src/api2/pull.rs

   1 //! Sync datastore from remote server
   2
   3 use failure::*;
   4 use serde_json::json;
   5 use std::convert::TryFrom;
   6 use std::sync::Arc;
   7 use std::collections::HashMap;
   8 use std::io::{Seek, SeekFrom};
   9 use chrono::{Utc, TimeZone};
  10
  11 use proxmox::api::api;
  12 use proxmox::api::{ApiMethod, Router, RpcEnvironment};
  13
  14 use crate::server::{WorkerTask};
  15 use crate::backup::*;
  16 use crate::client::*;
  17 use crate::config::remote;
  18 use crate::api2::types::*;
  19
  20 // fixme: implement filters
  21 // fixme: delete vanished groups
  22 // Todo: correctly lock backup groups
  23
  24 async fn pull_index_chunks<I: IndexFile>(
  25     _worker: &WorkerTask,
  26     chunk_reader: &mut RemoteChunkReader,
  27     target: Arc<DataStore>,
  28     index: I,
  29 ) -> Result<(), Error> {
  30
  31
  32     for pos in 0..index.index_count() {
  33         let digest = index.index_digest(pos).unwrap();
  34         let chunk_exists = target.cond_touch_chunk(digest, false)?;
  35         if chunk_exists {
  36             //worker.log(format!("chunk {} exists {}", pos, proxmox::tools::digest_to_hex(digest)));
  37             continue;
  38         }
  39         //worker.log(format!("sync {} chunk {}", pos, proxmox::tools::digest_to_hex(digest)));
  40         let chunk = chunk_reader.read_raw_chunk(&digest)?;
  41
  42         target.insert_chunk(&chunk, &digest)?;
  43     }
  44
  45     Ok(())
  46 }
  47
  48 async fn download_manifest(
  49     reader: &BackupReader,
  50     filename: &std::path::Path,
  51 ) -> Result<std::fs::File, Error> {
  52
  53     let tmp_manifest_file = std::fs::OpenOptions::new()
  54         .write(true)
  55         .create(true)
  56         .read(true)
  57         .open(&filename)?;
  58
  59     let mut tmp_manifest_file = reader.download(MANIFEST_BLOB_NAME, tmp_manifest_file).await?;
  60
  61     tmp_manifest_file.seek(SeekFrom::Start(0))?;
  62
  63     Ok(tmp_manifest_file)
  64 }
  65
  66 async fn pull_single_archive(
  67     worker: &WorkerTask,
  68     reader: &BackupReader,
  69     chunk_reader: &mut RemoteChunkReader,
  70     tgt_store: Arc<DataStore>,
  71     snapshot: &BackupDir,
  72     archive_name: &str,
  73 ) -> Result<(), Error> {
  74
  75     let mut path = tgt_store.base_path();
  76     path.push(snapshot.relative_path());
  77     path.push(archive_name);
  78
  79     let mut tmp_path = path.clone();
  80     tmp_path.set_extension("tmp");
  81
  82     worker.log(format!("sync archive {}", archive_name));
  83     let tmpfile = std::fs::OpenOptions::new()
  84         .write(true)
  85         .create(true)
  86         .read(true)
  87         .open(&tmp_path)?;
  88
  89     let tmpfile = reader.download(archive_name, tmpfile).await?;
  90
  91     match archive_type(archive_name)? {
  92         ArchiveType::DynamicIndex => {
  93             let index = DynamicIndexReader::new(tmpfile)
  94                 .map_err(|err| format_err!("unable to read dynamic index {:?} - {}", tmp_path, err))?;
  95
  96             pull_index_chunks(worker, chunk_reader, tgt_store.clone(), index).await?;
  97         }
  98         ArchiveType::FixedIndex => {
  99             let index = FixedIndexReader::new(tmpfile)
 100                 .map_err(|err| format_err!("unable to read fixed index '{:?}' - {}", tmp_path, err))?;
 101
 102             pull_index_chunks(worker, chunk_reader, tgt_store.clone(), index).await?;
 103         }
 104         ArchiveType::Blob => { /* nothing to do */ }
 105     }
 106     if let Err(err) = std::fs::rename(&tmp_path, &path) {
 107         bail!("Atomic rename file {:?} failed - {}", path, err);
 108     }
 109     Ok(())
 110 }
 111
 112 async fn pull_snapshot(
 113     worker: &WorkerTask,
 114     reader: Arc<BackupReader>,
 115     tgt_store: Arc<DataStore>,
 116     snapshot: &BackupDir,
 117 ) -> Result<(), Error> {
 118
 119     let mut manifest_name = tgt_store.base_path();
 120     manifest_name.push(snapshot.relative_path());
 121     manifest_name.push(MANIFEST_BLOB_NAME);
 122
 123     let mut tmp_manifest_name = manifest_name.clone();
 124     tmp_manifest_name.set_extension("tmp");
 125
 126     let mut tmp_manifest_file = download_manifest(&reader, &tmp_manifest_name).await?;
 127     let tmp_manifest_blob = DataBlob::load(&mut tmp_manifest_file)?;
 128     tmp_manifest_blob.verify_crc()?;
 129
 130     if manifest_name.exists() {
 131         let manifest_blob = proxmox::tools::try_block!({
 132             let mut manifest_file = std::fs::File::open(&manifest_name)
 133                 .map_err(|err| format_err!("unable to open local manifest {:?} - {}", manifest_name, err))?;
 134
 135             let manifest_blob = DataBlob::load(&mut manifest_file)?;
 136             manifest_blob.verify_crc()?;
 137             Ok(manifest_blob)
 138         }).map_err(|err: Error| {
 139             format_err!("unable to read local manifest {:?} - {}", manifest_name, err)
 140         })?;
 141
 142         if manifest_blob.raw_data() == tmp_manifest_blob.raw_data() {
 143             return Ok(()); // nothing changed
 144         }
 145     }
 146
 147     let manifest = BackupManifest::try_from(tmp_manifest_blob)?;
 148
 149     let mut chunk_reader = RemoteChunkReader::new(reader.clone(), None, HashMap::new());
 150
 151     for item in manifest.files() {
 152         let mut path = tgt_store.base_path();
 153         path.push(snapshot.relative_path());
 154         path.push(&item.filename);
 155
 156         if path.exists() {
 157             match archive_type(&item.filename)? {
 158                 ArchiveType::DynamicIndex => {
 159                     let index = DynamicIndexReader::open(&path)?;
 160                     let (csum, size) = index.compute_csum();
 161                     match manifest.verify_file(&item.filename, &csum, size) {
 162                         Ok(_) => continue,
 163                         Err(err) => {
 164                             worker.log(format!("detected changed file {:?} - {}", path, err));
 165                         }
 166                     }
 167                 }
 168                 ArchiveType::FixedIndex => {
 169                     let index = FixedIndexReader::open(&path)?;
 170                     let (csum, size) = index.compute_csum();
 171                     match manifest.verify_file(&item.filename, &csum, size) {
 172                         Ok(_) => continue,
 173                         Err(err) => {
 174                             worker.log(format!("detected changed file {:?} - {}", path, err));
 175                         }
 176                     }
 177                 }
 178                 ArchiveType::Blob => {
 179                     let mut tmpfile = std::fs::File::open(&path)?;
 180                     let (csum, size) = compute_file_csum(&mut tmpfile)?;
 181                     match manifest.verify_file(&item.filename, &csum, size) {
 182                         Ok(_) => continue,
 183                         Err(err) => {
 184                             worker.log(format!("detected changed file {:?} - {}", path, err));
 185                         }
 186                     }
 187                 }
 188             }
 189         }
 190
 191         pull_single_archive(
 192             worker,
 193             &reader,
 194             &mut chunk_reader,
 195             tgt_store.clone(),
 196             snapshot,
 197             &item.filename,
 198         ).await?;
 199     }
 200
 201     if let Err(err) = std::fs::rename(&tmp_manifest_name, &manifest_name) {
 202         bail!("Atomic rename file {:?} failed - {}", manifest_name, err);
 203     }
 204
 205     // cleanup - remove stale files
 206     tgt_store.cleanup_backup_dir(snapshot, &manifest)?;
 207
 208     Ok(())
 209 }
 210
 211 pub async fn pull_snapshot_from(
 212     worker: &WorkerTask,
 213     reader: Arc<BackupReader>,
 214     tgt_store: Arc<DataStore>,
 215     snapshot: &BackupDir,
 216 ) -> Result<(), Error> {
 217
 218     let (_path, is_new) = tgt_store.create_backup_dir(&snapshot)?;
 219
 220     if is_new {
 221         worker.log(format!("sync snapshot {:?}", snapshot.relative_path()));
 222
 223         if let Err(err) = pull_snapshot(worker, reader, tgt_store.clone(), &snapshot).await {
 224             if let Err(cleanup_err) = tgt_store.remove_backup_dir(&snapshot) {
 225                 worker.log(format!("cleanup error - {}", cleanup_err));
 226             }
 227             return Err(err);
 228         }
 229     } else {
 230         worker.log(format!("re-sync snapshot {:?}", snapshot.relative_path()));
 231         pull_snapshot(worker, reader, tgt_store.clone(), &snapshot).await?
 232     }
 233
 234     Ok(())
 235 }
 236
 237 pub async fn pull_group(
 238     worker: &WorkerTask,
 239     client: &HttpClient,
 240     src_repo: &BackupRepository,
 241     tgt_store: Arc<DataStore>,
 242     group: &BackupGroup,
 243 ) -> Result<(), Error> {
 244
 245     let path = format!("api2/json/admin/datastore/{}/snapshots", src_repo.store());
 246
 247     let args = json!({
 248         "backup-type": group.backup_type(),
 249         "backup-id": group.backup_id(),
 250     });
 251
 252     let mut result = client.get(&path, Some(args)).await?;
 253     let mut list: Vec<SnapshotListItem> = serde_json::from_value(result["data"].take())?;
 254
 255     list.sort_unstable_by(|a, b| a.backup_time.cmp(&b.backup_time));
 256
 257     let auth_info = client.login().await?;
 258
 259     let last_sync = group.last_successful_backup(&tgt_store.base_path())?;
 260
 261     for item in list {
 262         let backup_time = Utc.timestamp(item.backup_time, 0);
 263         if let Some(last_sync_time) = last_sync {
 264             if last_sync_time > backup_time { continue; }
 265         }
 266
 267         let new_client = HttpClient::new(
 268             src_repo.host(),
 269             src_repo.user(),
 270             Some(auth_info.ticket.clone())
 271         )?;
 272
 273         let reader = BackupReader::start(
 274             new_client,
 275             None,
 276             src_repo.store(),
 277             &item.backup_type,
 278             &item.backup_id,
 279             backup_time,
 280             true,
 281         ).await?;
 282
 283         let snapshot = BackupDir::new(item.backup_type, item.backup_id, item.backup_time);
 284
 285         pull_snapshot_from(worker, reader, tgt_store.clone(), &snapshot).await?;
 286     }
 287
 288     Ok(())
 289 }
 290
 291 pub async fn pull_store(
 292     worker: &WorkerTask,
 293     client: &HttpClient,
 294     src_repo: &BackupRepository,
 295     tgt_store: Arc<DataStore>,
 296 ) -> Result<(), Error> {
 297
 298     let path = format!("api2/json/admin/datastore/{}/groups", src_repo.store());
 299
 300     let mut result = client.get(&path, None).await?;
 301
 302     let mut list: Vec<GroupListItem> = serde_json::from_value(result["data"].take())?;
 303
 304     list.sort_unstable_by(|a, b| {
 305         let type_order = a.backup_type.cmp(&b.backup_type);
 306         if type_order == std::cmp::Ordering::Equal {
 307             a.backup_id.cmp(&b.backup_id)
 308         } else {
 309             type_order
 310         }
 311     });
 312
 313     let mut errors = false;
 314
 315     for item in list {
 316         let group = BackupGroup::new(&item.backup_type, &item.backup_id);
 317         if let Err(err) = pull_group(worker, client, src_repo, tgt_store.clone(), &group).await {
 318             worker.log(format!("sync group {}/{} failed - {}", item.backup_type, item.backup_id, err));
 319             errors = true;
 320             // continue
 321         }
 322     }
 323
 324     if errors {
 325         bail!("sync failed with some errors.");
 326     }
 327
 328     Ok(())
 329 }
 330
 331 #[api(
 332     input: {
 333         properties: {
 334             store: {
 335                 schema: DATASTORE_SCHEMA,
 336             },
 337             remote: {
 338                 schema: REMOTE_ID_SCHEMA,
 339             },
 340             "remote-store": {
 341                 schema: DATASTORE_SCHEMA,
 342             },
 343         },
 344     },
 345 )]
 346 /// Sync store from other repository
 347 async fn pull (
 348     store: String,
 349     remote: String,
 350     remote_store: String,
 351     _info: &ApiMethod,
 352     rpcenv: &mut dyn RpcEnvironment,
 353 ) -> Result<String, Error> {
 354
 355     let username = rpcenv.get_user().unwrap();
 356
 357     let tgt_store = DataStore::lookup_datastore(&store)?;
 358
 359     let (remote_config, _digest) = remote::config()?;
 360     let remote: remote::Remote = remote_config.lookup("remote", &remote)?;
 361
 362     let client = HttpClient::new(&remote.host, &remote.userid, Some(remote.password.clone()))?;
 363     let _auth_info = client.login() // make sure we can auth
 364         .await
 365         .map_err(|err| format_err!("remote connection to '{}' failed - {}", remote.host, err))?;
 366
 367     let src_repo = BackupRepository::new(Some(remote.userid), Some(remote.host), remote_store);
 368
 369     // fixme: set to_stdout to false?
 370     let upid_str = WorkerTask::spawn("sync", Some(store.clone()), &username.clone(), true, move |worker| async move {
 371
 372         worker.log(format!("sync datastore '{}' start", store));
 373
 374         // explicit create shared lock to prevent GC on newly created chunks
 375         let _shared_store_lock = tgt_store.try_shared_chunk_store_lock()?;
 376
 377         pull_store(&worker, &client, &src_repo, tgt_store.clone()).await?;
 378
 379         worker.log(format!("sync datastore '{}' end", store));
 380
 381         Ok(())
 382     })?;
 383
 384     Ok(upid_str)
 385 }
 386
 387 pub const ROUTER: Router = Router::new()
 388     .post(&API_METHOD_PULL);