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