src/api2/admin/datastore.rs

   1 use failure::*;
   2 use futures::*;
   3
   4 use crate::tools;
   5 use crate::api2::types::*;
   6 use crate::api_schema::*;
   7 use crate::api_schema::router::*;
   8 //use crate::server::rest::*;
   9 use serde_json::{json, Value};
  10 use std::collections::{HashSet, HashMap};
  11 use chrono::{DateTime, Datelike, TimeZone, Local};
  12 use std::path::PathBuf;
  13 use std::sync::Arc;
  14
  15 use crate::config::datastore;
  16
  17 use crate::backup::*;
  18 use crate::server::WorkerTask;
  19
  20 use hyper::{header, Body, Response, StatusCode};
  21 use hyper::http::request::Parts;
  22
  23 fn group_backups(backup_list: Vec<BackupInfo>) -> HashMap<String, Vec<BackupInfo>> {
  24
  25     let mut group_hash = HashMap::new();
  26
  27     for info in backup_list {
  28         let group_id = info.backup_dir.group().group_path().to_str().unwrap().to_owned();
  29         let time_list = group_hash.entry(group_id).or_insert(vec![]);
  30         time_list.push(info);
  31     }
  32
  33     group_hash
  34 }
  35
  36 fn mark_selections<F: Fn(DateTime<Local>, &BackupInfo) -> String> (
  37     mark: &mut HashSet<PathBuf>,
  38     list: &Vec<BackupInfo>,
  39     keep: usize,
  40     select_id: F,
  41 ){
  42     let mut hash = HashSet::new();
  43     for info in list {
  44         let local_time = info.backup_dir.backup_time().with_timezone(&Local);
  45         if hash.len() >= keep as usize { break; }
  46         let backup_id = info.backup_dir.relative_path();
  47         let sel_id: String = select_id(local_time, &info);
  48         if !hash.contains(&sel_id) {
  49             hash.insert(sel_id);
  50             //println!(" KEEP ID {} {}", backup_id, local_time.format("%c"));
  51             mark.insert(backup_id);
  52         }
  53     }
  54 }
  55
  56 fn list_groups(
  57     param: Value,
  58     _info: &ApiMethod,
  59     _rpcenv: &mut dyn RpcEnvironment,
  60 ) -> Result<Value, Error> {
  61
  62     let store = param["store"].as_str().unwrap();
  63
  64     let datastore = DataStore::lookup_datastore(store)?;
  65
  66     let backup_list = BackupInfo::list_backups(&datastore.base_path())?;
  67
  68     let group_hash = group_backups(backup_list);
  69
  70     let mut groups = vec![];
  71
  72     for (_group_id, mut list) in group_hash {
  73
  74         BackupInfo::sort_list(&mut list, false);
  75
  76         let info = &list[0];
  77         let group = info.backup_dir.group();
  78
  79         groups.push(json!({
  80             "backup-type": group.backup_type(),
  81             "backup-id": group.backup_id(),
  82             "last-backup": info.backup_dir.backup_time().timestamp(),
  83             "backup-count": list.len() as u64,
  84             "files": info.files,
  85         }));
  86     }
  87
  88     Ok(json!(groups))
  89 }
  90
  91 fn list_snapshot_files (
  92     param: Value,
  93     _info: &ApiMethod,
  94     _rpcenv: &mut dyn RpcEnvironment,
  95 ) -> Result<Value, Error> {
  96
  97     let store = tools::required_string_param(&param, "store")?;
  98     let backup_type = tools::required_string_param(&param, "backup-type")?;
  99     let backup_id = tools::required_string_param(&param, "backup-id")?;
 100     let backup_time = tools::required_integer_param(&param, "backup-time")?;
 101
 102     let snapshot = BackupDir::new(backup_type, backup_id, backup_time);
 103
 104     let datastore = DataStore::lookup_datastore(store)?;
 105
 106     let path = datastore.base_path();
 107     let files = BackupInfo::list_files(&path, &snapshot)?;
 108
 109     Ok(json!(files))
 110 }
 111
 112 fn delete_snapshots (
 113     param: Value,
 114     _info: &ApiMethod,
 115     _rpcenv: &mut dyn RpcEnvironment,
 116 ) -> Result<Value, Error> {
 117
 118     let store = tools::required_string_param(&param, "store")?;
 119     let backup_type = tools::required_string_param(&param, "backup-type")?;
 120     let backup_id = tools::required_string_param(&param, "backup-id")?;
 121     let backup_time = tools::required_integer_param(&param, "backup-time")?;
 122
 123     let snapshot = BackupDir::new(backup_type, backup_id, backup_time);
 124
 125     let datastore = DataStore::lookup_datastore(store)?;
 126
 127     datastore.remove_backup_dir(&snapshot)?;
 128
 129     Ok(Value::Null)
 130 }
 131
 132 fn list_snapshots (
 133     param: Value,
 134     _info: &ApiMethod,
 135     _rpcenv: &mut dyn RpcEnvironment,
 136 ) -> Result<Value, Error> {
 137
 138     let store = tools::required_string_param(&param, "store")?;
 139     let backup_type = param["backup-type"].as_str();
 140     let backup_id = param["backup-id"].as_str();
 141
 142     let datastore = DataStore::lookup_datastore(store)?;
 143
 144     let base_path = datastore.base_path();
 145
 146     let backup_list = BackupInfo::list_backups(&base_path)?;
 147
 148     let mut snapshots = vec![];
 149
 150     for info in backup_list {
 151         let group = info.backup_dir.group();
 152         if let Some(backup_type) = backup_type {
 153             if backup_type != group.backup_type() { continue; }
 154         }
 155        if let Some(backup_id) = backup_id {
 156             if backup_id != group.backup_id() { continue; }
 157         }
 158         snapshots.push(json!({
 159             "backup-type": group.backup_type(),
 160             "backup-id": group.backup_id(),
 161             "backup-time": info.backup_dir.backup_time().timestamp(),
 162             "files": info.files,
 163         }));
 164     }
 165
 166     Ok(json!(snapshots))
 167 }
 168
 169 fn status(
 170     param: Value,
 171     _info: &ApiMethod,
 172     _rpcenv: &mut dyn RpcEnvironment,
 173 ) -> Result<Value, Error> {
 174
 175     let store = param["store"].as_str().unwrap();
 176
 177     let datastore = DataStore::lookup_datastore(store)?;
 178
 179     let base_path = datastore.base_path();
 180
 181     let mut stat: libc::statfs64 = unsafe { std::mem::zeroed() };
 182
 183     use nix::NixPath;
 184
 185     let res = base_path.with_nix_path(|cstr| unsafe { libc::statfs64(cstr.as_ptr(), &mut stat) })?;
 186     nix::errno::Errno::result(res)?;
 187
 188     let bsize = stat.f_bsize as u64;
 189     Ok(json!({
 190         "total": stat.f_blocks*bsize,
 191         "used": (stat.f_blocks-stat.f_bfree)*bsize,
 192         "avail": stat.f_bavail*bsize,
 193     }))
 194 }
 195
 196 fn api_method_status() -> ApiMethod {
 197     ApiMethod::new(
 198         status,
 199         add_common_prune_prameters(
 200             ObjectSchema::new("Get datastore status.")
 201                 .required(
 202                     "store",
 203                     StringSchema::new("Datastore name.")
 204                 )
 205         )
 206     )
 207 }
 208
 209 fn prune(
 210     param: Value,
 211     _info: &ApiMethod,
 212     _rpcenv: &mut dyn RpcEnvironment,
 213 ) -> Result<Value, Error> {
 214
 215     let store = param["store"].as_str().unwrap();
 216
 217     let datastore = DataStore::lookup_datastore(store)?;
 218
 219     let mut keep_all = true;
 220
 221     for opt in &["keep-last", "keep-daily", "keep-weekly", "keep-weekly", "keep-yearly"] {
 222         if !param[opt].is_null() {
 223             keep_all = false;
 224             break;
 225         }
 226     }
 227
 228     let worker = WorkerTask::new("prune", Some(store.to_owned()), "root@pam", true)?;
 229     let result = try_block! {
 230         if keep_all {
 231             worker.log("No selection - keeping all files.");
 232             return Ok(());
 233         } else {
 234             worker.log(format!("Starting prune on store {}", store));
 235         }
 236
 237         let backup_list = BackupInfo::list_backups(&datastore.base_path())?;
 238
 239         let group_hash = group_backups(backup_list);
 240
 241         for (_group_id, mut list) in group_hash {
 242
 243             let mut mark = HashSet::new();
 244
 245             BackupInfo::sort_list(&mut list, false);
 246
 247             if let Some(keep_last) = param["keep-last"].as_u64() {
 248                 list.iter().take(keep_last as usize).for_each(|info| {
 249                     mark.insert(info.backup_dir.relative_path());
 250                 });
 251             }
 252
 253             if let Some(keep_daily) = param["keep-daily"].as_u64() {
 254                 mark_selections(&mut mark, &list, keep_daily as usize, |local_time, _info| {
 255                     format!("{}/{}/{}", local_time.year(), local_time.month(), local_time.day())
 256                 });
 257             }
 258
 259             if let Some(keep_weekly) = param["keep-weekly"].as_u64() {
 260                 mark_selections(&mut mark, &list, keep_weekly as usize, |local_time, _info| {
 261                     format!("{}/{}", local_time.year(), local_time.iso_week().week())
 262                 });
 263             }
 264
 265             if let Some(keep_monthly) = param["keep-monthly"].as_u64() {
 266                 mark_selections(&mut mark, &list, keep_monthly as usize, |local_time, _info| {
 267                     format!("{}/{}", local_time.year(), local_time.month())
 268                 });
 269             }
 270
 271             if let Some(keep_yearly) = param["keep-yearly"].as_u64() {
 272                 mark_selections(&mut mark, &list, keep_yearly as usize, |local_time, _info| {
 273                     format!("{}/{}", local_time.year(), local_time.year())
 274                 });
 275             }
 276
 277             let mut remove_list: Vec<BackupInfo> = list.into_iter()
 278                 .filter(|info| !mark.contains(&info.backup_dir.relative_path())).collect();
 279
 280             BackupInfo::sort_list(&mut remove_list, true);
 281
 282             for info in remove_list {
 283                 worker.log(format!("remove {:?}", info.backup_dir));
 284                 datastore.remove_backup_dir(&info.backup_dir)?;
 285             }
 286         }
 287
 288         Ok(())
 289     };
 290
 291     worker.log_result(&result);
 292
 293     if let Err(err) = result {
 294         bail!("prune failed - {}", err);
 295     }
 296
 297     Ok(json!(null))
 298 }
 299
 300 pub fn add_common_prune_prameters(schema: ObjectSchema) -> ObjectSchema  {
 301
 302     schema
 303         .optional(
 304             "keep-last",
 305             IntegerSchema::new("Number of backups to keep.")
 306                 .minimum(1)
 307         )
 308         .optional(
 309             "keep-daily",
 310             IntegerSchema::new("Number of daily backups to keep.")
 311                 .minimum(1)
 312         )
 313         .optional(
 314             "keep-weekly",
 315             IntegerSchema::new("Number of weekly backups to keep.")
 316                 .minimum(1)
 317         )
 318         .optional(
 319             "keep-monthly",
 320             IntegerSchema::new("Number of monthly backups to keep.")
 321                 .minimum(1)
 322         )
 323         .optional(
 324             "keep-yearly",
 325             IntegerSchema::new("Number of yearly backups to keep.")
 326                 .minimum(1)
 327         )
 328 }
 329
 330 fn api_method_prune() -> ApiMethod {
 331     ApiMethod::new(
 332         prune,
 333         add_common_prune_prameters(
 334             ObjectSchema::new("Prune the datastore.")
 335                 .required(
 336                     "store",
 337                     StringSchema::new("Datastore name.")
 338                 )
 339         )
 340     )
 341 }
 342
 343 fn start_garbage_collection(
 344     param: Value,
 345     _info: &ApiMethod,
 346     rpcenv: &mut dyn RpcEnvironment,
 347 ) -> Result<Value, Error> {
 348
 349     let store = param["store"].as_str().unwrap().to_string();
 350
 351     let datastore = DataStore::lookup_datastore(&store)?;
 352
 353     println!("Starting garbage collection on store {}", store);
 354
 355     let to_stdout = if rpcenv.env_type() == RpcEnvironmentType::CLI { true } else { false };
 356
 357     let upid_str = WorkerTask::new_thread(
 358         "garbage_collection", Some(store.clone()), "root@pam", to_stdout, move |worker|
 359         {
 360             worker.log(format!("starting garbage collection on store {}", store));
 361             datastore.garbage_collection(worker)
 362         })?;
 363
 364     Ok(json!(upid_str))
 365 }
 366
 367 pub fn api_method_start_garbage_collection() -> ApiMethod {
 368     ApiMethod::new(
 369         start_garbage_collection,
 370         ObjectSchema::new("Start garbage collection.")
 371             .required("store", StringSchema::new("Datastore name."))
 372     )
 373 }
 374
 375 fn garbage_collection_status(
 376     param: Value,
 377     _info: &ApiMethod,
 378     _rpcenv: &mut dyn RpcEnvironment,
 379 ) -> Result<Value, Error> {
 380
 381     let store = param["store"].as_str().unwrap();
 382
 383     let datastore = DataStore::lookup_datastore(&store)?;
 384
 385     println!("Garbage collection status on store {}", store);
 386
 387     let status = datastore.last_gc_status();
 388
 389     Ok(serde_json::to_value(&status)?)
 390 }
 391
 392 pub fn api_method_garbage_collection_status() -> ApiMethod {
 393     ApiMethod::new(
 394         garbage_collection_status,
 395         ObjectSchema::new("Garbage collection status.")
 396             .required("store", StringSchema::new("Datastore name."))
 397     )
 398 }
 399
 400 fn get_datastore_list(
 401     _param: Value,
 402     _info: &ApiMethod,
 403     _rpcenv: &mut dyn RpcEnvironment,
 404 ) -> Result<Value, Error> {
 405
 406     let config = datastore::config()?;
 407
 408     Ok(config.convert_to_array("store"))
 409 }
 410
 411
 412 fn download_file(
 413     _parts: Parts,
 414     _req_body: Body,
 415     param: Value,
 416     _info: &ApiAsyncMethod,
 417     _rpcenv: Box<dyn RpcEnvironment>,
 418 ) -> Result<BoxFut, Error> {
 419
 420     let store = tools::required_string_param(&param, "store")?;
 421
 422     let datastore = DataStore::lookup_datastore(store)?;
 423
 424     let file_name = tools::required_string_param(&param, "file-name")?.to_owned();
 425
 426     let backup_type = tools::required_string_param(&param, "backup-type")?;
 427     let backup_id = tools::required_string_param(&param, "backup-id")?;
 428     let backup_time = tools::required_integer_param(&param, "backup-time")?;
 429
 430     println!("Download {} from {} ({}/{}/{}/{})", file_name, store,
 431              backup_type, backup_id, Local.timestamp(backup_time, 0), file_name);
 432
 433     let backup_dir = BackupDir::new(backup_type, backup_id, backup_time);
 434
 435     let mut path = datastore.base_path();
 436     path.push(backup_dir.relative_path());
 437     path.push(&file_name);
 438
 439     let response_future = tokio::fs::File::open(path)
 440         .map_err(|err| http_err!(BAD_REQUEST, format!("File open failed: {}", err)))
 441         .and_then(move |file| {
 442             let payload = tokio::codec::FramedRead::new(file, tokio::codec::BytesCodec::new()).
 443                 map(|bytes| hyper::Chunk::from(bytes.freeze()));
 444             let body = Body::wrap_stream(payload);
 445
 446             // fixme: set other headers ?
 447             Ok(Response::builder()
 448                .status(StatusCode::OK)
 449                .header(header::CONTENT_TYPE, "application/octet-stream")
 450                .body(body)
 451                .unwrap())
 452         });
 453
 454     Ok(Box::new(response_future))
 455 }
 456
 457 pub fn api_method_download_file() -> ApiAsyncMethod {
 458     ApiAsyncMethod::new(
 459         download_file,
 460         ObjectSchema::new("Download single raw file from backup snapshot.")
 461             .required("store", StringSchema::new("Datastore name."))
 462             .required("backup-type", BACKUP_TYPE_SCHEMA.clone())
 463             .required("backup-id", BACKUP_ID_SCHEMA.clone())
 464             .required("backup-time", BACKUP_TIME_SCHEMA.clone())
 465             .required("file-name", StringSchema::new("Raw file name.").format(FILENAME_FORMAT.clone()))
 466     )
 467 }
 468
 469 fn upload_backup_log(
 470     _parts: Parts,
 471     req_body: Body,
 472     param: Value,
 473     _info: &ApiAsyncMethod,
 474     _rpcenv: Box<dyn RpcEnvironment>,
 475 ) -> Result<BoxFut, Error> {
 476
 477     let store = tools::required_string_param(&param, "store")?;
 478
 479     let datastore = DataStore::lookup_datastore(store)?;
 480
 481     let file_name = "client.log.blob";
 482
 483     let backup_type = tools::required_string_param(&param, "backup-type")?;
 484     let backup_id = tools::required_string_param(&param, "backup-id")?;
 485     let backup_time = tools::required_integer_param(&param, "backup-time")?;
 486
 487     let backup_dir = BackupDir::new(backup_type, backup_id, backup_time);
 488
 489     let mut path = datastore.base_path();
 490     path.push(backup_dir.relative_path());
 491     path.push(&file_name);
 492
 493     if path.exists() {
 494         bail!("backup already contains a log.");
 495     }
 496
 497     println!("Upload backup log to {}/{}/{}/{}/{}", store,
 498              backup_type, backup_id, BackupDir::backup_time_to_string(backup_dir.backup_time()), file_name);
 499
 500     let resp = req_body
 501         .map_err(Error::from)
 502          .fold(Vec::new(), |mut acc, chunk| {
 503             acc.extend_from_slice(&*chunk);
 504             Ok::<_, Error>(acc)
 505         })
 506         .and_then(move |data| {
 507             let mut blob = DataBlob::from_raw(data)?;
 508             // always comput CRC at server side
 509             blob.set_crc(blob.compute_crc());
 510             let raw_data = blob.raw_data();
 511             crate::tools::file_set_contents(&path, raw_data, None)?;
 512             Ok(())
 513         })
 514         .and_then(move |_| {
 515             Ok(crate::server::formatter::json_response(Ok(Value::Null)))
 516         })
 517         ;
 518
 519     Ok(Box::new(resp))
 520 }
 521
 522 pub fn api_method_upload_backup_log() -> ApiAsyncMethod {
 523     ApiAsyncMethod::new(
 524         upload_backup_log,
 525         ObjectSchema::new("Download single raw file from backup snapshot.")
 526             .required("store", StringSchema::new("Datastore name."))
 527             .required("backup-type", BACKUP_TYPE_SCHEMA.clone())
 528             .required("backup-id", BACKUP_ID_SCHEMA.clone())
 529             .required("backup-time", BACKUP_TIME_SCHEMA.clone())
 530     )
 531 }
 532
 533 pub fn router() -> Router {
 534
 535     let store_schema: Arc<Schema> = Arc::new(
 536         StringSchema::new("Datastore name.").into()
 537     );
 538
 539     let datastore_info = Router::new()
 540         .subdir(
 541             "download",
 542             Router::new()
 543                 .download(api_method_download_file())
 544         )
 545         .subdir(
 546             "upload-backup-log",
 547             Router::new()
 548                 .upload(api_method_upload_backup_log())
 549         )
 550         .subdir(
 551             "gc",
 552             Router::new()
 553                 .get(api_method_garbage_collection_status())
 554                 .post(api_method_start_garbage_collection()))
 555         .subdir(
 556             "files",
 557             Router::new()
 558                 .get(
 559                     ApiMethod::new(
 560                         list_snapshot_files,
 561                         ObjectSchema::new("List snapshot files.")
 562                             .required("store", store_schema.clone())
 563                             .required("backup-type", BACKUP_TYPE_SCHEMA.clone())
 564                             .required("backup-id", BACKUP_ID_SCHEMA.clone())
 565                             .required("backup-time", BACKUP_TIME_SCHEMA.clone())
 566                     )
 567                 )
 568         )
 569         .subdir(
 570             "groups",
 571             Router::new()
 572                 .get(ApiMethod::new(
 573                     list_groups,
 574                     ObjectSchema::new("List backup groups.")
 575                         .required("store", store_schema.clone()))))
 576         .subdir(
 577             "snapshots",
 578             Router::new()
 579                 .get(
 580                     ApiMethod::new(
 581                         list_snapshots,
 582                         ObjectSchema::new("List backup groups.")
 583                             .required("store", store_schema.clone())
 584                             .optional("backup-type", BACKUP_TYPE_SCHEMA.clone())
 585                             .optional("backup-id", BACKUP_ID_SCHEMA.clone())
 586                     )
 587                 )
 588                 .delete(
 589                     ApiMethod::new(
 590                         delete_snapshots,
 591                         ObjectSchema::new("Delete backup snapshot.")
 592                             .required("store", store_schema.clone())
 593                             .required("backup-type", BACKUP_TYPE_SCHEMA.clone())
 594                             .required("backup-id", BACKUP_ID_SCHEMA.clone())
 595                             .required("backup-time", BACKUP_TIME_SCHEMA.clone())
 596                    )
 597                 )
 598         )
 599         .subdir(
 600             "prune",
 601             Router::new()
 602                 .post(api_method_prune())
 603         )
 604         .subdir(
 605             "status",
 606             Router::new()
 607                 .get(api_method_status())
 608         )
 609         .list_subdirs();
 610
 611
 612
 613     let route = Router::new()
 614         .get(ApiMethod::new(
 615             get_datastore_list,
 616             ObjectSchema::new("Directory index.")))
 617         .match_all("store", datastore_info);
 618
 619
 620
 621     route
 622 }