src/bin/proxmox-backup-proxy.rs

   1 use std::sync::Arc;
   2 use std::path::{Path, PathBuf};
   3 use std::os::unix::io::AsRawFd;
   4
   5 use anyhow::{bail, format_err, Error};
   6 use futures::*;
   7 use hyper;
   8 use openssl::ssl::{SslMethod, SslAcceptor, SslFiletype};
   9
  10 use proxmox::try_block;
  11 use proxmox::api::RpcEnvironmentType;
  12
  13 use proxmox_backup::{
  14     backup::DataStore,
  15     server::{
  16         WorkerTask,
  17         ApiConfig,
  18         rest::*,
  19         jobstate::{
  20             self,
  21             Job,
  22         },
  23         rotate_task_log_archive,
  24     },
  25     tools::systemd::time::{
  26         parse_calendar_event,
  27         compute_next_event,
  28     },
  29 };
  30
  31
  32 use proxmox_backup::api2::types::Authid;
  33 use proxmox_backup::configdir;
  34 use proxmox_backup::buildcfg;
  35 use proxmox_backup::server;
  36 use proxmox_backup::auth_helpers::*;
  37 use proxmox_backup::tools::{
  38     daemon,
  39     disks::{
  40         DiskManage,
  41         zfs_pool_stats,
  42     },
  43     logrotate::LogRotate,
  44     socket::{
  45         set_tcp_keepalive,
  46         PROXMOX_BACKUP_TCP_KEEPALIVE_TIME,
  47     },
  48 };
  49
  50 use proxmox_backup::api2::pull::do_sync_job;
  51 use proxmox_backup::server::do_verification_job;
  52 use proxmox_backup::server::do_prune_job;
  53
  54 fn main() -> Result<(), Error> {
  55     proxmox_backup::tools::setup_safe_path_env();
  56
  57     let backup_uid = proxmox_backup::backup::backup_user()?.uid;
  58     let backup_gid = proxmox_backup::backup::backup_group()?.gid;
  59     let running_uid = nix::unistd::Uid::effective();
  60     let running_gid = nix::unistd::Gid::effective();
  61
  62     if running_uid != backup_uid || running_gid != backup_gid {
  63         bail!("proxy not running as backup user or group (got uid {} gid {})", running_uid, running_gid);
  64     }
  65
  66     proxmox_backup::tools::runtime::main(run())
  67 }
  68
  69 async fn run() -> Result<(), Error> {
  70     if let Err(err) = syslog::init(
  71         syslog::Facility::LOG_DAEMON,
  72         log::LevelFilter::Info,
  73         Some("proxmox-backup-proxy")) {
  74         bail!("unable to inititialize syslog - {}", err);
  75     }
  76
  77     // Note: To debug early connection error use
  78     // PROXMOX_DEBUG=1 ./target/release/proxmox-backup-proxy
  79     let debug = std::env::var("PROXMOX_DEBUG").is_ok();
  80
  81     let _ = public_auth_key(); // load with lazy_static
  82     let _ = csrf_secret(); // load with lazy_static
  83
  84     let mut config = ApiConfig::new(
  85         buildcfg::JS_DIR, &proxmox_backup::api2::ROUTER, RpcEnvironmentType::PUBLIC)?;
  86
  87     config.add_alias("novnc", "/usr/share/novnc-pve");
  88     config.add_alias("extjs", "/usr/share/javascript/extjs");
  89     config.add_alias("fontawesome", "/usr/share/fonts-font-awesome");
  90     config.add_alias("xtermjs", "/usr/share/pve-xtermjs");
  91     config.add_alias("locale", "/usr/share/pbs-i18n");
  92     config.add_alias("widgettoolkit", "/usr/share/javascript/proxmox-widget-toolkit");
  93     config.add_alias("css", "/usr/share/javascript/proxmox-backup/css");
  94     config.add_alias("docs", "/usr/share/doc/proxmox-backup/html");
  95
  96     let mut indexpath = PathBuf::from(buildcfg::JS_DIR);
  97     indexpath.push("index.hbs");
  98     config.register_template("index", &indexpath)?;
  99     config.register_template("console", "/usr/share/pve-xtermjs/index.html.hbs")?;
 100
 101     let mut commando_sock = server::CommandoSocket::new(server::our_ctrl_sock());
 102
 103     config.enable_file_log(buildcfg::API_ACCESS_LOG_FN, &mut commando_sock)?;
 104
 105     let rest_server = RestServer::new(config);
 106
 107     //openssl req -x509 -newkey rsa:4096 -keyout /etc/proxmox-backup/proxy.key -out /etc/proxmox-backup/proxy.pem -nodes
 108     let key_path = configdir!("/proxy.key");
 109     let cert_path = configdir!("/proxy.pem");
 110
 111     let mut acceptor = SslAcceptor::mozilla_intermediate_v5(SslMethod::tls()).unwrap();
 112     acceptor.set_private_key_file(key_path, SslFiletype::PEM)
 113         .map_err(|err| format_err!("unable to read proxy key {} - {}", key_path, err))?;
 114     acceptor.set_certificate_chain_file(cert_path)
 115         .map_err(|err| format_err!("unable to read proxy cert {} - {}", cert_path, err))?;
 116     acceptor.check_private_key().unwrap();
 117
 118     let acceptor = Arc::new(acceptor.build());
 119
 120     let server = daemon::create_daemon(
 121         ([0,0,0,0,0,0,0,0], 8007).into(),
 122         |listener, ready| {
 123
 124             let connections = accept_connections(listener, acceptor, debug);
 125             let connections = hyper::server::accept::from_stream(connections);
 126
 127             Ok(ready
 128                .and_then(|_| hyper::Server::builder(connections)
 129                     .serve(rest_server)
 130                     .with_graceful_shutdown(server::shutdown_future())
 131                     .map_err(Error::from)
 132                 )
 133                 .map_err(|err| eprintln!("server error: {}", err))
 134                 .map(|_| ())
 135             )
 136         },
 137     );
 138
 139     server::write_pid(buildcfg::PROXMOX_BACKUP_PROXY_PID_FN)?;
 140     daemon::systemd_notify(daemon::SystemdNotify::Ready)?;
 141
 142     let init_result: Result<(), Error> = try_block!({
 143         server::register_task_control_commands(&mut commando_sock)?;
 144         commando_sock.spawn()?;
 145         server::server_state_init()?;
 146         Ok(())
 147     });
 148
 149     if let Err(err) = init_result {
 150         bail!("unable to start daemon - {}", err);
 151     }
 152
 153     start_task_scheduler();
 154     start_stat_generator();
 155
 156     server.await?;
 157     log::info!("server shutting down, waiting for active workers to complete");
 158     proxmox_backup::server::last_worker_future().await?;
 159     log::info!("done - exit server");
 160
 161     Ok(())
 162 }
 163
 164 fn accept_connections(
 165     mut listener: tokio::net::TcpListener,
 166     acceptor: Arc<openssl::ssl::SslAcceptor>,
 167     debug: bool,
 168 ) -> tokio::sync::mpsc::Receiver<Result<tokio_openssl::SslStream<tokio::net::TcpStream>, Error>> {
 169
 170     const MAX_PENDING_ACCEPTS: usize = 1024;
 171
 172     let (sender, receiver) = tokio::sync::mpsc::channel(MAX_PENDING_ACCEPTS);
 173
 174     let accept_counter = Arc::new(());
 175
 176     tokio::spawn(async move {
 177         loop {
 178             match listener.accept().await {
 179                 Err(err) => {
 180                     eprintln!("error accepting tcp connection: {}", err);
 181                 }
 182                 Ok((sock, _addr)) =>  {
 183                     sock.set_nodelay(true).unwrap();
 184                     let _ = set_tcp_keepalive(sock.as_raw_fd(), PROXMOX_BACKUP_TCP_KEEPALIVE_TIME);
 185                     let acceptor = Arc::clone(&acceptor);
 186                     let mut sender = sender.clone();
 187
 188                     if Arc::strong_count(&accept_counter) > MAX_PENDING_ACCEPTS {
 189                         eprintln!("connection rejected - to many open connections");
 190                         continue;
 191                     }
 192
 193                     let accept_counter = accept_counter.clone();
 194                     tokio::spawn(async move {
 195                         let accept_future = tokio::time::timeout(
 196                             Duration::new(10, 0), tokio_openssl::accept(&acceptor, sock));
 197
 198                         let result = accept_future.await;
 199
 200                         match result {
 201                             Ok(Ok(connection)) => {
 202                                 if let Err(_) = sender.send(Ok(connection)).await {
 203                                     if debug {
 204                                         eprintln!("detect closed connection channel");
 205                                     }
 206                                 }
 207                             }
 208                             Ok(Err(err)) => {
 209                                 if debug {
 210                                     eprintln!("https handshake failed - {}", err);
 211                                 }
 212                             }
 213                             Err(_) => {
 214                                 if debug {
 215                                     eprintln!("https handshake timeout");
 216                                 }
 217                             }
 218                         }
 219
 220                         drop(accept_counter); // decrease reference count
 221                     });
 222                 }
 223             }
 224         }
 225     });
 226
 227     receiver
 228 }
 229
 230 fn start_stat_generator() {
 231     let abort_future = server::shutdown_future();
 232     let future = Box::pin(run_stat_generator());
 233     let task = futures::future::select(future, abort_future);
 234     tokio::spawn(task.map(|_| ()));
 235 }
 236
 237 fn start_task_scheduler() {
 238     let abort_future = server::shutdown_future();
 239     let future = Box::pin(run_task_scheduler());
 240     let task = futures::future::select(future, abort_future);
 241     tokio::spawn(task.map(|_| ()));
 242 }
 243
 244 use std::time::{SystemTime, Instant, Duration, UNIX_EPOCH};
 245
 246 fn next_minute() -> Result<Instant, Error> {
 247     let now = SystemTime::now();
 248     let epoch_now = now.duration_since(UNIX_EPOCH)?;
 249     let epoch_next = Duration::from_secs((epoch_now.as_secs()/60  + 1)*60);
 250     Ok(Instant::now() + epoch_next - epoch_now)
 251 }
 252
 253 async fn run_task_scheduler() {
 254
 255     let mut count: usize = 0;
 256
 257     loop {
 258         count += 1;
 259
 260         let delay_target = match next_minute() {  // try to run very minute
 261             Ok(d) => d,
 262             Err(err) => {
 263                 eprintln!("task scheduler: compute next minute failed - {}", err);
 264                 tokio::time::delay_until(tokio::time::Instant::from_std(Instant::now() + Duration::from_secs(60))).await;
 265                 continue;
 266             }
 267         };
 268
 269         if count > 2 { // wait 1..2 minutes before starting
 270             match schedule_tasks().catch_unwind().await {
 271                 Err(panic) => {
 272                     match panic.downcast::<&str>() {
 273                         Ok(msg) => {
 274                             eprintln!("task scheduler panic: {}", msg);
 275                         }
 276                         Err(_) => {
 277                             eprintln!("task scheduler panic - unknown type");
 278                         }
 279                     }
 280                 }
 281                 Ok(Err(err)) => {
 282                     eprintln!("task scheduler failed - {:?}", err);
 283                 }
 284                 Ok(Ok(_)) => {}
 285             }
 286         }
 287
 288         tokio::time::delay_until(tokio::time::Instant::from_std(delay_target)).await;
 289     }
 290 }
 291
 292 async fn schedule_tasks() -> Result<(), Error> {
 293
 294     schedule_datastore_garbage_collection().await;
 295     schedule_datastore_prune().await;
 296     schedule_datastore_sync_jobs().await;
 297     schedule_datastore_verify_jobs().await;
 298     schedule_task_log_rotate().await;
 299
 300     Ok(())
 301 }
 302
 303 async fn schedule_datastore_garbage_collection() {
 304
 305     use proxmox_backup::config::{
 306         datastore::{
 307             self,
 308             DataStoreConfig,
 309         },
 310     };
 311
 312     let config = match datastore::config() {
 313         Err(err) => {
 314             eprintln!("unable to read datastore config - {}", err);
 315             return;
 316         }
 317         Ok((config, _digest)) => config,
 318     };
 319
 320     for (store, (_, store_config)) in config.sections {
 321         let datastore = match DataStore::lookup_datastore(&store) {
 322             Ok(datastore) => datastore,
 323             Err(err) => {
 324                 eprintln!("lookup_datastore failed - {}", err);
 325                 continue;
 326             }
 327         };
 328
 329         let store_config: DataStoreConfig = match serde_json::from_value(store_config) {
 330             Ok(c) => c,
 331             Err(err) => {
 332                 eprintln!("datastore config from_value failed - {}", err);
 333                 continue;
 334             }
 335         };
 336
 337         let event_str = match store_config.gc_schedule {
 338             Some(event_str) => event_str,
 339             None => continue,
 340         };
 341
 342         let event = match parse_calendar_event(&event_str) {
 343             Ok(event) => event,
 344             Err(err) => {
 345                 eprintln!("unable to parse schedule '{}' - {}", event_str, err);
 346                 continue;
 347             }
 348         };
 349
 350         if datastore.garbage_collection_running() { continue; }
 351
 352         let worker_type = "garbage_collection";
 353
 354         let last = match jobstate::last_run_time(worker_type, &store) {
 355             Ok(time) => time,
 356             Err(err) => {
 357                 eprintln!("could not get last run time of {} {}: {}", worker_type, store, err);
 358                 continue;
 359             }
 360         };
 361
 362         let next = match compute_next_event(&event, last, false) {
 363             Ok(Some(next)) => next,
 364             Ok(None) => continue,
 365             Err(err) => {
 366                 eprintln!("compute_next_event for '{}' failed - {}", event_str, err);
 367                 continue;
 368             }
 369         };
 370
 371         let now = proxmox::tools::time::epoch_i64();
 372
 373         if next > now  { continue; }
 374
 375         let job = match Job::new(worker_type, &store) {
 376             Ok(job) => job,
 377             Err(_) => continue, // could not get lock
 378         };
 379
 380         let auth_id = Authid::backup_auth_id();
 381
 382         if let Err(err) = crate::server::do_garbage_collection_job(job, datastore, auth_id, Some(event_str), false) {
 383             eprintln!("unable to start garbage collection job on datastore {} - {}", store, err);
 384         }
 385     }
 386 }
 387
 388 async fn schedule_datastore_prune() {
 389
 390     use proxmox_backup::{
 391         backup::{
 392             PruneOptions,
 393         },
 394         config::datastore::{
 395             self,
 396             DataStoreConfig,
 397         },
 398     };
 399
 400     let config = match datastore::config() {
 401         Err(err) => {
 402             eprintln!("unable to read datastore config - {}", err);
 403             return;
 404         }
 405         Ok((config, _digest)) => config,
 406     };
 407
 408     for (store, (_, store_config)) in config.sections {
 409
 410         let store_config: DataStoreConfig = match serde_json::from_value(store_config) {
 411             Ok(c) => c,
 412             Err(err) => {
 413                 eprintln!("datastore '{}' config from_value failed - {}", store, err);
 414                 continue;
 415             }
 416         };
 417
 418         let event_str = match store_config.prune_schedule {
 419             Some(event_str) => event_str,
 420             None => continue,
 421         };
 422
 423         let prune_options = PruneOptions {
 424             keep_last: store_config.keep_last,
 425             keep_hourly: store_config.keep_hourly,
 426             keep_daily:  store_config.keep_daily,
 427             keep_weekly: store_config.keep_weekly,
 428             keep_monthly: store_config.keep_monthly,
 429             keep_yearly: store_config.keep_yearly,
 430         };
 431
 432         if !prune_options.keeps_something() { // no prune settings - keep all
 433             continue;
 434         }
 435
 436         let worker_type = "prune";
 437         if check_schedule(worker_type, &event_str, &store) {
 438             let job = match Job::new(worker_type, &store) {
 439                 Ok(job) => job,
 440                 Err(_) => continue, // could not get lock
 441             };
 442
 443             let auth_id = Authid::backup_auth_id().clone();
 444             if let Err(err) = do_prune_job(job, prune_options, store.clone(), &auth_id, Some(event_str)) {
 445                 eprintln!("unable to start datastore prune job {} - {}", &store, err);
 446             }
 447         };
 448     }
 449 }
 450
 451 async fn schedule_datastore_sync_jobs() {
 452
 453     use proxmox_backup::config::sync::{
 454         self,
 455         SyncJobConfig,
 456     };
 457
 458     let config = match sync::config() {
 459         Err(err) => {
 460             eprintln!("unable to read sync job config - {}", err);
 461             return;
 462         }
 463         Ok((config, _digest)) => config,
 464     };
 465
 466     for (job_id, (_, job_config)) in config.sections {
 467         let job_config: SyncJobConfig = match serde_json::from_value(job_config) {
 468             Ok(c) => c,
 469             Err(err) => {
 470                 eprintln!("sync job config from_value failed - {}", err);
 471                 continue;
 472             }
 473         };
 474
 475         let event_str = match job_config.schedule {
 476             Some(ref event_str) => event_str.clone(),
 477             None => continue,
 478         };
 479
 480         let worker_type = "syncjob";
 481         if check_schedule(worker_type, &event_str, &job_id) {
 482             let job = match Job::new(worker_type, &job_id) {
 483                 Ok(job) => job,
 484                 Err(_) => continue, // could not get lock
 485             };
 486
 487             let auth_id = Authid::backup_auth_id().clone();
 488             if let Err(err) = do_sync_job(job, job_config, &auth_id, Some(event_str)) {
 489                 eprintln!("unable to start datastore sync job {} - {}", &job_id, err);
 490             }
 491         };
 492     }
 493 }
 494
 495 async fn schedule_datastore_verify_jobs() {
 496
 497     use proxmox_backup::config::verify::{
 498         self,
 499         VerificationJobConfig,
 500     };
 501
 502     let config = match verify::config() {
 503         Err(err) => {
 504             eprintln!("unable to read verification job config - {}", err);
 505             return;
 506         }
 507         Ok((config, _digest)) => config,
 508     };
 509     for (job_id, (_, job_config)) in config.sections {
 510         let job_config: VerificationJobConfig = match serde_json::from_value(job_config) {
 511             Ok(c) => c,
 512             Err(err) => {
 513                 eprintln!("verification job config from_value failed - {}", err);
 514                 continue;
 515             }
 516         };
 517         let event_str = match job_config.schedule {
 518             Some(ref event_str) => event_str.clone(),
 519             None => continue,
 520         };
 521
 522         let worker_type = "verificationjob";
 523         let auth_id = Authid::backup_auth_id().clone();
 524         if check_schedule(worker_type, &event_str, &job_id) {
 525             let job = match Job::new(&worker_type, &job_id) {
 526                 Ok(job) => job,
 527                 Err(_) => continue, // could not get lock
 528             };
 529             if let Err(err) = do_verification_job(job, job_config, &auth_id, Some(event_str)) {
 530                 eprintln!("unable to start datastore verification job {} - {}", &job_id, err);
 531             }
 532         };
 533     }
 534 }
 535
 536 async fn schedule_task_log_rotate() {
 537
 538     let worker_type = "logrotate";
 539     let job_id = "access-log_and_task-archive";
 540
 541     // schedule daily at 00:00 like normal logrotate
 542     let schedule = "00:00";
 543
 544     if !check_schedule(worker_type, schedule, job_id) {
 545         // if we never ran the rotation, schedule instantly
 546         match jobstate::JobState::load(worker_type, job_id) {
 547             Ok(state) => match state {
 548                 jobstate::JobState::Created { .. } => {},
 549                 _ => return,
 550             },
 551             _ => return,
 552         }
 553     }
 554
 555     let mut job = match Job::new(worker_type, job_id) {
 556         Ok(job) => job,
 557         Err(_) => return, // could not get lock
 558     };
 559
 560     if let Err(err) = WorkerTask::new_thread(
 561         worker_type,
 562         None,
 563         Authid::backup_auth_id().clone(),
 564         false,
 565         move |worker| {
 566             job.start(&worker.upid().to_string())?;
 567             worker.log(format!("starting task log rotation"));
 568
 569             let result = try_block!({
 570                 let max_size = 512 * 1024 - 1; // an entry has ~ 100b, so > 5000 entries/file
 571                 let max_files = 20; // times twenty files gives > 100000 task entries
 572                 let has_rotated = rotate_task_log_archive(max_size, true, Some(max_files))?;
 573                 if has_rotated {
 574                     worker.log(format!("task log archive was rotated"));
 575                 } else {
 576                     worker.log(format!("task log archive was not rotated"));
 577                 }
 578
 579                 let max_size = 32 * 1024 * 1024 - 1;
 580                 let max_files = 14;
 581                 let mut logrotate = LogRotate::new(buildcfg::API_ACCESS_LOG_FN, true)
 582                         .ok_or_else(|| format_err!("could not get API access log file names"))?;
 583
 584                 let has_rotated = logrotate.rotate(max_size, None, Some(max_files))?;
 585                 if has_rotated {
 586                     println!("rotated access log, telling daemons to re-open log file");
 587                     proxmox_backup::tools::runtime::block_on(command_reopen_logfiles())?;
 588
 589                     worker.log(format!("API access log was rotated"));
 590                 } else {
 591                     worker.log(format!("API access log was not rotated"));
 592                 }
 593
 594                 Ok(())
 595             });
 596
 597             let status = worker.create_state(&result);
 598
 599             if let Err(err) = job.finish(status) {
 600                 eprintln!("could not finish job state for {}: {}", worker_type, err);
 601             }
 602
 603             result
 604         },
 605     ) {
 606         eprintln!("unable to start task log rotation: {}", err);
 607     }
 608
 609 }
 610
 611 async fn command_reopen_logfiles() -> Result<(), Error> {
 612     // only care about the most recent daemon instance for each, proxy & api, as other older ones
 613     // should not respond to new requests anyway, but only finish their current one and then exit.
 614     let sock = server::our_ctrl_sock();
 615     let f1 = server::send_command(sock, serde_json::json!({
 616         "command": "api-access-log-reopen",
 617     }));
 618
 619     let pid = server::read_pid(buildcfg::PROXMOX_BACKUP_API_PID_FN)?;
 620     let sock = server::ctrl_sock_from_pid(pid);
 621     let f2 = server::send_command(sock, serde_json::json!({
 622         "command": "api-access-log-reopen",
 623     }));
 624
 625     match futures::join!(f1, f2) {
 626         (Err(e1), Err(e2)) => Err(format_err!("reopen commands failed, proxy: {}; api: {}", e1, e2)),
 627         (Err(e1), Ok(_)) => Err(format_err!("reopen commands failed, proxy: {}", e1)),
 628         (Ok(_), Err(e2)) => Err(format_err!("reopen commands failed, api: {}", e2)),
 629         _ => Ok(()),
 630     }
 631 }
 632
 633 async fn run_stat_generator() {
 634
 635     let mut count = 0;
 636     loop {
 637         count += 1;
 638         let save = if count >= 6 { count = 0; true } else { false };
 639
 640         let delay_target = Instant::now() +  Duration::from_secs(10);
 641
 642         generate_host_stats(save).await;
 643
 644         tokio::time::delay_until(tokio::time::Instant::from_std(delay_target)).await;
 645
 646      }
 647
 648 }
 649
 650 fn rrd_update_gauge(name: &str, value: f64, save: bool) {
 651     use proxmox_backup::rrd;
 652     if let Err(err) = rrd::update_value(name, value, rrd::DST::Gauge, save) {
 653         eprintln!("rrd::update_value '{}' failed - {}", name, err);
 654     }
 655 }
 656
 657 fn rrd_update_derive(name: &str, value: f64, save: bool) {
 658     use proxmox_backup::rrd;
 659     if let Err(err) = rrd::update_value(name, value, rrd::DST::Derive, save) {
 660         eprintln!("rrd::update_value '{}' failed - {}", name, err);
 661     }
 662 }
 663
 664 async fn generate_host_stats(save: bool) {
 665     use proxmox::sys::linux::procfs::{
 666         read_meminfo, read_proc_stat, read_proc_net_dev, read_loadavg};
 667     use proxmox_backup::config::datastore;
 668
 669
 670     proxmox_backup::tools::runtime::block_in_place(move || {
 671
 672         match read_proc_stat() {
 673             Ok(stat) => {
 674                 rrd_update_gauge("host/cpu", stat.cpu, save);
 675                 rrd_update_gauge("host/iowait", stat.iowait_percent, save);
 676             }
 677             Err(err) => {
 678                 eprintln!("read_proc_stat failed - {}", err);
 679             }
 680         }
 681
 682         match read_meminfo() {
 683             Ok(meminfo) => {
 684                 rrd_update_gauge("host/memtotal", meminfo.memtotal as f64, save);
 685                 rrd_update_gauge("host/memused", meminfo.memused as f64, save);
 686                 rrd_update_gauge("host/swaptotal", meminfo.swaptotal as f64, save);
 687                 rrd_update_gauge("host/swapused", meminfo.swapused as f64, save);
 688             }
 689             Err(err) => {
 690                 eprintln!("read_meminfo failed - {}", err);
 691             }
 692         }
 693
 694         match read_proc_net_dev() {
 695             Ok(netdev) => {
 696                 use proxmox_backup::config::network::is_physical_nic;
 697                 let mut netin = 0;
 698                 let mut netout = 0;
 699                 for item in netdev {
 700                     if !is_physical_nic(&item.device) { continue; }
 701                     netin += item.receive;
 702                     netout += item.send;
 703                 }
 704                 rrd_update_derive("host/netin", netin as f64, save);
 705                 rrd_update_derive("host/netout", netout as f64, save);
 706             }
 707             Err(err) => {
 708                 eprintln!("read_prox_net_dev failed - {}", err);
 709             }
 710         }
 711
 712         match read_loadavg() {
 713             Ok(loadavg) => {
 714                 rrd_update_gauge("host/loadavg", loadavg.0 as f64, save);
 715             }
 716             Err(err) => {
 717                 eprintln!("read_loadavg failed - {}", err);
 718             }
 719         }
 720
 721         let disk_manager = DiskManage::new();
 722
 723         gather_disk_stats(disk_manager.clone(), Path::new("/"), "host", save);
 724
 725         match datastore::config() {
 726             Ok((config, _)) => {
 727                 let datastore_list: Vec<datastore::DataStoreConfig> =
 728                     config.convert_to_typed_array("datastore").unwrap_or(Vec::new());
 729
 730                 for config in datastore_list {
 731
 732                     let rrd_prefix = format!("datastore/{}", config.name);
 733                     let path = std::path::Path::new(&config.path);
 734                     gather_disk_stats(disk_manager.clone(), path, &rrd_prefix, save);
 735                 }
 736             }
 737             Err(err) => {
 738                 eprintln!("read datastore config failed - {}", err);
 739             }
 740         }
 741
 742     });
 743 }
 744
 745 fn check_schedule(worker_type: &str, event_str: &str, id: &str) -> bool {
 746     let event = match parse_calendar_event(event_str) {
 747         Ok(event) => event,
 748         Err(err) => {
 749             eprintln!("unable to parse schedule '{}' - {}", event_str, err);
 750             return false;
 751         }
 752     };
 753
 754     let last = match jobstate::last_run_time(worker_type, &id) {
 755         Ok(time) => time,
 756         Err(err) => {
 757             eprintln!("could not get last run time of {} {}: {}", worker_type, id, err);
 758             return false;
 759         }
 760     };
 761
 762     let next = match compute_next_event(&event, last, false) {
 763         Ok(Some(next)) => next,
 764         Ok(None) => return false,
 765         Err(err) => {
 766             eprintln!("compute_next_event for '{}' failed - {}", event_str, err);
 767             return false;
 768         }
 769     };
 770
 771     let now = proxmox::tools::time::epoch_i64();
 772     next <= now
 773 }
 774
 775 fn gather_disk_stats(disk_manager: Arc<DiskManage>, path: &Path, rrd_prefix: &str, save: bool) {
 776
 777     match proxmox_backup::tools::disks::disk_usage(path) {
 778         Ok(status) => {
 779             let rrd_key = format!("{}/total", rrd_prefix);
 780             rrd_update_gauge(&rrd_key, status.total as f64, save);
 781             let rrd_key = format!("{}/used", rrd_prefix);
 782             rrd_update_gauge(&rrd_key, status.used as f64, save);
 783         }
 784         Err(err) => {
 785             eprintln!("read disk_usage on {:?} failed - {}", path, err);
 786         }
 787     }
 788
 789     match disk_manager.find_mounted_device(path) {
 790         Ok(None) => {},
 791         Ok(Some((fs_type, device, source))) => {
 792             let mut device_stat = None;
 793             match fs_type.as_str() {
 794                 "zfs" => {
 795                     if let Some(pool) = source {
 796                         match zfs_pool_stats(&pool) {
 797                             Ok(stat) => device_stat = stat,
 798                             Err(err) => eprintln!("zfs_pool_stats({:?}) failed - {}", pool, err),
 799                         }
 800                     }
 801                 }
 802                 _ => {
 803                     if let Ok(disk) = disk_manager.clone().disk_by_dev_num(device.into_dev_t()) {
 804                         match disk.read_stat() {
 805                             Ok(stat) => device_stat = stat,
 806                             Err(err) => eprintln!("disk.read_stat {:?} failed - {}", path, err),
 807                         }
 808                     }
 809                 }
 810             }
 811             if let Some(stat) = device_stat {
 812                 let rrd_key = format!("{}/read_ios", rrd_prefix);
 813                 rrd_update_derive(&rrd_key, stat.read_ios as f64, save);
 814                 let rrd_key = format!("{}/read_bytes", rrd_prefix);
 815                 rrd_update_derive(&rrd_key, (stat.read_sectors*512) as f64, save);
 816
 817                 let rrd_key = format!("{}/write_ios", rrd_prefix);
 818                 rrd_update_derive(&rrd_key, stat.write_ios as f64, save);
 819                 let rrd_key = format!("{}/write_bytes", rrd_prefix);
 820                 rrd_update_derive(&rrd_key, (stat.write_sectors*512) as f64, save);
 821
 822                 let rrd_key = format!("{}/io_ticks", rrd_prefix);
 823                 rrd_update_derive(&rrd_key, (stat.io_ticks as f64)/1000.0, save);
 824             }
 825         }
 826         Err(err) => {
 827             eprintln!("find_mounted_device failed - {}", err);
 828         }
 829     }
 830 }