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