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