tyler/proxmox-backup
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

make datastore BackupGroup/Dir ctors private

Browse Source 
And use the api-types for their contents.

These are supposed to be instances for a datastore, the pure
specifications are the ones in pbs_api_types which should be
preferred in crates like clients which do not need to deal
with the datastore directly.

Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com>
This commit is contained in:
Wolfgang Bumiller
2022-04-19 10:38:46 +02:00
parent 38aa71fcc8
commit db87d93efc
24 changed files with 440 additions and 408 deletions
Download Patch File Download Diff File Expand all files Collapse all files

125
src/api2/admin/datastore.rs
View File

@ -63,16 +63,16 @@ use crate::server::jobstate::Job;
const GROUP_NOTES_FILE_NAME: &str = "notes";
fn get_group_note_path(store: &DataStore, group: &BackupGroup) -> PathBuf {
fn get_group_note_path(store: &DataStore, group: &pbs_api_types::BackupGroup) -> PathBuf {
let mut note_path = store.base_path();
note_path.push(group.relative_group_path());
note_path.push(group.to_string());
note_path.push(GROUP_NOTES_FILE_NAME);
note_path
}
fn check_priv_or_backup_owner(
store: &DataStore,
group: &BackupGroup,
group: &pbs_api_types::BackupGroup,
auth_id: &Authid,
required_privs: u64,
) -> Result<(), Error> {
@ -170,7 +170,7 @@ pub fn list_groups(
.iter_backup_groups()?
.try_fold(Vec::new(), |mut group_info, group| {
let group = group?;
let owner = match datastore.get_owner(&group) {
let owner = match datastore.get_owner(group.as_ref()) {
Ok(auth_id) => auth_id,
Err(err) => {
let id = &store;
@ -203,7 +203,7 @@ pub fn list_groups(
})
.to_owned();
let note_path = get_group_note_path(&datastore, &group);
let note_path = get_group_note_path(&datastore, group.as_ref());
let comment = file_read_firstline(&note_path).ok();
group_info.push(GroupListItem {
@ -244,7 +244,7 @@ pub fn delete_group(
) -> Result<Value, Error> {
let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
let group = BackupGroup::new(backup_type, backup_id);
let group = pbs_api_types::BackupGroup::from((backup_type, backup_id));
let datastore = DataStore::lookup_datastore(&store, Some(Operation::Write))?;
check_priv_or_backup_owner(&datastore, &group, &auth_id, PRIV_DATASTORE_MODIFY)?;
@ -285,11 +285,11 @@ pub fn list_snapshot_files(
let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
let datastore = DataStore::lookup_datastore(&store, Some(Operation::Read))?;
let snapshot = BackupDir::new(backup_type, backup_id, backup_time)?;
let snapshot = datastore.backup_dir_from_spec((backup_type, backup_id, backup_time).into())?;
check_priv_or_backup_owner(
&datastore,
snapshot.group(),
snapshot.as_ref(),
&auth_id,
PRIV_DATASTORE_AUDIT | PRIV_DATASTORE_READ,
)?;
@ -328,17 +328,17 @@ pub fn delete_snapshot(
) -> Result<Value, Error> {
let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
let snapshot = BackupDir::new(backup_type, backup_id, backup_time)?;
let datastore = DataStore::lookup_datastore(&store, Some(Operation::Write))?;
let snapshot = datastore.backup_dir_from_spec((backup_type, backup_id, backup_time).into())?;
check_priv_or_backup_owner(
&datastore,
snapshot.group(),
snapshot.as_ref(),
&auth_id,
PRIV_DATASTORE_MODIFY,
)?;
datastore.remove_backup_dir(&snapshot, false)?;
datastore.remove_backup_dir(snapshot.as_ref(), false)?;
Ok(Value::Null)
}
@ -386,7 +386,9 @@ pub fn list_snapshots(
// FIXME: filter also owner before collecting, for doing that nicely the owner should move into
// backup group and provide an error free (Err -> None) accessor
let groups = match (backup_type, backup_id) {
(Some(backup_type), Some(backup_id)) => vec![BackupGroup::new(backup_type, backup_id)],
(Some(backup_type), Some(backup_id)) => {
vec![datastore.backup_group(backup_type, backup_id)]
}
(Some(backup_type), None) => datastore
.iter_backup_groups_ok()?
.filter(|group| group.backup_type() == backup_type)
@ -471,7 +473,7 @@ pub fn list_snapshots(
};
groups.iter().try_fold(Vec::new(), |mut snapshots, group| {
let owner = match datastore.get_owner(group) {
let owner = match datastore.get_owner(group.as_ref()) {
Ok(auth_id) => auth_id,
Err(err) => {
eprintln!(
@ -502,7 +504,7 @@ fn get_snapshots_count(store: &DataStore, filter_owner: Option<&Authid>) -> Resu
store
.iter_backup_groups_ok()?
.filter(|group| {
let owner = match store.get_owner(group) {
let owner = match store.get_owner(group.as_ref()) {
Ok(owner) => owner,
Err(err) => {
let id = store.name();
@ -658,20 +660,20 @@ pub fn verify(
"{}:{}/{}/{:08X}",
store, backup_type, backup_id, backup_time
);
let dir = BackupDir::new(backup_type, backup_id, backup_time)?;
let dir = datastore.backup_dir_from_parts(backup_type, backup_id, backup_time)?;
check_priv_or_backup_owner(&datastore, dir.group(), &auth_id, PRIV_DATASTORE_VERIFY)?;
check_priv_or_backup_owner(&datastore, dir.as_ref(), &auth_id, PRIV_DATASTORE_VERIFY)?;
backup_dir = Some(dir);
worker_type = "verify_snapshot";
}
(Some(backup_type), Some(backup_id), None) => {
worker_id = format!("{}:{}/{}", store, backup_type, backup_id);
let group = BackupGroup::new(backup_type, backup_id);
let group = pbs_api_types::BackupGroup::from((backup_type, backup_id));
check_priv_or_backup_owner(&datastore, &group, &auth_id, PRIV_DATASTORE_VERIFY)?;
backup_group = Some(group);
backup_group = Some(datastore.backup_group_from_spec(group));
worker_type = "verify_group";
}
(None, None, None) => {
@ -776,11 +778,11 @@ pub fn prune(
) -> Result<Value, Error> {
let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
let group = BackupGroup::new(backup_type, &backup_id);
let datastore = DataStore::lookup_datastore(&store, Some(Operation::Write))?;
check_priv_or_backup_owner(&datastore, &group, &auth_id, PRIV_DATASTORE_MODIFY)?;
let group = datastore.backup_group(backup_type, &backup_id);
check_priv_or_backup_owner(&datastore, group.as_ref(), &auth_id, PRIV_DATASTORE_MODIFY)?;
let worker_id = format!("{}:{}/{}", store, backup_type, &backup_id);
@ -798,13 +800,10 @@ pub fn prune(
for (info, mark) in prune_info {
let keep = keep_all || mark.keep();
let backup_time = info.backup_dir.backup_time();
let group = info.backup_dir.group();
prune_result.push(json!({
"backup-type": group.backup_type(),
"backup-id": group.backup_id(),
"backup-time": backup_time,
"backup-type": info.backup_dir.backup_type(),
"backup-id": info.backup_dir.backup_id(),
"backup-time": info.backup_dir.backup_time(),
"keep": keep,
"protected": mark.protected(),
}));
@ -837,28 +836,22 @@ pub fn prune(
let backup_time = info.backup_dir.backup_time();
let timestamp = info.backup_dir.backup_time_string();
let group = info.backup_dir.group();
let group: &pbs_api_types::BackupGroup = info.backup_dir.as_ref();
let msg = format!(
"{}/{}/{} {}",
group.backup_type(),
group.backup_id(),
timestamp,
mark,
);
let msg = format!("{}/{}/{} {}", group.ty, group.id, timestamp, mark,);
task_log!(worker, "{}", msg);
prune_result.push(json!({
"backup-type": group.backup_type(),
"backup-id": group.backup_id(),
"backup-type": group.ty,
"backup-id": group.id,
"backup-time": backup_time,
"keep": keep,
"protected": mark.protected(),
}));
if !(dry_run || keep) {
if let Err(err) = datastore.remove_backup_dir(&info.backup_dir, false) {
if let Err(err) = datastore.remove_backup_dir(info.backup_dir.as_ref(), false) {
task_warn!(
worker,
"failed to remove dir {:?}: {}",
@ -1079,14 +1072,14 @@ pub fn download_file(
let file_name = required_string_param(&param, "file-name")?.to_owned();
let backup_type: BackupType = required_string_param(&param, "backup-type")?.parse()?;
let backup_id = required_string_param(&param, "backup-id")?;
let backup_id = required_string_param(&param, "backup-id")?.to_owned();
let backup_time = required_integer_param(&param, "backup-time")?;
let backup_dir = BackupDir::new(backup_type, backup_id, backup_time)?;
let backup_dir = datastore.backup_dir_from_parts(backup_type, backup_id, backup_time)?;
check_priv_or_backup_owner(
&datastore,
backup_dir.group(),
backup_dir.as_ref(),
&auth_id,
PRIV_DATASTORE_READ,
)?;
@ -1162,14 +1155,14 @@ pub fn download_file_decoded(
let file_name = required_string_param(&param, "file-name")?.to_owned();
let backup_type: BackupType = required_string_param(&param, "backup-type")?.parse()?;
let backup_id = required_string_param(&param, "backup-id")?;
let backup_id = required_string_param(&param, "backup-id")?.to_owned();
let backup_time = required_integer_param(&param, "backup-time")?;
let backup_dir = BackupDir::new(backup_type, backup_id, backup_time)?;
let backup_dir = datastore.backup_dir_from_parts(backup_type, backup_id, backup_time)?;
check_priv_or_backup_owner(
&datastore,
backup_dir.group(),
backup_dir.as_ref(),
&auth_id,
PRIV_DATASTORE_READ,
)?;
@ -1291,10 +1284,10 @@ pub fn upload_backup_log(
let backup_id = required_string_param(&param, "backup-id")?;
let backup_time = required_integer_param(&param, "backup-time")?;
let backup_dir = BackupDir::new(backup_type, backup_id, backup_time)?;
let backup_dir = datastore.backup_dir_from_parts(backup_type, backup_id, backup_time)?;
let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
let owner = datastore.get_owner(backup_dir.group())?;
let owner = datastore.get_owner(backup_dir.as_ref())?;
check_backup_owner(&owner, &auth_id)?;
let mut path = datastore.base_path();
@ -1363,11 +1356,12 @@ pub fn catalog(
let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
let backup_dir = BackupDir::new(backup_type, backup_id, backup_time)?;
let backup_dir =
datastore.backup_dir_from_spec((backup_type, backup_id, backup_time).into())?;
check_priv_or_backup_owner(
&datastore,
backup_dir.group(),
backup_dir.as_ref(),
&auth_id,
PRIV_DATASTORE_READ,
)?;
@ -1446,11 +1440,12 @@ pub fn pxar_file_download(
let tar = param["tar"].as_bool().unwrap_or(false);
let backup_dir = BackupDir::new(backup_type, backup_id, backup_time)?;
let backup_dir = datastore
.backup_dir_from_spec((backup_type, backup_id.to_owned(), backup_time).into())?;
check_priv_or_backup_owner(
&datastore,
backup_dir.group(),
backup_dir.as_ref(),
&auth_id,
PRIV_DATASTORE_READ,
)?;
@ -1637,7 +1632,7 @@ pub fn get_group_notes(
let datastore = DataStore::lookup_datastore(&store, Some(Operation::Read))?;
let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
let backup_group = BackupGroup::new(backup_type, backup_id);
let backup_group = pbs_api_types::BackupGroup::from((backup_type, backup_id));
check_priv_or_backup_owner(&datastore, &backup_group, &auth_id, PRIV_DATASTORE_AUDIT)?;
@ -1673,7 +1668,7 @@ pub fn set_group_notes(
let datastore = DataStore::lookup_datastore(&store, Some(Operation::Write))?;
let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
let backup_group = BackupGroup::new(backup_type, backup_id);
let backup_group = pbs_api_types::BackupGroup::from((backup_type, backup_id));
check_priv_or_backup_owner(&datastore, &backup_group, &auth_id, PRIV_DATASTORE_MODIFY)?;
@ -1707,11 +1702,12 @@ pub fn get_notes(
let datastore = DataStore::lookup_datastore(&store, Some(Operation::Read))?;
let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
let backup_dir = BackupDir::new(backup_type, backup_id, backup_time)?;
let backup_dir =
datastore.backup_dir_from_spec((backup_type, backup_id, backup_time).into())?;
check_priv_or_backup_owner(
&datastore,
backup_dir.group(),
backup_dir.as_ref(),
&auth_id,
PRIV_DATASTORE_AUDIT,
)?;
@ -1753,11 +1749,12 @@ pub fn set_notes(
let datastore = DataStore::lookup_datastore(&store, Some(Operation::Write))?;
let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
let backup_dir = BackupDir::new(backup_type, backup_id, backup_time)?;
let backup_dir =
datastore.backup_dir_from_spec((backup_type, backup_id, backup_time).into())?;
check_priv_or_backup_owner(
&datastore,
backup_dir.group(),
backup_dir.as_ref(),
&auth_id,
PRIV_DATASTORE_MODIFY,
)?;
@ -1795,11 +1792,12 @@ pub fn get_protection(
let datastore = DataStore::lookup_datastore(&store, Some(Operation::Read))?;
let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
let backup_dir = BackupDir::new(backup_type, backup_id, backup_time)?;
let backup_dir =
datastore.backup_dir_from_spec((backup_type, backup_id, backup_time).into())?;
check_priv_or_backup_owner(
&datastore,
backup_dir.group(),
backup_dir.as_ref(),
&auth_id,
PRIV_DATASTORE_AUDIT,
)?;
@ -1837,11 +1835,12 @@ pub fn set_protection(
let datastore = DataStore::lookup_datastore(&store, Some(Operation::Write))?;
let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
let backup_dir = BackupDir::new(backup_type, backup_id, backup_time)?;
let backup_dir =
datastore.backup_dir_from_spec((backup_type, backup_id, backup_time).into())?;
check_priv_or_backup_owner(
&datastore,
backup_dir.group(),
backup_dir.as_ref(),
&auth_id,
PRIV_DATASTORE_MODIFY,
)?;
@ -1875,7 +1874,7 @@ pub fn set_backup_owner(
) -> Result<(), Error> {
let datastore = DataStore::lookup_datastore(&store, Some(Operation::Write))?;
let backup_group = BackupGroup::new(backup_type, backup_id);
let backup_group = datastore.backup_group(backup_type, backup_id);
let auth_id: Authid = rpcenv.get_auth_id().unwrap().parse()?;
@ -1887,7 +1886,7 @@ pub fn set_backup_owner(
// High-privilege user/token
true
} else if (privs & PRIV_DATASTORE_BACKUP) != 0 {
let owner = datastore.get_owner(&backup_group)?;
let owner = datastore.get_owner(backup_group.as_ref())?;
match (owner.is_token(), new_owner.is_token()) {
(true, true) => {
@ -1935,7 +1934,7 @@ pub fn set_backup_owner(
);
}
datastore.set_owner(&backup_group, &new_owner, true)?;
datastore.set_owner(backup_group.as_ref(), &new_owner, true)?;
Ok(())
}

9
src/api2/backup/environment.rs
View File

@ -614,7 +614,7 @@ impl BackupEnvironment {
.map_err(|err| format_err!("unable to update manifest blob - {}", err))?;
if let Some(base) = &self.last_backup {
let path = self.datastore.snapshot_path(&base.backup_dir);
let path = self.datastore.snapshot_path(base.backup_dir.as_ref());
if !path.exists() {
bail!(
"base snapshot {} was removed during backup, cannot finish as chunks might be missing",
@ -643,8 +643,8 @@ impl BackupEnvironment {
let worker_id = format!(
"{}:{}/{}/{:08X}",
self.datastore.name(),
self.backup_dir.group().backup_type(),
self.backup_dir.group().backup_id(),
self.backup_dir.backup_type(),
self.backup_dir.backup_id(),
self.backup_dir.backup_time()
);
@ -710,7 +710,8 @@ impl BackupEnvironment {
let mut state = self.state.lock().unwrap();
state.finished = true;
self.datastore.remove_backup_dir(&self.backup_dir, true)?;
self.datastore
.remove_backup_dir(self.backup_dir.as_ref(), true)?;
Ok(())
}

13
src/api2/backup/mod.rs
View File

@ -21,7 +21,6 @@ use pbs_api_types::{
DATASTORE_SCHEMA, PRIV_DATASTORE_BACKUP,
};
use pbs_config::CachedUserInfo;
use pbs_datastore::backup_info::{BackupDir, BackupGroup};
use pbs_datastore::index::IndexFile;
use pbs_datastore::manifest::{archive_type, ArchiveType};
use pbs_datastore::{DataStore, PROXMOX_BACKUP_PROTOCOL_ID_V1};
@ -107,7 +106,7 @@ fn upgrade_to_backup_protocol(
let env_type = rpcenv.env_type();
let backup_group = BackupGroup::new(backup_type, backup_id);
let backup_group = datastore.backup_group(backup_type, backup_id);
let worker_type = if backup_type == BackupType::Host && backup_id == "benchmark" {
if !benchmark {
@ -123,7 +122,7 @@ fn upgrade_to_backup_protocol(
// lock backup group to only allow one backup per group at a time
let (owner, _group_guard) =
datastore.create_locked_backup_group(&backup_group, &auth_id)?;
datastore.create_locked_backup_group(backup_group.as_ref(), &auth_id)?;
// permission check
let correct_owner =
@ -155,7 +154,7 @@ fn upgrade_to_backup_protocol(
}
};
let backup_dir = BackupDir::with_group(backup_group, backup_time)?;
let backup_dir = backup_group.backup_dir(backup_time)?;
let _last_guard = if let Some(last) = &last_backup {
if backup_dir.backup_time() <= last.backup_dir.backup_time() {
@ -163,7 +162,7 @@ fn upgrade_to_backup_protocol(
}
// lock last snapshot to prevent forgetting/pruning it during backup
let full_path = datastore.snapshot_path(&last.backup_dir);
let full_path = datastore.snapshot_path(last.backup_dir.as_ref());
Some(lock_dir_noblock_shared(
&full_path,
"snapshot",
@ -173,7 +172,7 @@ fn upgrade_to_backup_protocol(
None
};
let (path, is_new, snap_guard) = datastore.create_locked_backup_dir(&backup_dir)?;
let (path, is_new, snap_guard) = datastore.create_locked_backup_dir(backup_dir.as_ref())?;
if !is_new {
bail!("backup directory already exists.");
}
@ -812,7 +811,7 @@ fn download_previous(
None => bail!("no valid previous backup"),
};
let mut path = env.datastore.snapshot_path(&last_backup.backup_dir);
let mut path = env.datastore.snapshot_path(last_backup.backup_dir.as_ref());
path.push(&archive_name);
{

7
src/api2/reader/mod.rs
View File

@ -21,7 +21,6 @@ use pbs_api_types::{
PRIV_DATASTORE_BACKUP, PRIV_DATASTORE_READ,
};
use pbs_config::CachedUserInfo;
use pbs_datastore::backup_info::BackupDir;
use pbs_datastore::index::IndexFile;
use pbs_datastore::manifest::{archive_type, ArchiveType};
use pbs_datastore::{DataStore, PROXMOX_BACKUP_READER_PROTOCOL_ID_V1};
@ -113,9 +112,9 @@ fn upgrade_to_backup_reader_protocol(
let env_type = rpcenv.env_type();
let backup_dir = BackupDir::new(backup_type, backup_id, backup_time)?;
let backup_dir = datastore.backup_dir_from_parts(backup_type, backup_id, backup_time)?;
if !priv_read {
let owner = datastore.get_owner(backup_dir.group())?;
let owner = datastore.get_owner(backup_dir.as_ref())?;
let correct_owner = owner == auth_id
|| (owner.is_token() && Authid::from(owner.user().clone()) == auth_id);
if !correct_owner {
@ -124,7 +123,7 @@ fn upgrade_to_backup_reader_protocol(
}
let _guard = lock_dir_noblock_shared(
&datastore.snapshot_path(&backup_dir),
&backup_dir.full_path(datastore.base_path()),
"snapshot",
"locked by another operation",
)?;

2
src/api2/tape/backup.rs
View File

@ -576,7 +576,7 @@ pub fn backup_snapshot(
) -> Result<bool, Error> {
task_log!(worker, "backup snapshot {}", snapshot);
let snapshot_reader = match SnapshotReader::new(datastore.clone(), snapshot.clone()) {
let snapshot_reader = match SnapshotReader::new(datastore.clone(), (&snapshot).into()) {
Ok(reader) => reader,
Err(err) => {
// ignore missing snapshots and continue

9
src/api2/tape/media.rs
View File

@ -13,7 +13,6 @@ use pbs_api_types::{
MEDIA_POOL_NAME_SCHEMA, MEDIA_UUID_SCHEMA, PRIV_TAPE_AUDIT, VAULT_NAME_SCHEMA,
};
use pbs_config::CachedUserInfo;
use pbs_datastore::backup_info::BackupDir;
use crate::tape::{
changer::update_online_status, media_catalog_snapshot_list, Inventory, MediaCatalog, MediaPool,
@ -439,15 +438,15 @@ pub fn list_content(
.unwrap_or_else(|_| set.uuid.to_string());
for (store, snapshot) in media_catalog_snapshot_list(status_path, &media_id)? {
let backup_dir: BackupDir = snapshot.parse()?;
let backup_dir: pbs_api_types::BackupDir = snapshot.parse()?;
if let Some(backup_type) = filter.backup_type {
if backup_dir.group().backup_type() != backup_type {
if backup_dir.ty() != backup_type {
continue;
}
}
if let Some(ref backup_id) = filter.backup_id {
if backup_dir.group().backup_id() != backup_id {
if backup_dir.id() != backup_id {
continue;
}
}
@ -462,7 +461,7 @@ pub fn list_content(
seq_nr: set.seq_nr,
snapshot: snapshot.to_owned(),
store: store.to_owned(),
backup_time: backup_dir.backup_time(),
backup_time: backup_dir.time,
});
}
}

13
src/api2/tape/restore.rs
View File

@ -22,7 +22,6 @@ use pbs_api_types::{
TAPE_RESTORE_SNAPSHOT_SCHEMA, UPID_SCHEMA,
};
use pbs_config::CachedUserInfo;
use pbs_datastore::backup_info::BackupDir;
use pbs_datastore::dynamic_index::DynamicIndexReader;
use pbs_datastore::fixed_index::FixedIndexReader;
use pbs_datastore::index::IndexFile;
@ -423,7 +422,7 @@ fn restore_list_worker(
let snapshot = split
.next()
.ok_or_else(|| format_err!("invalid snapshot:{}", store_snapshot))?;
let backup_dir: BackupDir = snapshot.parse()?;
let backup_dir: pbs_api_types::BackupDir = snapshot.parse()?;
let datastore = store_map.get_datastore(source_datastore).ok_or_else(|| {
format_err!(
@ -433,7 +432,7 @@ fn restore_list_worker(
})?;
let (owner, _group_lock) =
datastore.create_locked_backup_group(backup_dir.group(), restore_owner)?;
datastore.create_locked_backup_group(backup_dir.as_ref(), restore_owner)?;
if restore_owner != &owner {
// only the owner is allowed to create additional snapshots
bail!(
@ -577,7 +576,7 @@ fn restore_list_worker(
let snapshot = split
.next()
.ok_or_else(|| format_err!("invalid snapshot:{}", store_snapshot))?;
let backup_dir: BackupDir = snapshot.parse()?;
let backup_dir: pbs_api_types::BackupDir = snapshot.parse()?;
let datastore = store_map.get_datastore(source_datastore).ok_or_else(|| {
format_err!("unexpected source datastore: {}", source_datastore)
@ -1037,12 +1036,12 @@ fn restore_archive<'a>(
snapshot
);
let backup_dir: BackupDir = snapshot.parse()?;
let backup_dir: pbs_api_types::BackupDir = snapshot.parse()?;
if let Some((store_map, authid)) = target.as_ref() {
if let Some(datastore) = store_map.get_datastore(&datastore_name) {
let (owner, _group_lock) =
datastore.create_locked_backup_group(backup_dir.group(), authid)?;
datastore.create_locked_backup_group(backup_dir.as_ref(), authid)?;
if *authid != &owner {
// only the owner is allowed to create additional snapshots
bail!(
@ -1054,7 +1053,7 @@ fn restore_archive<'a>(
}
let (rel_path, is_new, _snap_lock) =
datastore.create_locked_backup_dir(&backup_dir)?;
datastore.create_locked_backup_dir(backup_dir.as_ref())?;
let mut path = datastore.base_path();
path.push(rel_path);