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 use hyper;
   8 use openssl::ssl::{SslMethod, SslAcceptor, SslFiletype};
   9
  10 use proxmox::try_block;
  11 use proxmox::api::RpcEnvironmentType;
  12
  13 use proxmox_backup::{
  14     backup::DataStore,
  15     server::{
  16         UPID,
  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     socket::{
  45         set_tcp_keepalive,
  46         PROXMOX_BACKUP_TCP_KEEPALIVE_TIME,
  47     },
  48 };
  49
  50 use proxmox_backup::api2::pull::do_sync_job;
  51 use proxmox_backup::server::do_verification_job;
  52 use proxmox_backup::server::do_prune_job;
  53
  54 fn main() -> Result<(), Error> {
  55     proxmox_backup::tools::setup_safe_path_env();
  56
  57     let backup_uid = proxmox_backup::backup::backup_user()?.uid;
  58     let backup_gid = proxmox_backup::backup::backup_group()?.gid;
  59     let running_uid = nix::unistd::Uid::effective();
  60     let running_gid = nix::unistd::Gid::effective();
  61
  62     if running_uid != backup_uid || running_gid != backup_gid {
  63         bail!("proxy not running as backup user or group (got uid {} gid {})", running_uid, running_gid);
  64     }
  65
  66     proxmox_backup::tools::runtime::main(run())
  67 }
  68
  69 async fn run() -> Result<(), Error> {
  70     if let Err(err) = syslog::init(
  71         syslog::Facility::LOG_DAEMON,
  72         log::LevelFilter::Info,
  73         Some("proxmox-backup-proxy")) {
  74         bail!("unable to inititialize syslog - {}", err);
  75     }
  76
  77     let _ = public_auth_key(); // load with lazy_static
  78     let _ = csrf_secret(); // load with lazy_static
  79
  80     let mut config = ApiConfig::new(
  81         buildcfg::JS_DIR, &proxmox_backup::api2::ROUTER, RpcEnvironmentType::PUBLIC)?;
  82
  83     config.add_alias("novnc", "/usr/share/novnc-pve");
  84     config.add_alias("extjs", "/usr/share/javascript/extjs");
  85     config.add_alias("fontawesome", "/usr/share/fonts-font-awesome");
  86     config.add_alias("xtermjs", "/usr/share/pve-xtermjs");
  87     config.add_alias("locale", "/usr/share/pbs-i18n");
  88     config.add_alias("widgettoolkit", "/usr/share/javascript/proxmox-widget-toolkit");
  89     config.add_alias("css", "/usr/share/javascript/proxmox-backup/css");
  90     config.add_alias("docs", "/usr/share/doc/proxmox-backup/html");
  91
  92     let mut indexpath = PathBuf::from(buildcfg::JS_DIR);
  93     indexpath.push("index.hbs");
  94     config.register_template("index", &indexpath)?;
  95     config.register_template("console", "/usr/share/pve-xtermjs/index.html.hbs")?;
  96
  97     let mut commando_sock = server::CommandoSocket::new(server::our_ctrl_sock());
  98
  99     config.enable_file_log(buildcfg::API_ACCESS_LOG_FN)?;
 100
 101     let rest_server = RestServer::new(config);
 102
 103     //openssl req -x509 -newkey rsa:4096 -keyout /etc/proxmox-backup/proxy.key -out /etc/proxmox-backup/proxy.pem -nodes
 104     let key_path = configdir!("/proxy.key");
 105     let cert_path = configdir!("/proxy.pem");
 106
 107     let mut acceptor = SslAcceptor::mozilla_intermediate_v5(SslMethod::tls()).unwrap();
 108     acceptor.set_private_key_file(key_path, SslFiletype::PEM)
 109         .map_err(|err| format_err!("unable to read proxy key {} - {}", key_path, err))?;
 110     acceptor.set_certificate_chain_file(cert_path)
 111         .map_err(|err| format_err!("unable to read proxy cert {} - {}", cert_path, err))?;
 112     acceptor.check_private_key().unwrap();
 113
 114     let acceptor = Arc::new(acceptor.build());
 115
 116     let server = daemon::create_daemon(
 117         ([0,0,0,0,0,0,0,0], 8007).into(),
 118         |listener, ready| {
 119             let connections = proxmox_backup::tools::async_io::StaticIncoming::from(listener)
 120                 .map_err(Error::from)
 121                 .try_filter_map(move |(sock, _addr)| {
 122                     let acceptor = Arc::clone(&acceptor);
 123                     async move {
 124                         sock.set_nodelay(true).unwrap();
 125
 126                         let _ = set_tcp_keepalive(sock.as_raw_fd(), PROXMOX_BACKUP_TCP_KEEPALIVE_TIME);
 127
 128                         Ok(tokio_openssl::accept(&acceptor, sock)
 129                             .await
 130                             .ok() // handshake errors aren't be fatal, so return None to filter
 131                         )
 132                     }
 133                 });
 134             let connections = proxmox_backup::tools::async_io::HyperAccept(connections);
 135
 136             Ok(ready
 137                 .and_then(|_| hyper::Server::builder(connections)
 138                     .serve(rest_server)
 139                     .with_graceful_shutdown(server::shutdown_future())
 140                     .map_err(Error::from)
 141                 )
 142                 .map_err(|err| eprintln!("server error: {}", err))
 143                 .map(|_| ())
 144             )
 145         },
 146     );
 147
 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 start_stat_generator() {
 173     let abort_future = server::shutdown_future();
 174     let future = Box::pin(run_stat_generator());
 175     let task = futures::future::select(future, abort_future);
 176     tokio::spawn(task.map(|_| ()));
 177 }
 178
 179 fn start_task_scheduler() {
 180     let abort_future = server::shutdown_future();
 181     let future = Box::pin(run_task_scheduler());
 182     let task = futures::future::select(future, abort_future);
 183     tokio::spawn(task.map(|_| ()));
 184 }
 185
 186 use std::time::{SystemTime, Instant, Duration, UNIX_EPOCH};
 187
 188 fn next_minute() -> Result<Instant, Error> {
 189     let now = SystemTime::now();
 190     let epoch_now = now.duration_since(UNIX_EPOCH)?;
 191     let epoch_next = Duration::from_secs((epoch_now.as_secs()/60  + 1)*60);
 192     Ok(Instant::now() + epoch_next - epoch_now)
 193 }
 194
 195 async fn run_task_scheduler() {
 196
 197     let mut count: usize = 0;
 198
 199     loop {
 200         count += 1;
 201
 202         let delay_target = match next_minute() {  // try to run very minute
 203             Ok(d) => d,
 204             Err(err) => {
 205                 eprintln!("task scheduler: compute next minute failed - {}", err);
 206                 tokio::time::delay_until(tokio::time::Instant::from_std(Instant::now() + Duration::from_secs(60))).await;
 207                 continue;
 208             }
 209         };
 210
 211         if count > 2 { // wait 1..2 minutes before starting
 212             match schedule_tasks().catch_unwind().await {
 213                 Err(panic) => {
 214                     match panic.downcast::<&str>() {
 215                         Ok(msg) => {
 216                             eprintln!("task scheduler panic: {}", msg);
 217                         }
 218                         Err(_) => {
 219                             eprintln!("task scheduler panic - unknown type");
 220                         }
 221                     }
 222                 }
 223                 Ok(Err(err)) => {
 224                     eprintln!("task scheduler failed - {:?}", err);
 225                 }
 226                 Ok(Ok(_)) => {}
 227             }
 228         }
 229
 230         tokio::time::delay_until(tokio::time::Instant::from_std(delay_target)).await;
 231     }
 232 }
 233
 234 async fn schedule_tasks() -> Result<(), Error> {
 235
 236     schedule_datastore_garbage_collection().await;
 237     schedule_datastore_prune().await;
 238     schedule_datastore_sync_jobs().await;
 239     schedule_datastore_verify_jobs().await;
 240     schedule_task_log_rotate().await;
 241
 242     Ok(())
 243 }
 244
 245 async fn schedule_datastore_garbage_collection() {
 246
 247     use proxmox_backup::config::{
 248         datastore::{
 249             self,
 250             DataStoreConfig,
 251         },
 252     };
 253
 254     let config = match datastore::config() {
 255         Err(err) => {
 256             eprintln!("unable to read datastore config - {}", err);
 257             return;
 258         }
 259         Ok((config, _digest)) => config,
 260     };
 261
 262     for (store, (_, store_config)) in config.sections {
 263         let datastore = match DataStore::lookup_datastore(&store) {
 264             Ok(datastore) => datastore,
 265             Err(err) => {
 266                 eprintln!("lookup_datastore failed - {}", err);
 267                 continue;
 268             }
 269         };
 270
 271         let store_config: DataStoreConfig = match serde_json::from_value(store_config) {
 272             Ok(c) => c,
 273             Err(err) => {
 274                 eprintln!("datastore config from_value failed - {}", err);
 275                 continue;
 276             }
 277         };
 278
 279         let event_str = match store_config.gc_schedule {
 280             Some(event_str) => event_str,
 281             None => continue,
 282         };
 283
 284         let event = match parse_calendar_event(&event_str) {
 285             Ok(event) => event,
 286             Err(err) => {
 287                 eprintln!("unable to parse schedule '{}' - {}", event_str, err);
 288                 continue;
 289             }
 290         };
 291
 292         if datastore.garbage_collection_running() { continue; }
 293
 294         let worker_type = "garbage_collection";
 295
 296         let stat = datastore.last_gc_status();
 297         let last = if let Some(upid_str) = stat.upid {
 298             match upid_str.parse::<UPID>() {
 299                 Ok(upid) => upid.starttime,
 300                 Err(err) => {
 301                     eprintln!("unable to parse upid '{}' - {}", upid_str, err);
 302                     continue;
 303                 }
 304             }
 305         } else {
 306             match jobstate::last_run_time(worker_type, &store) {
 307                 Ok(time) => time,
 308                 Err(err) => {
 309                     eprintln!("could not get last run time of {} {}: {}", worker_type, store, err);
 310                     continue;
 311                 }
 312             }
 313         };
 314
 315         let next = match compute_next_event(&event, last, false) {
 316             Ok(Some(next)) => next,
 317             Ok(None) => continue,
 318             Err(err) => {
 319                 eprintln!("compute_next_event for '{}' failed - {}", event_str, err);
 320                 continue;
 321             }
 322         };
 323
 324         let now = proxmox::tools::time::epoch_i64();
 325
 326         if next > now  { continue; }
 327
 328         let job = match Job::new(worker_type, &store) {
 329             Ok(job) => job,
 330             Err(_) => continue, // could not get lock
 331         };
 332
 333         let auth_id = Authid::backup_auth_id();
 334
 335         if let Err(err) = crate::server::do_garbage_collection_job(job, datastore, auth_id, Some(event_str)) {
 336             eprintln!("unable to start garbage collection job on datastore {} - {}", store, err);
 337         }
 338     }
 339 }
 340
 341 async fn schedule_datastore_prune() {
 342
 343     use proxmox_backup::{
 344         backup::{
 345             PruneOptions,
 346         },
 347         config::datastore::{
 348             self,
 349             DataStoreConfig,
 350         },
 351     };
 352
 353     let config = match datastore::config() {
 354         Err(err) => {
 355             eprintln!("unable to read datastore config - {}", err);
 356             return;
 357         }
 358         Ok((config, _digest)) => config,
 359     };
 360
 361     for (store, (_, store_config)) in config.sections {
 362
 363         let store_config: DataStoreConfig = match serde_json::from_value(store_config) {
 364             Ok(c) => c,
 365             Err(err) => {
 366                 eprintln!("datastore '{}' config from_value failed - {}", store, err);
 367                 continue;
 368             }
 369         };
 370
 371         let event_str = match store_config.prune_schedule {
 372             Some(event_str) => event_str,
 373             None => continue,
 374         };
 375
 376         let prune_options = PruneOptions {
 377             keep_last: store_config.keep_last,
 378             keep_hourly: store_config.keep_hourly,
 379             keep_daily:  store_config.keep_daily,
 380             keep_weekly: store_config.keep_weekly,
 381             keep_monthly: store_config.keep_monthly,
 382             keep_yearly: store_config.keep_yearly,
 383         };
 384
 385         if !prune_options.keeps_something() { // no prune settings - keep all
 386             continue;
 387         }
 388
 389         let worker_type = "prune";
 390         if check_schedule(worker_type, &event_str, &store) {
 391             let job = match Job::new(worker_type, &store) {
 392                 Ok(job) => job,
 393                 Err(_) => continue, // could not get lock
 394             };
 395
 396             let auth_id = Authid::backup_auth_id().clone();
 397             if let Err(err) = do_prune_job(job, prune_options, store.clone(), &auth_id, Some(event_str)) {
 398                 eprintln!("unable to start datastore prune job {} - {}", &store, err);
 399             }
 400         };
 401     }
 402 }
 403
 404 async fn schedule_datastore_sync_jobs() {
 405
 406     use proxmox_backup::config::sync::{
 407         self,
 408         SyncJobConfig,
 409     };
 410
 411     let config = match sync::config() {
 412         Err(err) => {
 413             eprintln!("unable to read sync job config - {}", err);
 414             return;
 415         }
 416         Ok((config, _digest)) => config,
 417     };
 418
 419     for (job_id, (_, job_config)) in config.sections {
 420         let job_config: SyncJobConfig = match serde_json::from_value(job_config) {
 421             Ok(c) => c,
 422             Err(err) => {
 423                 eprintln!("sync job config from_value failed - {}", err);
 424                 continue;
 425             }
 426         };
 427
 428         let event_str = match job_config.schedule {
 429             Some(ref event_str) => event_str.clone(),
 430             None => continue,
 431         };
 432
 433         let worker_type = "syncjob";
 434         if check_schedule(worker_type, &event_str, &job_id) {
 435             let job = match Job::new(worker_type, &job_id) {
 436                 Ok(job) => job,
 437                 Err(_) => continue, // could not get lock
 438             };
 439
 440             let auth_id = Authid::backup_auth_id().clone();
 441             if let Err(err) = do_sync_job(job, job_config, &auth_id, Some(event_str)) {
 442                 eprintln!("unable to start datastore sync job {} - {}", &job_id, err);
 443             }
 444         };
 445     }
 446 }
 447
 448 async fn schedule_datastore_verify_jobs() {
 449
 450     use proxmox_backup::config::verify::{
 451         self,
 452         VerificationJobConfig,
 453     };
 454
 455     let config = match verify::config() {
 456         Err(err) => {
 457             eprintln!("unable to read verification job config - {}", err);
 458             return;
 459         }
 460         Ok((config, _digest)) => config,
 461     };
 462     for (job_id, (_, job_config)) in config.sections {
 463         let job_config: VerificationJobConfig = match serde_json::from_value(job_config) {
 464             Ok(c) => c,
 465             Err(err) => {
 466                 eprintln!("verification job config from_value failed - {}", err);
 467                 continue;
 468             }
 469         };
 470         let event_str = match job_config.schedule {
 471             Some(ref event_str) => event_str.clone(),
 472             None => continue,
 473         };
 474
 475         let worker_type = "verificationjob";
 476         let auth_id = Authid::backup_auth_id().clone();
 477         if check_schedule(worker_type, &event_str, &job_id) {
 478             let job = match Job::new(&worker_type, &job_id) {
 479                 Ok(job) => job,
 480                 Err(_) => continue, // could not get lock
 481             };
 482             if let Err(err) = do_verification_job(job, job_config, &auth_id, Some(event_str)) {
 483                 eprintln!("unable to start datastore verification job {} - {}", &job_id, err);
 484             }
 485         };
 486     }
 487 }
 488
 489 async fn schedule_task_log_rotate() {
 490
 491     let worker_type = "logrotate";
 492     let job_id = "task_archive";
 493
 494     // schedule daily at 00:00 like normal logrotate
 495     let schedule = "00:00";
 496
 497     if !check_schedule(worker_type, schedule, job_id) {
 498         // if we never ran the rotation, schedule instantly
 499         match jobstate::JobState::load(worker_type, job_id) {
 500             Ok(state) => match state {
 501                 jobstate::JobState::Created { .. } => {},
 502                 _ => return,
 503             },
 504             _ => return,
 505         }
 506     }
 507
 508     let mut job = match Job::new(worker_type, job_id) {
 509         Ok(job) => job,
 510         Err(_) => return, // could not get lock
 511     };
 512
 513     if let Err(err) = WorkerTask::new_thread(
 514         worker_type,
 515         Some(job_id.to_string()),
 516         Authid::backup_auth_id().clone(),
 517         false,
 518         move |worker| {
 519             job.start(&worker.upid().to_string())?;
 520             worker.log(format!("starting task log rotation"));
 521
 522             let result = try_block!({
 523                 // rotate task log archive
 524                 let max_size = 500000; // a normal entry has about 100b, so ~ 5000 entries/file
 525                 let max_files = 20; // times twenty files gives at least 100000 task entries
 526                 let has_rotated = rotate_task_log_archive(max_size, true, Some(max_files))?;
 527                 if has_rotated {
 528                     worker.log(format!("task log archive was rotated"));
 529                 } else {
 530                     worker.log(format!("task log archive was not rotated"));
 531                 }
 532
 533                 Ok(())
 534             });
 535
 536             let status = worker.create_state(&result);
 537
 538             if let Err(err) = job.finish(status) {
 539                 eprintln!("could not finish job state for {}: {}", worker_type, err);
 540             }
 541
 542             result
 543         },
 544     ) {
 545         eprintln!("unable to start task log rotation: {}", err);
 546     }
 547
 548 }
 549
 550 async fn run_stat_generator() {
 551
 552     let mut count = 0;
 553     loop {
 554         count += 1;
 555         let save = if count >= 6 { count = 0; true } else { false };
 556
 557         let delay_target = Instant::now() +  Duration::from_secs(10);
 558
 559         generate_host_stats(save).await;
 560
 561         tokio::time::delay_until(tokio::time::Instant::from_std(delay_target)).await;
 562
 563      }
 564
 565 }
 566
 567 fn rrd_update_gauge(name: &str, value: f64, save: bool) {
 568     use proxmox_backup::rrd;
 569     if let Err(err) = rrd::update_value(name, value, rrd::DST::Gauge, save) {
 570         eprintln!("rrd::update_value '{}' failed - {}", name, err);
 571     }
 572 }
 573
 574 fn rrd_update_derive(name: &str, value: f64, save: bool) {
 575     use proxmox_backup::rrd;
 576     if let Err(err) = rrd::update_value(name, value, rrd::DST::Derive, save) {
 577         eprintln!("rrd::update_value '{}' failed - {}", name, err);
 578     }
 579 }
 580
 581 async fn generate_host_stats(save: bool) {
 582     use proxmox::sys::linux::procfs::{
 583         read_meminfo, read_proc_stat, read_proc_net_dev, read_loadavg};
 584     use proxmox_backup::config::datastore;
 585
 586
 587     proxmox_backup::tools::runtime::block_in_place(move || {
 588
 589         match read_proc_stat() {
 590             Ok(stat) => {
 591                 rrd_update_gauge("host/cpu", stat.cpu, save);
 592                 rrd_update_gauge("host/iowait", stat.iowait_percent, save);
 593             }
 594             Err(err) => {
 595                 eprintln!("read_proc_stat failed - {}", err);
 596             }
 597         }
 598
 599         match read_meminfo() {
 600             Ok(meminfo) => {
 601                 rrd_update_gauge("host/memtotal", meminfo.memtotal as f64, save);
 602                 rrd_update_gauge("host/memused", meminfo.memused as f64, save);
 603                 rrd_update_gauge("host/swaptotal", meminfo.swaptotal as f64, save);
 604                 rrd_update_gauge("host/swapused", meminfo.swapused as f64, save);
 605             }
 606             Err(err) => {
 607                 eprintln!("read_meminfo failed - {}", err);
 608             }
 609         }
 610
 611         match read_proc_net_dev() {
 612             Ok(netdev) => {
 613                 use proxmox_backup::config::network::is_physical_nic;
 614                 let mut netin = 0;
 615                 let mut netout = 0;
 616                 for item in netdev {
 617                     if !is_physical_nic(&item.device) { continue; }
 618                     netin += item.receive;
 619                     netout += item.send;
 620                 }
 621                 rrd_update_derive("host/netin", netin as f64, save);
 622                 rrd_update_derive("host/netout", netout as f64, save);
 623             }
 624             Err(err) => {
 625                 eprintln!("read_prox_net_dev failed - {}", err);
 626             }
 627         }
 628
 629         match read_loadavg() {
 630             Ok(loadavg) => {
 631                 rrd_update_gauge("host/loadavg", loadavg.0 as f64, save);
 632             }
 633             Err(err) => {
 634                 eprintln!("read_loadavg failed - {}", err);
 635             }
 636         }
 637
 638         let disk_manager = DiskManage::new();
 639
 640         gather_disk_stats(disk_manager.clone(), Path::new("/"), "host", save);
 641
 642         match datastore::config() {
 643             Ok((config, _)) => {
 644                 let datastore_list: Vec<datastore::DataStoreConfig> =
 645                     config.convert_to_typed_array("datastore").unwrap_or(Vec::new());
 646
 647                 for config in datastore_list {
 648
 649                     let rrd_prefix = format!("datastore/{}", config.name);
 650                     let path = std::path::Path::new(&config.path);
 651                     gather_disk_stats(disk_manager.clone(), path, &rrd_prefix, save);
 652                 }
 653             }
 654             Err(err) => {
 655                 eprintln!("read datastore config failed - {}", err);
 656             }
 657         }
 658
 659     });
 660 }
 661
 662 fn check_schedule(worker_type: &str, event_str: &str, id: &str) -> bool {
 663     let event = match parse_calendar_event(event_str) {
 664         Ok(event) => event,
 665         Err(err) => {
 666             eprintln!("unable to parse schedule '{}' - {}", event_str, err);
 667             return false;
 668         }
 669     };
 670
 671     let last = match jobstate::last_run_time(worker_type, &id) {
 672         Ok(time) => time,
 673         Err(err) => {
 674             eprintln!("could not get last run time of {} {}: {}", worker_type, id, err);
 675             return false;
 676         }
 677     };
 678
 679     let next = match compute_next_event(&event, last, false) {
 680         Ok(Some(next)) => next,
 681         Ok(None) => return false,
 682         Err(err) => {
 683             eprintln!("compute_next_event for '{}' failed - {}", event_str, err);
 684             return false;
 685         }
 686     };
 687
 688     let now = proxmox::tools::time::epoch_i64();
 689     next <= now
 690 }
 691
 692 fn gather_disk_stats(disk_manager: Arc<DiskManage>, path: &Path, rrd_prefix: &str, save: bool) {
 693
 694     match proxmox_backup::tools::disks::disk_usage(path) {
 695         Ok(status) => {
 696             let rrd_key = format!("{}/total", rrd_prefix);
 697             rrd_update_gauge(&rrd_key, status.total as f64, save);
 698             let rrd_key = format!("{}/used", rrd_prefix);
 699             rrd_update_gauge(&rrd_key, status.used as f64, save);
 700         }
 701         Err(err) => {
 702             eprintln!("read disk_usage on {:?} failed - {}", path, err);
 703         }
 704     }
 705
 706     match disk_manager.find_mounted_device(path) {
 707         Ok(None) => {},
 708         Ok(Some((fs_type, device, source))) => {
 709             let mut device_stat = None;
 710             match fs_type.as_str() {
 711                 "zfs" => {
 712                     if let Some(pool) = source {
 713                         match zfs_pool_stats(&pool) {
 714                             Ok(stat) => device_stat = stat,
 715                             Err(err) => eprintln!("zfs_pool_stats({:?}) failed - {}", pool, err),
 716                         }
 717                     }
 718                 }
 719                 _ => {
 720                     if let Ok(disk) = disk_manager.clone().disk_by_dev_num(device.into_dev_t()) {
 721                         match disk.read_stat() {
 722                             Ok(stat) => device_stat = stat,
 723                             Err(err) => eprintln!("disk.read_stat {:?} failed - {}", path, err),
 724                         }
 725                     }
 726                 }
 727             }
 728             if let Some(stat) = device_stat {
 729                 let rrd_key = format!("{}/read_ios", rrd_prefix);
 730                 rrd_update_derive(&rrd_key, stat.read_ios as f64, save);
 731                 let rrd_key = format!("{}/read_bytes", rrd_prefix);
 732                 rrd_update_derive(&rrd_key, (stat.read_sectors*512) as f64, save);
 733
 734                 let rrd_key = format!("{}/write_ios", rrd_prefix);
 735                 rrd_update_derive(&rrd_key, stat.write_ios as f64, save);
 736                 let rrd_key = format!("{}/write_bytes", rrd_prefix);
 737                 rrd_update_derive(&rrd_key, (stat.write_sectors*512) as f64, save);
 738
 739                 let rrd_key = format!("{}/io_ticks", rrd_prefix);
 740                 rrd_update_derive(&rrd_key, (stat.io_ticks as f64)/1000.0, save);
 741             }
 742         }
 743         Err(err) => {
 744             eprintln!("find_mounted_device failed - {}", err);
 745         }
 746     }
 747 }