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