src/bin/proxmox-backup-proxy.rs

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