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