2 use std
::path
::{Path, PathBuf}
;
4 use anyhow
::{bail, format_err, Error}
;
7 use openssl
::ssl
::{SslMethod, SslAcceptor, SslFiletype}
;
9 use proxmox
::try_block
;
10 use proxmox
::api
::RpcEnvironmentType
;
12 use proxmox_backup
::api2
::types
::Userid
;
13 use proxmox_backup
::configdir
;
14 use proxmox_backup
::buildcfg
;
15 use proxmox_backup
::server
;
16 use proxmox_backup
::tools
::daemon
;
17 use proxmox_backup
::server
::{ApiConfig, rest::*}
;
18 use proxmox_backup
::auth_helpers
::*;
19 use proxmox_backup
::tools
::disks
::{ DiskManage, zfs_pool_stats }
;
21 use proxmox_backup
::api2
::pull
::do_sync_job
;
23 fn main() -> Result
<(), Error
> {
24 proxmox_backup
::tools
::setup_safe_path_env();
26 let backup_uid
= proxmox_backup
::backup
::backup_user()?
.uid
;
27 let backup_gid
= proxmox_backup
::backup
::backup_group()?
.gid
;
28 let running_uid
= nix
::unistd
::Uid
::effective();
29 let running_gid
= nix
::unistd
::Gid
::effective();
31 if running_uid
!= backup_uid
|| running_gid
!= backup_gid
{
32 bail
!("proxy not running as backup user or group (got uid {} gid {})", running_uid
, running_gid
);
35 proxmox_backup
::tools
::runtime
::main(run())
38 async
fn run() -> Result
<(), Error
> {
39 if let Err(err
) = syslog
::init(
40 syslog
::Facility
::LOG_DAEMON
,
41 log
::LevelFilter
::Info
,
42 Some("proxmox-backup-proxy")) {
43 bail
!("unable to inititialize syslog - {}", err
);
46 let _
= public_auth_key(); // load with lazy_static
47 let _
= csrf_secret(); // load with lazy_static
49 let mut config
= ApiConfig
::new(
50 buildcfg
::JS_DIR
, &proxmox_backup
::api2
::ROUTER
, RpcEnvironmentType
::PUBLIC
)?
;
52 config
.add_alias("novnc", "/usr/share/novnc-pve");
53 config
.add_alias("extjs", "/usr/share/javascript/extjs");
54 config
.add_alias("fontawesome", "/usr/share/fonts-font-awesome");
55 config
.add_alias("xtermjs", "/usr/share/pve-xtermjs");
56 config
.add_alias("locale", "/usr/share/pbs-i18n");
57 config
.add_alias("widgettoolkit", "/usr/share/javascript/proxmox-widget-toolkit");
58 config
.add_alias("css", "/usr/share/javascript/proxmox-backup/css");
59 config
.add_alias("docs", "/usr/share/doc/proxmox-backup/html");
61 let mut indexpath
= PathBuf
::from(buildcfg
::JS_DIR
);
62 indexpath
.push("index.hbs");
63 config
.register_template("index", &indexpath
)?
;
64 config
.register_template("console", "/usr/share/pve-xtermjs/index.html.hbs")?
;
66 let rest_server
= RestServer
::new(config
);
68 //openssl req -x509 -newkey rsa:4096 -keyout /etc/proxmox-backup/proxy.key -out /etc/proxmox-backup/proxy.pem -nodes
69 let key_path
= configdir
!("/proxy.key");
70 let cert_path
= configdir
!("/proxy.pem");
72 let mut acceptor
= SslAcceptor
::mozilla_intermediate(SslMethod
::tls()).unwrap();
73 acceptor
.set_private_key_file(key_path
, SslFiletype
::PEM
)
74 .map_err(|err
| format_err
!("unable to read proxy key {} - {}", key_path
, err
))?
;
75 acceptor
.set_certificate_chain_file(cert_path
)
76 .map_err(|err
| format_err
!("unable to read proxy cert {} - {}", cert_path
, err
))?
;
77 acceptor
.check_private_key().unwrap();
79 let acceptor
= Arc
::new(acceptor
.build());
81 let server
= daemon
::create_daemon(
82 ([0,0,0,0,0,0,0,0], 8007).into(),
84 let connections
= proxmox_backup
::tools
::async_io
::StaticIncoming
::from(listener
)
86 .try_filter_map(move |(sock
, _addr
)| {
87 let acceptor
= Arc
::clone(&acceptor
);
89 sock
.set_nodelay(true).unwrap();
90 Ok(tokio_openssl
::accept(&acceptor
, sock
)
92 .ok() // handshake errors aren't be fatal, so return None to filter
96 let connections
= proxmox_backup
::tools
::async_io
::HyperAccept(connections
);
99 .and_then(|_
| hyper
::Server
::builder(connections
)
101 .with_graceful_shutdown(server
::shutdown_future())
102 .map_err(Error
::from
)
104 .map_err(|err
| eprintln
!("server error: {}", err
))
110 daemon
::systemd_notify(daemon
::SystemdNotify
::Ready
)?
;
112 let init_result
: Result
<(), Error
> = try_block
!({
113 server
::create_task_control_socket()?
;
114 server
::server_state_init()?
;
118 if let Err(err
) = init_result
{
119 bail
!("unable to start daemon - {}", err
);
122 start_task_scheduler();
123 start_stat_generator();
126 log
::info
!("server shutting down, waiting for active workers to complete");
127 proxmox_backup
::server
::last_worker_future().await?
;
128 log
::info
!("done - exit server");
133 fn start_stat_generator() {
134 let abort_future
= server
::shutdown_future();
135 let future
= Box
::pin(run_stat_generator());
136 let task
= futures
::future
::select(future
, abort_future
);
137 tokio
::spawn(task
.map(|_
| ()));
140 fn start_task_scheduler() {
141 let abort_future
= server
::shutdown_future();
142 let future
= Box
::pin(run_task_scheduler());
143 let task
= futures
::future
::select(future
, abort_future
);
144 tokio
::spawn(task
.map(|_
| ()));
147 use std
::time
::{SystemTime, Instant, Duration, UNIX_EPOCH}
;
149 fn next_minute() -> Result
<Instant
, Error
> {
150 let now
= SystemTime
::now();
151 let epoch_now
= now
.duration_since(UNIX_EPOCH
)?
;
152 let epoch_next
= Duration
::from_secs((epoch_now
.as_secs()/60 + 1)*60);
153 Ok(Instant
::now() + epoch_next
- epoch_now
)
156 async
fn run_task_scheduler() {
158 let mut count
: usize = 0;
163 let delay_target
= match next_minute() { // try to run very minute
166 eprintln
!("task scheduler: compute next minute failed - {}", err
);
167 tokio
::time
::delay_until(tokio
::time
::Instant
::from_std(Instant
::now() + Duration
::from_secs(60))).await
;
172 if count
> 2 { // wait 1..2 minutes before starting
173 match schedule_tasks().catch_unwind().await
{
175 match panic
.downcast
::<&str>() {
177 eprintln
!("task scheduler panic: {}", msg
);
180 eprintln
!("task scheduler panic - unknown type");
185 eprintln
!("task scheduler failed - {:?}", err
);
191 tokio
::time
::delay_until(tokio
::time
::Instant
::from_std(delay_target
)).await
;
195 async
fn schedule_tasks() -> Result
<(), Error
> {
197 schedule_datastore_garbage_collection().await
;
198 schedule_datastore_prune().await
;
199 schedule_datastore_verification().await
;
200 schedule_datastore_sync_jobs().await
;
201 schedule_task_log_rotate().await
;
206 async
fn schedule_datastore_garbage_collection() {
208 use proxmox_backup
::backup
::DataStore
;
209 use proxmox_backup
::server
::{UPID, WorkerTask}
;
210 use proxmox_backup
::config
::{
211 jobstate
::{self, Job}
,
212 datastore
::{self, DataStoreConfig}
214 use proxmox_backup
::tools
::systemd
::time
::{
215 parse_calendar_event
, compute_next_event
};
217 let config
= match datastore
::config() {
219 eprintln
!("unable to read datastore config - {}", err
);
222 Ok((config
, _digest
)) => config
,
225 for (store
, (_
, store_config
)) in config
.sections
{
226 let datastore
= match DataStore
::lookup_datastore(&store
) {
227 Ok(datastore
) => datastore
,
229 eprintln
!("lookup_datastore failed - {}", err
);
234 let store_config
: DataStoreConfig
= match serde_json
::from_value(store_config
) {
237 eprintln
!("datastore config from_value failed - {}", err
);
242 let event_str
= match store_config
.gc_schedule
{
243 Some(event_str
) => event_str
,
247 let event
= match parse_calendar_event(&event_str
) {
250 eprintln
!("unable to parse schedule '{}' - {}", event_str
, err
);
255 if datastore
.garbage_collection_running() { continue; }
257 let worker_type
= "garbage_collection";
259 let stat
= datastore
.last_gc_status();
260 let last
= if let Some(upid_str
) = stat
.upid
{
261 match upid_str
.parse
::<UPID
>() {
262 Ok(upid
) => upid
.starttime
,
264 eprintln
!("unable to parse upid '{}' - {}", upid_str
, err
);
269 match jobstate
::last_run_time(worker_type
, &store
) {
272 eprintln
!("could not get last run time of {} {}: {}", worker_type
, store
, err
);
278 let next
= match compute_next_event(&event
, last
, false) {
279 Ok(Some(next
)) => next
,
280 Ok(None
) => continue,
282 eprintln
!("compute_next_event for '{}' failed - {}", event_str
, err
);
287 let now
= proxmox
::tools
::time
::epoch_i64();
289 if next
> now { continue; }
291 let mut job
= match Job
::new(worker_type
, &store
) {
293 Err(_
) => continue, // could not get lock
296 let store2
= store
.clone();
298 if let Err(err
) = WorkerTask
::new_thread(
301 Userid
::backup_userid().clone(),
304 job
.start(&worker
.upid().to_string())?
;
306 worker
.log(format
!("starting garbage collection on store {}", store
));
307 worker
.log(format
!("task triggered by schedule '{}'", event_str
));
309 let result
= datastore
.garbage_collection(&*worker
, worker
.upid());
311 let status
= worker
.create_state(&result
);
313 if let Err(err
) = job
.finish(status
) {
314 eprintln
!("could not finish job state for {}: {}", worker_type
, err
);
320 eprintln
!("unable to start garbage collection on store {} - {}", store2
, err
);
325 async
fn schedule_datastore_prune() {
327 use proxmox_backup
::backup
::{
328 PruneOptions
, DataStore
, BackupGroup
, compute_prune_info
};
329 use proxmox_backup
::server
::{WorkerTask}
;
330 use proxmox_backup
::config
::{
331 jobstate
::{self, Job}
,
332 datastore
::{self, DataStoreConfig}
334 use proxmox_backup
::tools
::systemd
::time
::{
335 parse_calendar_event
, compute_next_event
};
337 let config
= match datastore
::config() {
339 eprintln
!("unable to read datastore config - {}", err
);
342 Ok((config
, _digest
)) => config
,
345 for (store
, (_
, store_config
)) in config
.sections
{
346 let datastore
= match DataStore
::lookup_datastore(&store
) {
347 Ok(datastore
) => datastore
,
349 eprintln
!("lookup_datastore '{}' failed - {}", store
, err
);
354 let store_config
: DataStoreConfig
= match serde_json
::from_value(store_config
) {
357 eprintln
!("datastore '{}' config from_value failed - {}", store
, err
);
362 let event_str
= match store_config
.prune_schedule
{
363 Some(event_str
) => event_str
,
367 let prune_options
= PruneOptions
{
368 keep_last
: store_config
.keep_last
,
369 keep_hourly
: store_config
.keep_hourly
,
370 keep_daily
: store_config
.keep_daily
,
371 keep_weekly
: store_config
.keep_weekly
,
372 keep_monthly
: store_config
.keep_monthly
,
373 keep_yearly
: store_config
.keep_yearly
,
376 if !prune_options
.keeps_something() { // no prune settings - keep all
380 let event
= match parse_calendar_event(&event_str
) {
383 eprintln
!("unable to parse schedule '{}' - {}", event_str
, err
);
388 let worker_type
= "prune";
390 let last
= match jobstate
::last_run_time(worker_type
, &store
) {
393 eprintln
!("could not get last run time of {} {}: {}", worker_type
, store
, err
);
398 let next
= match compute_next_event(&event
, last
, false) {
399 Ok(Some(next
)) => next
,
400 Ok(None
) => continue,
402 eprintln
!("compute_next_event for '{}' failed - {}", event_str
, err
);
407 let now
= proxmox
::tools
::time
::epoch_i64();
409 if next
> now { continue; }
411 let mut job
= match Job
::new(worker_type
, &store
) {
413 Err(_
) => continue, // could not get lock
416 let store2
= store
.clone();
418 if let Err(err
) = WorkerTask
::new_thread(
421 Userid
::backup_userid().clone(),
425 job
.start(&worker
.upid().to_string())?
;
427 let result
= try_block
!({
429 worker
.log(format
!("Starting datastore prune on store \"{}\"", store
));
430 worker
.log(format
!("task triggered by schedule '{}'", event_str
));
431 worker
.log(format
!("retention options: {}", prune_options
.cli_options_string()));
433 let base_path
= datastore
.base_path();
435 let groups
= BackupGroup
::list_groups(&base_path
)?
;
436 for group
in groups
{
437 let list
= group
.list_backups(&base_path
)?
;
438 let mut prune_info
= compute_prune_info(list
, &prune_options
)?
;
439 prune_info
.reverse(); // delete older snapshots first
441 worker
.log(format
!("Starting prune on store \"{}\" group \"{}/{}\"",
442 store
, group
.backup_type(), group
.backup_id()));
444 for (info
, keep
) in prune_info
{
447 if keep { "keep" }
else { "remove" }
,
448 group
.backup_type(), group
.backup_id(),
449 info
.backup_dir
.backup_time_string()));
451 datastore
.remove_backup_dir(&info
.backup_dir
, true)?
;
458 let status
= worker
.create_state(&result
);
460 if let Err(err
) = job
.finish(status
) {
461 eprintln
!("could not finish job state for {}: {}", worker_type
, err
);
467 eprintln
!("unable to start datastore prune on store {} - {}", store2
, err
);
472 async
fn schedule_datastore_verification() {
473 use proxmox_backup
::backup
::{DataStore, verify_all_backups}
;
474 use proxmox_backup
::server
::{WorkerTask}
;
475 use proxmox_backup
::config
::{
476 jobstate
::{self, Job}
,
477 datastore
::{self, DataStoreConfig}
479 use proxmox_backup
::tools
::systemd
::time
::{
480 parse_calendar_event
, compute_next_event
};
482 let config
= match datastore
::config() {
484 eprintln
!("unable to read datastore config - {}", err
);
487 Ok((config
, _digest
)) => config
,
490 for (store
, (_
, store_config
)) in config
.sections
{
491 let datastore
= match DataStore
::lookup_datastore(&store
) {
492 Ok(datastore
) => datastore
,
494 eprintln
!("lookup_datastore failed - {}", err
);
499 let store_config
: DataStoreConfig
= match serde_json
::from_value(store_config
) {
502 eprintln
!("datastore config from_value failed - {}", err
);
507 let event_str
= match store_config
.verify_schedule
{
508 Some(event_str
) => event_str
,
512 let event
= match parse_calendar_event(&event_str
) {
515 eprintln
!("unable to parse schedule '{}' - {}", event_str
, err
);
520 let worker_type
= "verify";
522 let last
= match jobstate
::last_run_time(worker_type
, &store
) {
525 eprintln
!("could not get last run time of {} {}: {}", worker_type
, store
, err
);
530 let next
= match compute_next_event(&event
, last
, false) {
531 Ok(Some(next
)) => next
,
532 Ok(None
) => continue,
534 eprintln
!("compute_next_event for '{}' failed - {}", event_str
, err
);
539 let now
= proxmox
::tools
::time
::epoch_i64();
541 if next
> now { continue; }
543 let mut job
= match Job
::new(worker_type
, &store
) {
545 Err(_
) => continue, // could not get lock
548 let worker_id
= store
.clone();
549 let store2
= store
.clone();
550 if let Err(err
) = WorkerTask
::new_thread(
553 Userid
::backup_userid().clone(),
556 job
.start(&worker
.upid().to_string())?
;
557 worker
.log(format
!("starting verification on store {}", store2
));
558 worker
.log(format
!("task triggered by schedule '{}'", event_str
));
559 let result
= try_block
!({
561 verify_all_backups(datastore
, worker
.clone(), worker
.upid())?
;
562 if failed_dirs
.len() > 0 {
563 worker
.log("Failed to verify following snapshots:");
564 for dir
in failed_dirs
{
565 worker
.log(format
!("\t{}", dir
));
567 Err(format_err
!("verification failed - please check the log for details"))
573 let status
= worker
.create_state(&result
);
575 if let Err(err
) = job
.finish(status
) {
576 eprintln
!("could not finish job state for {}: {}", worker_type
, err
);
582 eprintln
!("unable to start verification on store {} - {}", store
, err
);
587 async
fn schedule_datastore_sync_jobs() {
589 use proxmox_backup
::{
590 config
::{ sync::{self, SyncJobConfig}
, jobstate
::{self, Job}
},
591 tools
::systemd
::time
::{ parse_calendar_event, compute_next_event }
,
594 let config
= match sync
::config() {
596 eprintln
!("unable to read sync job config - {}", err
);
599 Ok((config
, _digest
)) => config
,
602 for (job_id
, (_
, job_config
)) in config
.sections
{
603 let job_config
: SyncJobConfig
= match serde_json
::from_value(job_config
) {
606 eprintln
!("sync job config from_value failed - {}", err
);
611 let event_str
= match job_config
.schedule
{
612 Some(ref event_str
) => event_str
.clone(),
616 let event
= match parse_calendar_event(&event_str
) {
619 eprintln
!("unable to parse schedule '{}' - {}", event_str
, err
);
624 let worker_type
= "syncjob";
626 let last
= match jobstate
::last_run_time(worker_type
, &job_id
) {
629 eprintln
!("could not get last run time of {} {}: {}", worker_type
, job_id
, err
);
634 let next
= match compute_next_event(&event
, last
, false) {
635 Ok(Some(next
)) => next
,
636 Ok(None
) => continue,
638 eprintln
!("compute_next_event for '{}' failed - {}", event_str
, err
);
643 let now
= proxmox
::tools
::time
::epoch_i64();
645 if next
> now { continue; }
647 let job
= match Job
::new(worker_type
, &job_id
) {
649 Err(_
) => continue, // could not get lock
652 let userid
= Userid
::backup_userid().clone();
654 if let Err(err
) = do_sync_job(job
, job_config
, &userid
, Some(event_str
)) {
655 eprintln
!("unable to start datastore sync job {} - {}", &job_id
, err
);
660 async
fn schedule_task_log_rotate() {
661 use proxmox_backup
::{
662 config
::jobstate
::{self, Job}
,
663 server
::rotate_task_log_archive
,
665 use proxmox_backup
::server
::WorkerTask
;
666 use proxmox_backup
::tools
::systemd
::time
::{
667 parse_calendar_event
, compute_next_event
};
669 let worker_type
= "logrotate";
670 let job_id
= "task-archive";
672 let last
= match jobstate
::last_run_time(worker_type
, job_id
) {
675 eprintln
!("could not get last run time of task log archive rotation: {}", err
);
680 // schedule daily at 00:00 like normal logrotate
681 let schedule
= "00:00";
683 let event
= match parse_calendar_event(schedule
) {
686 // should not happen?
687 eprintln
!("unable to parse schedule '{}' - {}", schedule
, err
);
692 let next
= match compute_next_event(&event
, last
, false) {
693 Ok(Some(next
)) => next
,
696 eprintln
!("compute_next_event for '{}' failed - {}", schedule
, err
);
701 let now
= proxmox
::tools
::time
::epoch_i64();
704 // if we never ran the rotation, schedule instantly
705 match jobstate
::JobState
::load(worker_type
, job_id
) {
706 Ok(state
) => match state
{
707 jobstate
::JobState
::Created { .. }
=> {}
,
714 let mut job
= match Job
::new(worker_type
, job_id
) {
716 Err(_
) => return, // could not get lock
719 if let Err(err
) = WorkerTask
::new_thread(
721 Some(job_id
.to_string()),
722 Userid
::backup_userid().clone(),
725 job
.start(&worker
.upid().to_string())?
;
726 worker
.log(format
!("starting task log rotation"));
727 // one entry has normally about ~100-150 bytes
728 let max_size
= 500000; // at least 5000 entries
729 let max_files
= 20; // at least 100000 entries
730 let result
= try_block
!({
731 let has_rotated
= rotate_task_log_archive(max_size
, true, Some(max_files
))?
;
733 worker
.log(format
!("task log archive was rotated"));
735 worker
.log(format
!("task log archive was not rotated"));
741 let status
= worker
.create_state(&result
);
743 if let Err(err
) = job
.finish(status
) {
744 eprintln
!("could not finish job state for {}: {}", worker_type
, err
);
750 eprintln
!("unable to start task log rotation: {}", err
);
755 async
fn run_stat_generator() {
760 let save
= if count
>= 6 { count = 0; true }
else { false }
;
762 let delay_target
= Instant
::now() + Duration
::from_secs(10);
764 generate_host_stats(save
).await
;
766 tokio
::time
::delay_until(tokio
::time
::Instant
::from_std(delay_target
)).await
;
772 fn rrd_update_gauge(name
: &str, value
: f64, save
: bool
) {
773 use proxmox_backup
::rrd
;
774 if let Err(err
) = rrd
::update_value(name
, value
, rrd
::DST
::Gauge
, save
) {
775 eprintln
!("rrd::update_value '{}' failed - {}", name
, err
);
779 fn rrd_update_derive(name
: &str, value
: f64, save
: bool
) {
780 use proxmox_backup
::rrd
;
781 if let Err(err
) = rrd
::update_value(name
, value
, rrd
::DST
::Derive
, save
) {
782 eprintln
!("rrd::update_value '{}' failed - {}", name
, err
);
786 async
fn generate_host_stats(save
: bool
) {
787 use proxmox
::sys
::linux
::procfs
::{
788 read_meminfo
, read_proc_stat
, read_proc_net_dev
, read_loadavg
};
789 use proxmox_backup
::config
::datastore
;
792 proxmox_backup
::tools
::runtime
::block_in_place(move || {
794 match read_proc_stat() {
796 rrd_update_gauge("host/cpu", stat
.cpu
, save
);
797 rrd_update_gauge("host/iowait", stat
.iowait_percent
, save
);
800 eprintln
!("read_proc_stat failed - {}", err
);
804 match read_meminfo() {
806 rrd_update_gauge("host/memtotal", meminfo
.memtotal
as f64, save
);
807 rrd_update_gauge("host/memused", meminfo
.memused
as f64, save
);
808 rrd_update_gauge("host/swaptotal", meminfo
.swaptotal
as f64, save
);
809 rrd_update_gauge("host/swapused", meminfo
.swapused
as f64, save
);
812 eprintln
!("read_meminfo failed - {}", err
);
816 match read_proc_net_dev() {
818 use proxmox_backup
::config
::network
::is_physical_nic
;
822 if !is_physical_nic(&item
.device
) { continue; }
823 netin
+= item
.receive
;
826 rrd_update_derive("host/netin", netin
as f64, save
);
827 rrd_update_derive("host/netout", netout
as f64, save
);
830 eprintln
!("read_prox_net_dev failed - {}", err
);
834 match read_loadavg() {
836 rrd_update_gauge("host/loadavg", loadavg
.0 as f64, save
);
839 eprintln
!("read_loadavg failed - {}", err
);
843 let disk_manager
= DiskManage
::new();
845 gather_disk_stats(disk_manager
.clone(), Path
::new("/"), "host", save
);
847 match datastore
::config() {
849 let datastore_list
: Vec
<datastore
::DataStoreConfig
> =
850 config
.convert_to_typed_array("datastore").unwrap_or(Vec
::new());
852 for config
in datastore_list
{
854 let rrd_prefix
= format
!("datastore/{}", config
.name
);
855 let path
= std
::path
::Path
::new(&config
.path
);
856 gather_disk_stats(disk_manager
.clone(), path
, &rrd_prefix
, save
);
860 eprintln
!("read datastore config failed - {}", err
);
867 fn gather_disk_stats(disk_manager
: Arc
<DiskManage
>, path
: &Path
, rrd_prefix
: &str, save
: bool
) {
869 match proxmox_backup
::tools
::disks
::disk_usage(path
) {
871 let rrd_key
= format
!("{}/total", rrd_prefix
);
872 rrd_update_gauge(&rrd_key
, status
.total
as f64, save
);
873 let rrd_key
= format
!("{}/used", rrd_prefix
);
874 rrd_update_gauge(&rrd_key
, status
.used
as f64, save
);
877 eprintln
!("read disk_usage on {:?} failed - {}", path
, err
);
881 match disk_manager
.find_mounted_device(path
) {
883 Ok(Some((fs_type
, device
, source
))) => {
884 let mut device_stat
= None
;
885 match fs_type
.as_str() {
887 if let Some(pool
) = source
{
888 match zfs_pool_stats(&pool
) {
889 Ok(stat
) => device_stat
= stat
,
890 Err(err
) => eprintln
!("zfs_pool_stats({:?}) failed - {}", pool
, err
),
895 if let Ok(disk
) = disk_manager
.clone().disk_by_dev_num(device
.into_dev_t()) {
896 match disk
.read_stat() {
897 Ok(stat
) => device_stat
= stat
,
898 Err(err
) => eprintln
!("disk.read_stat {:?} failed - {}", path
, err
),
903 if let Some(stat
) = device_stat
{
904 let rrd_key
= format
!("{}/read_ios", rrd_prefix
);
905 rrd_update_derive(&rrd_key
, stat
.read_ios
as f64, save
);
906 let rrd_key
= format
!("{}/read_bytes", rrd_prefix
);
907 rrd_update_derive(&rrd_key
, (stat
.read_sectors
*512) as f64, save
);
909 let rrd_key
= format
!("{}/write_ios", rrd_prefix
);
910 rrd_update_derive(&rrd_key
, stat
.write_ios
as f64, save
);
911 let rrd_key
= format
!("{}/write_bytes", rrd_prefix
);
912 rrd_update_derive(&rrd_key
, (stat
.write_sectors
*512) as f64, save
);
914 let rrd_key
= format
!("{}/io_ticks", rrd_prefix
);
915 rrd_update_derive(&rrd_key
, (stat
.io_ticks
as f64)/1000.0, save
);
919 eprintln
!("find_mounted_device failed - {}", err
);