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