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