-use std::collections::{HashSet, HashMap};
-use std::convert::TryFrom;
+use std::collections::HashSet;
use std::io::{self, Read, Write, Seek, SeekFrom};
-use std::os::unix::io::{FromRawFd, RawFd};
use std::path::{Path, PathBuf};
use std::pin::Pin;
use std::sync::{Arc, Mutex};
use futures::stream::{StreamExt, TryStreamExt};
use serde_json::{json, Value};
use tokio::sync::mpsc;
+use tokio_stream::wrappers::ReceiverStream;
use xdg::BaseDirectories;
use pathpatterns::{MatchEntry, MatchType, PatternFlag};
use proxmox::{
tools::{
time::{strftime_local, epoch_i64},
- fs::{file_get_contents, file_get_json, replace_file, CreateOptions, image_size},
+ fs::{file_get_json, replace_file, CreateOptions, image_size},
},
api::{
api,
};
use pxar::accessor::{MaybeReady, ReadAt, ReadAtOperation};
-use proxmox_backup::tools;
+use pbs_datastore::catalog::BackupCatalogWriter;
+
+use proxmox_backup::tools::{
+ self,
+ StdChannelWriter,
+ TokioWriterAdapter,
+};
use proxmox_backup::api2::types::*;
use proxmox_backup::api2::version;
use proxmox_backup::client::*;
-use proxmox_backup::pxar::catalog::*;
use proxmox_backup::backup::{
archive_type,
decrypt_key,
+ rsa_encrypt_key_config,
verify_chunk_size,
ArchiveType,
AsyncReadChunk,
ChunkStream,
CryptConfig,
CryptMode,
- DataBlob,
DynamicIndexReader,
+ ENCRYPTED_KEY_BLOB_NAME,
FixedChunkStream,
FixedIndexReader,
+ KeyConfig,
IndexFile,
MANIFEST_BLOB_NAME,
Shell,
mod proxmox_backup_client;
use proxmox_backup_client::*;
-const ENV_VAR_PBS_FINGERPRINT: &str = "PBS_FINGERPRINT";
-const ENV_VAR_PBS_PASSWORD: &str = "PBS_PASSWORD";
-
-
-pub const REPO_URL_SCHEMA: Schema = StringSchema::new("Repository URL.")
- .format(&BACKUP_REPO_URL)
- .max_length(256)
- .schema();
-
-pub const KEYFILE_SCHEMA: Schema = StringSchema::new(
- "Path to encryption key. All data will be encrypted using this key.")
- .schema();
-
-pub const KEYFD_SCHEMA: Schema = IntegerSchema::new(
- "Pass an encryption key via an already opened file descriptor.")
- .minimum(0)
- .schema();
-
-const CHUNK_SIZE_SCHEMA: Schema = IntegerSchema::new(
- "Chunk size in KB. Must be a power of 2.")
- .minimum(64)
- .maximum(4096)
- .default(4096)
- .schema();
-
-fn get_default_repository() -> Option<String> {
- std::env::var("PBS_REPOSITORY").ok()
-}
-
-pub fn extract_repository_from_value(
- param: &Value,
-) -> Result<BackupRepository, Error> {
-
- let repo_url = param["repository"]
- .as_str()
- .map(String::from)
- .or_else(get_default_repository)
- .ok_or_else(|| format_err!("unable to get (default) repository"))?;
-
- let repo: BackupRepository = repo_url.parse()?;
-
- Ok(repo)
-}
-
-fn extract_repository_from_map(
- param: &HashMap<String, String>,
-) -> Option<BackupRepository> {
-
- param.get("repository")
- .map(String::from)
- .or_else(get_default_repository)
- .and_then(|repo_url| repo_url.parse::<BackupRepository>().ok())
-}
+pub mod proxmox_client_tools;
+use proxmox_client_tools::{
+ complete_archive_name, complete_auth_id, complete_backup_group, complete_backup_snapshot,
+ complete_backup_source, complete_chunk_size, complete_group_or_snapshot,
+ complete_img_archive_name, complete_pxar_archive_name, complete_repository, connect,
+ extract_repository_from_value,
+ key_source::{
+ crypto_parameters, format_key_source, get_encryption_key_password, KEYFD_SCHEMA,
+ KEYFILE_SCHEMA, MASTER_PUBKEY_FD_SCHEMA, MASTER_PUBKEY_FILE_SCHEMA,
+ },
+ CHUNK_SIZE_SCHEMA, REPO_URL_SCHEMA,
+};
fn record_repository(repo: &BackupRepository) {
let _ = replace_file(path, new_data.to_string().as_bytes(), CreateOptions::new());
}
-pub fn complete_repository(_arg: &str, _param: &HashMap<String, String>) -> Vec<String> {
-
- let mut result = vec![];
-
- let base = match BaseDirectories::with_prefix("proxmox-backup") {
- Ok(v) => v,
- _ => return result,
- };
-
- // usually $HOME/.cache/proxmox-backup/repo-list
- let path = match base.place_cache_file("repo-list") {
- Ok(v) => v,
- _ => return result,
- };
-
- let data = file_get_json(&path, None).unwrap_or_else(|_| json!({}));
-
- if let Some(map) = data.as_object() {
- for (repo, _count) in map {
- result.push(repo.to_owned());
- }
- }
-
- result
-}
-
-fn connect(server: &str, port: u16, userid: &Userid) -> Result<HttpClient, Error> {
-
- let fingerprint = std::env::var(ENV_VAR_PBS_FINGERPRINT).ok();
-
- use std::env::VarError::*;
- let password = match std::env::var(ENV_VAR_PBS_PASSWORD) {
- Ok(p) => Some(p),
- Err(NotUnicode(_)) => bail!(format!("{} contains bad characters", ENV_VAR_PBS_PASSWORD)),
- Err(NotPresent) => None,
- };
-
- let options = HttpClientOptions::new()
- .prefix(Some("proxmox-backup".to_string()))
- .password(password)
- .interactive(true)
- .fingerprint(fingerprint)
- .fingerprint_cache(true)
- .ticket_cache(true);
-
- HttpClient::new(server, port, userid, options)
-}
-
-async fn view_task_result(
- client: HttpClient,
- result: Value,
- output_format: &str,
-) -> Result<(), Error> {
- let data = &result["data"];
- if output_format == "text" {
- if let Some(upid) = data.as_str() {
- display_task_log(client, upid, true).await?;
- }
- } else {
- format_and_print_result(&data, &output_format);
- }
-
- Ok(())
-}
-
async fn api_datastore_list_snapshots(
client: &HttpClient,
store: &str,
async fn backup_directory<P: AsRef<Path>>(
client: &BackupWriter,
- previous_manifest: Option<Arc<BackupManifest>>,
dir_path: P,
archive_name: &str,
chunk_size: Option<usize>,
- device_set: Option<HashSet<u64>>,
- verbose: bool,
- skip_lost_and_found: bool,
- catalog: Arc<Mutex<CatalogWriter<crate::tools::StdChannelWriter>>>,
- exclude_pattern: Vec<MatchEntry>,
- entries_max: usize,
- compress: bool,
- encrypt: bool,
+ catalog: Arc<Mutex<CatalogWriter<TokioWriterAdapter<StdChannelWriter>>>>,
+ pxar_create_options: proxmox_backup::pxar::PxarCreateOptions,
+ upload_options: UploadOptions,
) -> Result<BackupStats, Error> {
let pxar_stream = PxarBackupStream::open(
dir_path.as_ref(),
- device_set,
- verbose,
- skip_lost_and_found,
catalog,
- exclude_pattern,
- entries_max,
+ pxar_create_options,
)?;
let mut chunk_stream = ChunkStream::new(pxar_stream, chunk_size);
- let (mut tx, rx) = mpsc::channel(10); // allow to buffer 10 chunks
+ let (tx, rx) = mpsc::channel(10); // allow to buffer 10 chunks
- let stream = rx
+ let stream = ReceiverStream::new(rx)
.map_err(Error::from);
// spawn chunker inside a separate task so that it can run parallel
}
});
+ if upload_options.fixed_size.is_some() {
+ bail!("cannot backup directory with fixed chunk size!");
+ }
+
let stats = client
- .upload_stream(previous_manifest, archive_name, stream, "dynamic", None, compress, encrypt)
+ .upload_stream(archive_name, stream, upload_options)
.await?;
Ok(stats)
async fn backup_image<P: AsRef<Path>>(
client: &BackupWriter,
- previous_manifest: Option<Arc<BackupManifest>>,
image_path: P,
archive_name: &str,
- image_size: u64,
chunk_size: Option<usize>,
- compress: bool,
- encrypt: bool,
- _verbose: bool,
+ upload_options: UploadOptions,
) -> Result<BackupStats, Error> {
let path = image_path.as_ref().to_owned();
let stream = FixedChunkStream::new(stream, chunk_size.unwrap_or(4*1024*1024));
+ if upload_options.fixed_size.is_none() {
+ bail!("cannot backup image with dynamic chunk size!");
+ }
+
let stats = client
- .upload_stream(previous_manifest, archive_name, stream, "fixed", Some(image_size), compress, encrypt)
+ .upload_stream(archive_name, stream, upload_options)
.await?;
Ok(stats)
let repo = extract_repository_from_value(¶m)?;
- let client = connect(repo.host(), repo.port(), repo.user())?;
+ let client = connect(&repo)?;
let path = format!("api2/json/admin/datastore/{}/groups", repo.store());
let render_files = |_v: &Value, record: &Value| -> Result<String, Error> {
let item: GroupListItem = serde_json::from_value(record.to_owned())?;
- Ok(tools::format::render_backup_file_list(&item.files))
+ Ok(pbs_tools::format::render_backup_file_list(&item.files))
};
let options = default_table_format_options()
let mut data: Value = result["data"].take();
- let info = &proxmox_backup::api2::admin::datastore::API_RETURN_SCHEMA_LIST_GROUPS;
+ let return_type = &proxmox_backup::api2::admin::datastore::API_METHOD_LIST_GROUPS.returns;
- format_and_print_result_full(&mut data, info, &output_format, &options);
+ format_and_print_result_full(&mut data, return_type, &output_format, &options);
Ok(Value::Null)
}
group: {
type: String,
description: "Backup group.",
- optional: true,
},
- "output-format": {
- schema: OUTPUT_FORMAT,
- optional: true,
+ "new-owner": {
+ type: Authid,
},
}
}
)]
-/// List backup snapshots.
-async fn list_snapshots(param: Value) -> Result<Value, Error> {
+/// Change owner of a backup group
+async fn change_backup_owner(group: String, mut param: Value) -> Result<(), Error> {
let repo = extract_repository_from_value(¶m)?;
- let output_format = get_output_format(¶m);
-
- let client = connect(repo.host(), repo.port(), repo.user())?;
-
- let group: Option<BackupGroup> = if let Some(path) = param["group"].as_str() {
- Some(path.parse()?)
- } else {
- None
- };
-
- let mut data = api_datastore_list_snapshots(&client, repo.store(), group).await?;
-
- record_repository(&repo);
+ let mut client = connect(&repo)?;
- let render_snapshot_path = |_v: &Value, record: &Value| -> Result<String, Error> {
- let item: SnapshotListItem = serde_json::from_value(record.to_owned())?;
- let snapshot = BackupDir::new(item.backup_type, item.backup_id, item.backup_time)?;
- Ok(snapshot.relative_path().to_str().unwrap().to_owned())
- };
-
- let render_files = |_v: &Value, record: &Value| -> Result<String, Error> {
- let item: SnapshotListItem = serde_json::from_value(record.to_owned())?;
- let mut filenames = Vec::new();
- for file in &item.files {
- filenames.push(file.filename.to_string());
- }
- Ok(tools::format::render_backup_file_list(&filenames[..]))
- };
-
- let options = default_table_format_options()
- .sortby("backup-type", false)
- .sortby("backup-id", false)
- .sortby("backup-time", false)
- .column(ColumnConfig::new("backup-id").renderer(render_snapshot_path).header("snapshot"))
- .column(ColumnConfig::new("size"))
- .column(ColumnConfig::new("files").renderer(render_files))
- ;
-
- let info = &proxmox_backup::api2::admin::datastore::API_RETURN_SCHEMA_LIST_SNAPSHOTS;
-
- format_and_print_result_full(&mut data, info, &output_format, &options);
-
- Ok(Value::Null)
-}
-
-#[api(
- input: {
- properties: {
- repository: {
- schema: REPO_URL_SCHEMA,
- optional: true,
- },
- snapshot: {
- type: String,
- description: "Snapshot path.",
- },
- }
- }
-)]
-/// Forget (remove) backup snapshots.
-async fn forget_snapshots(param: Value) -> Result<Value, Error> {
-
- let repo = extract_repository_from_value(¶m)?;
-
- let path = tools::required_string_param(¶m, "snapshot")?;
- let snapshot: BackupDir = path.parse()?;
+ param.as_object_mut().unwrap().remove("repository");
- let mut client = connect(repo.host(), repo.port(), repo.user())?;
+ let group: BackupGroup = group.parse()?;
- let path = format!("api2/json/admin/datastore/{}/snapshots", repo.store());
+ param["backup-type"] = group.backup_type().into();
+ param["backup-id"] = group.backup_id().into();
- let result = client.delete(&path, Some(json!({
- "backup-type": snapshot.group().backup_type(),
- "backup-id": snapshot.group().backup_id(),
- "backup-time": snapshot.backup_time(),
- }))).await?;
+ let path = format!("api2/json/admin/datastore/{}/change-owner", repo.store());
+ client.post(&path, Some(param)).await?;
record_repository(&repo);
- Ok(result)
+ Ok(())
}
#[api(
let repo = extract_repository_from_value(¶m)?;
- let client = connect(repo.host(), repo.port(), repo.user())?;
+ let client = connect(&repo)?;
client.login().await?;
record_repository(&repo);
let repo = extract_repository_from_value(¶m);
if let Ok(repo) = repo {
- let client = connect(repo.host(), repo.port(), repo.user())?;
+ let client = connect(&repo)?;
match client.get("api2/json/version", None).await {
Ok(mut result) => version_info["server"] = result["data"].take(),
Ok(())
}
-
-#[api(
- input: {
- properties: {
- repository: {
- schema: REPO_URL_SCHEMA,
- optional: true,
- },
- snapshot: {
- type: String,
- description: "Snapshot path.",
- },
- "output-format": {
- schema: OUTPUT_FORMAT,
- optional: true,
- },
- }
- }
-)]
-/// List snapshot files.
-async fn list_snapshot_files(param: Value) -> Result<Value, Error> {
-
- let repo = extract_repository_from_value(¶m)?;
-
- let path = tools::required_string_param(¶m, "snapshot")?;
- let snapshot: BackupDir = path.parse()?;
-
- let output_format = get_output_format(¶m);
-
- let client = connect(repo.host(), repo.port(), repo.user())?;
-
- let path = format!("api2/json/admin/datastore/{}/files", repo.store());
-
- let mut result = client.get(&path, Some(json!({
- "backup-type": snapshot.group().backup_type(),
- "backup-id": snapshot.group().backup_id(),
- "backup-time": snapshot.backup_time(),
- }))).await?;
-
- record_repository(&repo);
-
- let info = &proxmox_backup::api2::admin::datastore::API_RETURN_SCHEMA_LIST_SNAPSHOT_FILES;
-
- let mut data: Value = result["data"].take();
-
- let options = default_table_format_options();
-
- format_and_print_result_full(&mut data, info, &output_format, &options);
-
- Ok(Value::Null)
-}
-
#[api(
input: {
properties: {
let output_format = get_output_format(¶m);
- let mut client = connect(repo.host(), repo.port(), repo.user())?;
+ let mut client = connect(&repo)?;
let path = format!("api2/json/admin/datastore/{}/gc", repo.store());
record_repository(&repo);
- view_task_result(client, result, &output_format).await?;
+ view_task_result(&mut client, result, &output_format).await?;
Ok(Value::Null)
}
+struct CatalogUploadResult {
+ catalog_writer: Arc<Mutex<CatalogWriter<TokioWriterAdapter<StdChannelWriter>>>>,
+ result: tokio::sync::oneshot::Receiver<Result<BackupStats, Error>>,
+}
+
fn spawn_catalog_upload(
client: Arc<BackupWriter>,
encrypt: bool,
-) -> Result<
- (
- Arc<Mutex<CatalogWriter<crate::tools::StdChannelWriter>>>,
- tokio::sync::oneshot::Receiver<Result<BackupStats, Error>>
- ), Error>
-{
+) -> Result<CatalogUploadResult, Error> {
let (catalog_tx, catalog_rx) = std::sync::mpsc::sync_channel(10); // allow to buffer 10 writes
let catalog_stream = crate::tools::StdChannelStream(catalog_rx);
let catalog_chunk_size = 512*1024;
let catalog_chunk_stream = ChunkStream::new(catalog_stream, Some(catalog_chunk_size));
- let catalog = Arc::new(Mutex::new(CatalogWriter::new(crate::tools::StdChannelWriter::new(catalog_tx))?));
+ let catalog_writer = Arc::new(Mutex::new(CatalogWriter::new(TokioWriterAdapter::new(StdChannelWriter::new(catalog_tx)))?));
let (catalog_result_tx, catalog_result_rx) = tokio::sync::oneshot::channel();
+ let upload_options = UploadOptions {
+ encrypt,
+ compress: true,
+ ..UploadOptions::default()
+ };
+
tokio::spawn(async move {
let catalog_upload_result = client
- .upload_stream(None, CATALOG_NAME, catalog_chunk_stream, "dynamic", None, true, encrypt)
+ .upload_stream(CATALOG_NAME, catalog_chunk_stream, upload_options)
.await;
if let Err(ref err) = catalog_upload_result {
let _ = catalog_result_tx.send(catalog_upload_result);
});
- Ok((catalog, catalog_result_rx))
-}
-
-fn keyfile_parameters(param: &Value) -> Result<(Option<Vec<u8>>, CryptMode), Error> {
- let keyfile = match param.get("keyfile") {
- Some(Value::String(keyfile)) => Some(keyfile),
- Some(_) => bail!("bad --keyfile parameter type"),
- None => None,
- };
-
- let key_fd = match param.get("keyfd") {
- Some(Value::Number(key_fd)) => Some(
- RawFd::try_from(key_fd
- .as_i64()
- .ok_or_else(|| format_err!("bad key fd: {:?}", key_fd))?
- )
- .map_err(|err| format_err!("bad key fd: {:?}: {}", key_fd, err))?
- ),
- Some(_) => bail!("bad --keyfd parameter type"),
- None => None,
- };
-
- let crypt_mode: Option<CryptMode> = match param.get("crypt-mode") {
- Some(mode) => Some(serde_json::from_value(mode.clone())?),
- None => None,
- };
-
- let keydata = match (keyfile, key_fd) {
- (None, None) => None,
- (Some(_), Some(_)) => bail!("--keyfile and --keyfd are mutually exclusive"),
- (Some(keyfile), None) => Some(file_get_contents(keyfile)?),
- (None, Some(fd)) => {
- let input = unsafe { std::fs::File::from_raw_fd(fd) };
- let mut data = Vec::new();
- let _len: usize = { input }.read_to_end(&mut data)
- .map_err(|err| {
- format_err!("error reading encryption key from fd {}: {}", fd, err)
- })?;
- Some(data)
- }
- };
-
- Ok(match (keydata, crypt_mode) {
- // no parameters:
- (None, None) => match key::read_optional_default_encryption_key()? {
- Some(key) => (Some(key), CryptMode::Encrypt),
- None => (None, CryptMode::None),
- },
-
- // just --crypt-mode=none
- (None, Some(CryptMode::None)) => (None, CryptMode::None),
-
- // just --crypt-mode other than none
- (None, Some(crypt_mode)) => match key::read_optional_default_encryption_key()? {
- None => bail!("--crypt-mode without --keyfile and no default key file available"),
- Some(key) => (Some(key), crypt_mode),
- }
-
- // just --keyfile
- (Some(key), None) => (Some(key), CryptMode::Encrypt),
-
- // --keyfile and --crypt-mode=none
- (Some(_), Some(CryptMode::None)) => {
- bail!("--keyfile/--keyfd and --crypt-mode=none are mutually exclusive");
- }
-
- // --keyfile and --crypt-mode other than none
- (Some(key), Some(crypt_mode)) => (Some(key), crypt_mode),
- })
+ Ok(CatalogUploadResult { catalog_writer, result: catalog_result_rx })
}
#[api(
description: "Path to file.",
}
},
+ "all-file-systems": {
+ type: Boolean,
+ description: "Include all mounted subdirectories.",
+ optional: true,
+ },
keyfile: {
schema: KEYFILE_SCHEMA,
optional: true,
schema: KEYFD_SCHEMA,
optional: true,
},
+ "master-pubkey-file": {
+ schema: MASTER_PUBKEY_FILE_SCHEMA,
+ optional: true,
+ },
+ "master-pubkey-fd": {
+ schema: MASTER_PUBKEY_FD_SCHEMA,
+ optional: true,
+ },
"crypt-mode": {
type: CryptMode,
optional: true,
verify_chunk_size(size)?;
}
- let (keydata, crypt_mode) = keyfile_parameters(¶m)?;
+ let crypto = crypto_parameters(¶m)?;
let backup_id = param["backup-id"].as_str().unwrap_or(&proxmox::tools::nodename());
}
}
- let backup_time = backup_time_opt.unwrap_or_else(|| epoch_i64());
+ let backup_time = backup_time_opt.unwrap_or_else(epoch_i64);
- let client = connect(repo.host(), repo.port(), repo.user())?;
+ let client = connect(&repo)?;
record_repository(&repo);
println!("Starting backup: {}/{}/{}", backup_type, backup_id, BackupDir::backup_time_to_string(backup_time)?);
println!("Starting backup protocol: {}", strftime_local("%c", epoch_i64())?);
- let (crypt_config, rsa_encrypted_key) = match keydata {
+ let (crypt_config, rsa_encrypted_key) = match crypto.enc_key {
None => (None, None),
- Some(key) => {
- let (key, created) = decrypt_key(&key, &key::get_encryption_key_password)?;
+ Some(key_with_source) => {
+ println!(
+ "{}",
+ format_key_source(&key_with_source.source, "encryption")
+ );
+
+ let (key, created, fingerprint) =
+ decrypt_key(&key_with_source.key, &get_encryption_key_password)?;
+ println!("Encryption key fingerprint: {}", fingerprint);
let crypt_config = CryptConfig::new(key)?;
- match key::find_master_pubkey()? {
- Some(ref path) if path.exists() => {
- let pem_data = file_get_contents(path)?;
- let rsa = openssl::rsa::Rsa::public_key_from_pem(&pem_data)?;
- let enc_key = crypt_config.generate_rsa_encoded_key(rsa, created)?;
+ match crypto.master_pubkey {
+ Some(pem_with_source) => {
+ println!("{}", format_key_source(&pem_with_source.source, "master"));
+
+ let rsa = openssl::rsa::Rsa::public_key_from_pem(&pem_with_source.key)?;
+
+ let mut key_config = KeyConfig::without_password(key)?;
+ key_config.created = created; // keep original value
+
+ let enc_key = rsa_encrypt_key_config(rsa, &key_config)?;
+
(Some(Arc::new(crypt_config)), Some(enc_key))
- }
+ },
_ => (Some(Arc::new(crypt_config)), None),
}
}
false
).await?;
- let previous_manifest = if let Ok(previous_manifest) = client.download_previous_manifest().await {
- Some(Arc::new(previous_manifest))
+ let download_previous_manifest = match client.previous_backup_time().await {
+ Ok(Some(backup_time)) => {
+ println!(
+ "Downloading previous manifest ({})",
+ strftime_local("%c", backup_time)?
+ );
+ true
+ }
+ Ok(None) => {
+ println!("No previous manifest available.");
+ false
+ }
+ Err(_) => {
+ // Fallback for outdated server, TODO remove/bubble up with 2.0
+ true
+ }
+ };
+
+ let previous_manifest = if download_previous_manifest {
+ match client.download_previous_manifest().await {
+ Ok(previous_manifest) => {
+ match previous_manifest.check_fingerprint(crypt_config.as_ref().map(Arc::as_ref)) {
+ Ok(()) => Some(Arc::new(previous_manifest)),
+ Err(err) => {
+ println!("Couldn't re-use previous manifest - {}", err);
+ None
+ }
+ }
+ }
+ Err(err) => {
+ println!("Couldn't download previous manifest - {}", err);
+ None
+ }
+ }
} else {
None
};
let mut manifest = BackupManifest::new(snapshot);
let mut catalog = None;
- let mut catalog_result_tx = None;
+ let mut catalog_result_rx = None;
for (backup_type, filename, target, size) in upload_list {
match backup_type {
BackupSpecificationType::CONFIG => {
+ let upload_options = UploadOptions {
+ compress: true,
+ encrypt: crypto.mode == CryptMode::Encrypt,
+ ..UploadOptions::default()
+ };
+
println!("Upload config file '{}' to '{}' as {}", filename, repo, target);
let stats = client
- .upload_blob_from_file(&filename, &target, true, crypt_mode == CryptMode::Encrypt)
+ .upload_blob_from_file(&filename, &target, upload_options)
.await?;
- manifest.add_file(target, stats.size, stats.csum, crypt_mode)?;
+ manifest.add_file(target, stats.size, stats.csum, crypto.mode)?;
}
BackupSpecificationType::LOGFILE => { // fixme: remove - not needed anymore ?
+ let upload_options = UploadOptions {
+ compress: true,
+ encrypt: crypto.mode == CryptMode::Encrypt,
+ ..UploadOptions::default()
+ };
+
println!("Upload log file '{}' to '{}' as {}", filename, repo, target);
let stats = client
- .upload_blob_from_file(&filename, &target, true, crypt_mode == CryptMode::Encrypt)
+ .upload_blob_from_file(&filename, &target, upload_options)
.await?;
- manifest.add_file(target, stats.size, stats.csum, crypt_mode)?;
+ manifest.add_file(target, stats.size, stats.csum, crypto.mode)?;
}
BackupSpecificationType::PXAR => {
// start catalog upload on first use
if catalog.is_none() {
- let (cat, res) = spawn_catalog_upload(client.clone(), crypt_mode == CryptMode::Encrypt)?;
- catalog = Some(cat);
- catalog_result_tx = Some(res);
+ let catalog_upload_res = spawn_catalog_upload(client.clone(), crypto.mode == CryptMode::Encrypt)?;
+ catalog = Some(catalog_upload_res.catalog_writer);
+ catalog_result_rx = Some(catalog_upload_res.result);
}
let catalog = catalog.as_ref().unwrap();
println!("Upload directory '{}' to '{}' as {}", filename, repo, target);
catalog.lock().unwrap().start_directory(std::ffi::CString::new(target.as_str())?.as_c_str())?;
+
+ let pxar_options = proxmox_backup::pxar::PxarCreateOptions {
+ device_set: devices.clone(),
+ patterns: pattern_list.clone(),
+ entries_max: entries_max as usize,
+ skip_lost_and_found,
+ verbose,
+ };
+
+ let upload_options = UploadOptions {
+ previous_manifest: previous_manifest.clone(),
+ compress: true,
+ encrypt: crypto.mode == CryptMode::Encrypt,
+ ..UploadOptions::default()
+ };
+
let stats = backup_directory(
&client,
- previous_manifest.clone(),
&filename,
&target,
chunk_size_opt,
- devices.clone(),
- verbose,
- skip_lost_and_found,
catalog.clone(),
- pattern_list.clone(),
- entries_max as usize,
- true,
- crypt_mode == CryptMode::Encrypt,
+ pxar_options,
+ upload_options,
).await?;
- manifest.add_file(target, stats.size, stats.csum, crypt_mode)?;
+ manifest.add_file(target, stats.size, stats.csum, crypto.mode)?;
catalog.lock().unwrap().end_directory()?;
}
BackupSpecificationType::IMAGE => {
println!("Upload image '{}' to '{:?}' as {}", filename, repo, target);
+
+ let upload_options = UploadOptions {
+ previous_manifest: previous_manifest.clone(),
+ fixed_size: Some(size),
+ compress: true,
+ encrypt: crypto.mode == CryptMode::Encrypt,
+ };
+
let stats = backup_image(
&client,
- previous_manifest.clone(),
- &filename,
+ &filename,
&target,
- size,
chunk_size_opt,
- true,
- crypt_mode == CryptMode::Encrypt,
- verbose,
+ upload_options,
).await?;
- manifest.add_file(target, stats.size, stats.csum, crypt_mode)?;
+ manifest.add_file(target, stats.size, stats.csum, crypto.mode)?;
}
}
}
drop(catalog); // close upload stream
- if let Some(catalog_result_rx) = catalog_result_tx {
+ if let Some(catalog_result_rx) = catalog_result_rx {
let stats = catalog_result_rx.await??;
- manifest.add_file(CATALOG_NAME.to_owned(), stats.size, stats.csum, crypt_mode)?;
+ manifest.add_file(CATALOG_NAME.to_owned(), stats.size, stats.csum, crypto.mode)?;
}
}
if let Some(rsa_encrypted_key) = rsa_encrypted_key {
- let target = "rsa-encrypted.key.blob";
+ let target = ENCRYPTED_KEY_BLOB_NAME;
println!("Upload RSA encoded key to '{:?}' as {}", repo, target);
+ let options = UploadOptions { compress: false, encrypt: false, ..UploadOptions::default() };
let stats = client
- .upload_blob_from_data(rsa_encrypted_key, target, false, false)
+ .upload_blob_from_data(rsa_encrypted_key, target, options)
.await?;
- manifest.add_file(target.to_string(), stats.size, stats.csum, crypt_mode)?;
-
- // openssl rsautl -decrypt -inkey master-private.pem -in rsa-encrypted.key -out t
- /*
- let mut buffer2 = vec![0u8; rsa.size() as usize];
- let pem_data = file_get_contents("master-private.pem")?;
- let rsa = openssl::rsa::Rsa::private_key_from_pem(&pem_data)?;
- let len = rsa.private_decrypt(&buffer, &mut buffer2, openssl::rsa::Padding::PKCS1)?;
- println!("TEST {} {:?}", len, buffer2);
- */
+ manifest.add_file(target.to_string(), stats.size, stats.csum, crypto.mode)?;
+
}
// create manifest (index.json)
// manifests are never encrypted, but include a signature
if verbose { println!("Upload index.json to '{}'", repo) };
+ let options = UploadOptions { compress: true, encrypt: false, ..UploadOptions::default() };
client
- .upload_blob_from_data(manifest.into_bytes(), MANIFEST_BLOB_NAME, true, false)
+ .upload_blob_from_data(manifest.into_bytes(), MANIFEST_BLOB_NAME, options)
.await?;
client.finish().await?;
Ok(Value::Null)
}
-fn complete_backup_source(arg: &str, param: &HashMap<String, String>) -> Vec<String> {
-
- let mut result = vec![];
-
- let data: Vec<&str> = arg.splitn(2, ':').collect();
-
- if data.len() != 2 {
- result.push(String::from("root.pxar:/"));
- result.push(String::from("etc.pxar:/etc"));
- return result;
- }
-
- let files = tools::complete_file_name(data[1], param);
-
- for file in files {
- result.push(format!("{}:{}", data[0], file));
- }
-
- result
-}
-
async fn dump_image<W: Write>(
client: Arc<BackupReader>,
crypt_config: Option<Arc<CryptConfig>>,
type: String,
description: r###"Target directory path. Use '-' to write to standard output.
-We do not extraxt '.pxar' archives when writing to standard output.
+We do not extract '.pxar' archives when writing to standard output.
"###
},
let archive_name = tools::required_string_param(¶m, "archive-name")?;
- let client = connect(repo.host(), repo.port(), repo.user())?;
+ let client = connect(&repo)?;
record_repository(&repo);
let target = tools::required_string_param(¶m, "target")?;
let target = if target == "-" { None } else { Some(target) };
- let (keydata, _crypt_mode) = keyfile_parameters(¶m)?;
+ let crypto = crypto_parameters(¶m)?;
- let crypt_config = match keydata {
+ let crypt_config = match crypto.enc_key {
None => None,
- Some(key) => {
- let (key, _) = decrypt_key(&key, &key::get_encryption_key_password)?;
+ Some(ref key) => {
+ let (key, _, _) =
+ decrypt_key(&key.key, &get_encryption_key_password).map_err(|err| {
+ eprintln!("{}", format_key_source(&key.source, "encryption"));
+ err
+ })?;
Some(Arc::new(CryptConfig::new(key)?))
}
};
true,
).await?;
+ let (archive_name, archive_type) = parse_archive_type(archive_name);
+
let (manifest, backup_index_data) = client.download_manifest().await?;
- let (archive_name, archive_type) = parse_archive_type(archive_name);
+ if archive_name == ENCRYPTED_KEY_BLOB_NAME && crypt_config.is_none() {
+ eprintln!("Restoring encrypted key blob without original key - skipping manifest fingerprint check!")
+ } else {
+ if manifest.signature.is_some() {
+ if let Some(key) = &crypto.enc_key {
+ eprintln!("{}", format_key_source(&key.source, "encryption"));
+ }
+ if let Some(config) = &crypt_config {
+ eprintln!("Fingerprint: {}", config.fingerprint());
+ }
+ }
+ manifest.check_fingerprint(crypt_config.as_ref().map(Arc::as_ref))?;
+ }
if archive_name == MANIFEST_BLOB_NAME {
if let Some(target) = target {
let mut reader = BufferedDynamicReader::new(index, chunk_reader);
+ let options = proxmox_backup::pxar::PxarExtractOptions {
+ match_list: &[],
+ extract_match_default: true,
+ allow_existing_dirs,
+ on_error: None,
+ };
+
if let Some(target) = target {
proxmox_backup::pxar::extract_archive(
pxar::decoder::Decoder::from_std(reader)?,
Path::new(target),
- &[],
- true,
proxmox_backup::pxar::Flags::DEFAULT,
- allow_existing_dirs,
|path| {
if verbose {
println!("{:?}", path);
}
},
- None,
+ options,
)
.map_err(|err| format_err!("error extracting archive - {}", err))?;
} else {
Ok(Value::Null)
}
-#[api(
- input: {
- properties: {
- repository: {
- schema: REPO_URL_SCHEMA,
- optional: true,
- },
- snapshot: {
- type: String,
- description: "Group/Snapshot path.",
- },
- logfile: {
- type: String,
- description: "The path to the log file you want to upload.",
- },
- keyfile: {
- schema: KEYFILE_SCHEMA,
- optional: true,
- },
- "keyfd": {
- schema: KEYFD_SCHEMA,
- optional: true,
- },
- "crypt-mode": {
- type: CryptMode,
- optional: true,
- },
- }
- }
-)]
-/// Upload backup log file.
-async fn upload_log(param: Value) -> Result<Value, Error> {
-
- let logfile = tools::required_string_param(¶m, "logfile")?;
- let repo = extract_repository_from_value(¶m)?;
-
- let snapshot = tools::required_string_param(¶m, "snapshot")?;
- let snapshot: BackupDir = snapshot.parse()?;
-
- let mut client = connect(repo.host(), repo.port(), repo.user())?;
-
- let (keydata, crypt_mode) = keyfile_parameters(¶m)?;
-
- let crypt_config = match keydata {
- None => None,
- Some(key) => {
- let (key, _created) = decrypt_key(&key, &key::get_encryption_key_password)?;
- let crypt_config = CryptConfig::new(key)?;
- Some(Arc::new(crypt_config))
- }
- };
-
- let data = file_get_contents(logfile)?;
-
- // fixme: howto sign log?
- let blob = match crypt_mode {
- CryptMode::None | CryptMode::SignOnly => DataBlob::encode(&data, None, true)?,
- CryptMode::Encrypt => DataBlob::encode(&data, crypt_config.as_ref().map(Arc::as_ref), true)?,
- };
-
- let raw_data = blob.into_inner();
-
- let path = format!("api2/json/admin/datastore/{}/upload-backup-log", repo.store());
-
- let args = json!({
- "backup-type": snapshot.group().backup_type(),
- "backup-id": snapshot.group().backup_id(),
- "backup-time": snapshot.backup_time(),
- });
-
- let body = hyper::Body::from(raw_data);
-
- client.upload("application/octet-stream", body, &path, Some(args)).await
-}
-
const API_METHOD_PRUNE: ApiMethod = ApiMethod::new(
&ApiHandler::Async(&prune),
&ObjectSchema::new(
async fn prune_async(mut param: Value) -> Result<Value, Error> {
let repo = extract_repository_from_value(¶m)?;
- let mut client = connect(repo.host(), repo.port(), repo.user())?;
+ let mut client = connect(&repo)?;
let path = format!("api2/json/admin/datastore/{}/prune", repo.store());
let group = tools::required_string_param(¶m, "group")?;
let group: BackupGroup = group.parse()?;
- let output_format = get_output_format(¶m);
+ let output_format = extract_output_format(&mut param);
let quiet = param["quiet"].as_bool().unwrap_or(false);
param.as_object_mut().unwrap().remove("repository");
param.as_object_mut().unwrap().remove("group");
- param.as_object_mut().unwrap().remove("output-format");
param.as_object_mut().unwrap().remove("quiet");
param["backup-type"] = group.backup_type().into();
.sortby("backup-id", false)
.sortby("backup-time", false)
.column(ColumnConfig::new("backup-id").renderer(render_snapshot_path).header("snapshot"))
- .column(ColumnConfig::new("backup-time").renderer(tools::format::render_epoch).header("date"))
+ .column(ColumnConfig::new("backup-time").renderer(pbs_tools::format::render_epoch).header("date"))
.column(ColumnConfig::new("keep").renderer(render_prune_action).header("action"))
;
- let info = &proxmox_backup::api2::admin::datastore::API_RETURN_SCHEMA_PRUNE;
+ let return_type = &proxmox_backup::api2::admin::datastore::API_METHOD_PRUNE.returns;
let mut data = result["data"].take();
if quiet {
let list: Vec<Value> = data.as_array().unwrap().iter().filter(|item| {
item["keep"].as_bool() == Some(false)
- }).map(|v| v.clone()).collect();
+ }).cloned().collect();
data = list.into();
}
- format_and_print_result_full(&mut data, info, &output_format, &options);
+ format_and_print_result_full(&mut data, return_type, &output_format, &options);
Ok(Value::Null)
}
optional: true,
},
}
- }
+ },
+ returns: {
+ type: StorageStatus,
+ },
)]
/// Get repository status.
async fn status(param: Value) -> Result<Value, Error> {
let output_format = get_output_format(¶m);
- let client = connect(repo.host(), repo.port(), repo.user())?;
+ let client = connect(&repo)?;
let path = format!("api2/json/admin/datastore/{}/status", repo.store());
.column(ColumnConfig::new("used").renderer(render_total_percentage))
.column(ColumnConfig::new("avail").renderer(render_total_percentage));
- let schema = &proxmox_backup::api2::admin::datastore::API_RETURN_SCHEMA_STATUS;
+ let return_type = &API_METHOD_STATUS.returns;
- format_and_print_result_full(&mut data, schema, &output_format, &options);
+ format_and_print_result_full(&mut data, return_type, &output_format, &options);
Ok(Value::Null)
}
-// like get, but simply ignore errors and return Null instead
-async fn try_get(repo: &BackupRepository, url: &str) -> Value {
-
- let fingerprint = std::env::var(ENV_VAR_PBS_FINGERPRINT).ok();
- let password = std::env::var(ENV_VAR_PBS_PASSWORD).ok();
-
- let options = HttpClientOptions::new()
- .prefix(Some("proxmox-backup".to_string()))
- .password(password)
- .interactive(false)
- .fingerprint(fingerprint)
- .fingerprint_cache(true)
- .ticket_cache(true);
-
- let client = match HttpClient::new(repo.host(), repo.port(), repo.user(), options) {
- Ok(v) => v,
- _ => return Value::Null,
- };
-
- let mut resp = match client.get(url, None).await {
- Ok(v) => v,
- _ => return Value::Null,
- };
-
- if let Some(map) = resp.as_object_mut() {
- if let Some(data) = map.remove("data") {
- return data;
- }
- }
- Value::Null
-}
-
-fn complete_backup_group(_arg: &str, param: &HashMap<String, String>) -> Vec<String> {
- proxmox_backup::tools::runtime::main(async { complete_backup_group_do(param).await })
-}
-
-async fn complete_backup_group_do(param: &HashMap<String, String>) -> Vec<String> {
-
- let mut result = vec![];
-
- let repo = match extract_repository_from_map(param) {
- Some(v) => v,
- _ => return result,
- };
-
- let path = format!("api2/json/admin/datastore/{}/groups", repo.store());
-
- let data = try_get(&repo, &path).await;
-
- if let Some(list) = data.as_array() {
- for item in list {
- if let (Some(backup_id), Some(backup_type)) =
- (item["backup-id"].as_str(), item["backup-type"].as_str())
- {
- result.push(format!("{}/{}", backup_type, backup_id));
- }
- }
- }
-
- result
-}
-
-pub fn complete_group_or_snapshot(arg: &str, param: &HashMap<String, String>) -> Vec<String> {
- proxmox_backup::tools::runtime::main(async { complete_group_or_snapshot_do(arg, param).await })
-}
-
-async fn complete_group_or_snapshot_do(arg: &str, param: &HashMap<String, String>) -> Vec<String> {
-
- if arg.matches('/').count() < 2 {
- let groups = complete_backup_group_do(param).await;
- let mut result = vec![];
- for group in groups {
- result.push(group.to_string());
- result.push(format!("{}/", group));
- }
- return result;
- }
-
- complete_backup_snapshot_do(param).await
-}
-
-fn complete_backup_snapshot(_arg: &str, param: &HashMap<String, String>) -> Vec<String> {
- proxmox_backup::tools::runtime::main(async { complete_backup_snapshot_do(param).await })
-}
-
-async fn complete_backup_snapshot_do(param: &HashMap<String, String>) -> Vec<String> {
-
- let mut result = vec![];
-
- let repo = match extract_repository_from_map(param) {
- Some(v) => v,
- _ => return result,
- };
-
- let path = format!("api2/json/admin/datastore/{}/snapshots", repo.store());
-
- let data = try_get(&repo, &path).await;
-
- if let Some(list) = data.as_array() {
- for item in list {
- if let (Some(backup_id), Some(backup_type), Some(backup_time)) =
- (item["backup-id"].as_str(), item["backup-type"].as_str(), item["backup-time"].as_i64())
- {
- if let Ok(snapshot) = BackupDir::new(backup_type, backup_id, backup_time) {
- result.push(snapshot.relative_path().to_str().unwrap().to_owned());
- }
- }
- }
- }
-
- result
-}
-
-fn complete_server_file_name(_arg: &str, param: &HashMap<String, String>) -> Vec<String> {
- proxmox_backup::tools::runtime::main(async { complete_server_file_name_do(param).await })
-}
-
-async fn complete_server_file_name_do(param: &HashMap<String, String>) -> Vec<String> {
-
- let mut result = vec![];
-
- let repo = match extract_repository_from_map(param) {
- Some(v) => v,
- _ => return result,
- };
-
- let snapshot: BackupDir = match param.get("snapshot") {
- Some(path) => {
- match path.parse() {
- Ok(v) => v,
- _ => return result,
- }
- }
- _ => return result,
- };
-
- let query = tools::json_object_to_query(json!({
- "backup-type": snapshot.group().backup_type(),
- "backup-id": snapshot.group().backup_id(),
- "backup-time": snapshot.backup_time(),
- })).unwrap();
-
- let path = format!("api2/json/admin/datastore/{}/files?{}", repo.store(), query);
-
- let data = try_get(&repo, &path).await;
-
- if let Some(list) = data.as_array() {
- for item in list {
- if let Some(filename) = item["filename"].as_str() {
- result.push(filename.to_owned());
- }
- }
- }
-
- result
-}
-
-fn complete_archive_name(arg: &str, param: &HashMap<String, String>) -> Vec<String> {
- complete_server_file_name(arg, param)
- .iter()
- .map(|v| tools::format::strip_server_file_extension(&v))
- .collect()
-}
-
-pub fn complete_pxar_archive_name(arg: &str, param: &HashMap<String, String>) -> Vec<String> {
- complete_server_file_name(arg, param)
- .iter()
- .filter_map(|name| {
- if name.ends_with(".pxar.didx") {
- Some(tools::format::strip_server_file_extension(name))
- } else {
- None
- }
- })
- .collect()
-}
-
-pub fn complete_img_archive_name(arg: &str, param: &HashMap<String, String>) -> Vec<String> {
- complete_server_file_name(arg, param)
- .iter()
- .filter_map(|name| {
- if name.ends_with(".img.fidx") {
- Some(tools::format::strip_server_file_extension(name))
- } else {
- None
- }
- })
- .collect()
-}
-
-fn complete_chunk_size(_arg: &str, _param: &HashMap<String, String>) -> Vec<String> {
-
- let mut result = vec![];
-
- let mut size = 64;
- loop {
- result.push(size.to_string());
- size *= 2;
- if size > 4096 { break; }
- }
-
- result
-}
-
use proxmox_backup::client::RemoteChunkReader;
/// This is a workaround until we have cleaned up the chunk/reader/... infrastructure for better
/// async use!
.completion_cb("repository", complete_repository)
.completion_cb("backupspec", complete_backup_source)
.completion_cb("keyfile", tools::complete_file_name)
+ .completion_cb("master-pubkey-file", tools::complete_file_name)
.completion_cb("chunk-size", complete_chunk_size);
let benchmark_cmd_def = CliCommand::new(&API_METHOD_BENCHMARK)
.completion_cb("repository", complete_repository)
.completion_cb("keyfile", tools::complete_file_name);
- let upload_log_cmd_def = CliCommand::new(&API_METHOD_UPLOAD_LOG)
- .arg_param(&["snapshot", "logfile"])
- .completion_cb("snapshot", complete_backup_snapshot)
- .completion_cb("logfile", tools::complete_file_name)
- .completion_cb("keyfile", tools::complete_file_name)
- .completion_cb("repository", complete_repository);
-
let list_cmd_def = CliCommand::new(&API_METHOD_LIST_BACKUP_GROUPS)
.completion_cb("repository", complete_repository);
- let snapshots_cmd_def = CliCommand::new(&API_METHOD_LIST_SNAPSHOTS)
- .arg_param(&["group"])
- .completion_cb("group", complete_backup_group)
- .completion_cb("repository", complete_repository);
-
- let forget_cmd_def = CliCommand::new(&API_METHOD_FORGET_SNAPSHOTS)
- .arg_param(&["snapshot"])
- .completion_cb("repository", complete_repository)
- .completion_cb("snapshot", complete_backup_snapshot);
-
let garbage_collect_cmd_def = CliCommand::new(&API_METHOD_START_GARBAGE_COLLECTION)
.completion_cb("repository", complete_repository);
.completion_cb("archive-name", complete_archive_name)
.completion_cb("target", tools::complete_file_name);
- let files_cmd_def = CliCommand::new(&API_METHOD_LIST_SNAPSHOT_FILES)
- .arg_param(&["snapshot"])
- .completion_cb("repository", complete_repository)
- .completion_cb("snapshot", complete_backup_snapshot);
-
let prune_cmd_def = CliCommand::new(&API_METHOD_PRUNE)
.arg_param(&["group"])
.completion_cb("group", complete_backup_group)
let version_cmd_def = CliCommand::new(&API_METHOD_API_VERSION)
.completion_cb("repository", complete_repository);
+ let change_owner_cmd_def = CliCommand::new(&API_METHOD_CHANGE_BACKUP_OWNER)
+ .arg_param(&["group", "new-owner"])
+ .completion_cb("group", complete_backup_group)
+ .completion_cb("new-owner", complete_auth_id)
+ .completion_cb("repository", complete_repository);
+
let cmd_def = CliCommandMap::new()
.insert("backup", backup_cmd_def)
- .insert("upload-log", upload_log_cmd_def)
- .insert("forget", forget_cmd_def)
.insert("garbage-collect", garbage_collect_cmd_def)
.insert("list", list_cmd_def)
.insert("login", login_cmd_def)
.insert("logout", logout_cmd_def)
.insert("prune", prune_cmd_def)
.insert("restore", restore_cmd_def)
- .insert("snapshots", snapshots_cmd_def)
- .insert("files", files_cmd_def)
+ .insert("snapshot", snapshot_mgtm_cli())
.insert("status", status_cmd_def)
.insert("key", key::cli())
.insert("mount", mount_cmd_def())
.insert("catalog", catalog_mgmt_cli())
.insert("task", task_mgmt_cli())
.insert("version", version_cmd_def)
- .insert("benchmark", benchmark_cmd_def);
+ .insert("benchmark", benchmark_cmd_def)
+ .insert("change-owner", change_owner_cmd_def)
+
+ .alias(&["files"], &["snapshot", "files"])
+ .alias(&["forget"], &["snapshot", "forget"])
+ .alias(&["upload-log"], &["snapshot", "upload-log"])
+ .alias(&["snapshots"], &["snapshot", "list"])
+ ;
let rpcenv = CliEnvironment::new();
run_cli_command(cmd_def, rpcenv, Some(|future| {
- proxmox_backup::tools::runtime::main(future)
+ pbs_runtime::main(future)
}));
}