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