2019-03-05 06:18:12 +00:00
|
|
|
use crate::tools;
|
|
|
|
|
2020-04-17 12:11:25 +00:00
|
|
|
use anyhow::{bail, format_err, Error};
|
2019-05-11 08:19:34 +00:00
|
|
|
use std::os::unix::io::RawFd;
|
2019-03-05 06:18:12 +00:00
|
|
|
|
2021-03-14 18:18:35 +00:00
|
|
|
use std::path::{Path, PathBuf};
|
2020-11-03 05:36:50 +00:00
|
|
|
|
|
|
|
use proxmox::const_regex;
|
2019-03-05 06:18:12 +00:00
|
|
|
|
2020-01-06 10:35:22 +00:00
|
|
|
use super::manifest::MANIFEST_BLOB_NAME;
|
|
|
|
|
2021-03-14 18:18:35 +00:00
|
|
|
macro_rules! BACKUP_ID_RE {
|
|
|
|
() => {
|
|
|
|
r"[A-Za-z0-9_][A-Za-z0-9._\-]*"
|
|
|
|
};
|
|
|
|
}
|
|
|
|
macro_rules! BACKUP_TYPE_RE {
|
|
|
|
() => {
|
|
|
|
r"(?:host|vm|ct)"
|
|
|
|
};
|
|
|
|
}
|
|
|
|
macro_rules! BACKUP_TIME_RE {
|
|
|
|
() => {
|
|
|
|
r"[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z"
|
|
|
|
};
|
|
|
|
}
|
2019-03-05 06:18:12 +00:00
|
|
|
|
2021-03-14 18:18:35 +00:00
|
|
|
const_regex! {
|
2020-11-03 05:36:50 +00:00
|
|
|
BACKUP_FILE_REGEX = r"^.*\.([fd]idx|blob)$";
|
2019-03-05 06:18:12 +00:00
|
|
|
|
2020-11-03 05:36:50 +00:00
|
|
|
BACKUP_TYPE_REGEX = concat!(r"^(", BACKUP_TYPE_RE!(), r")$");
|
2019-03-05 06:18:12 +00:00
|
|
|
|
2020-11-03 05:36:50 +00:00
|
|
|
pub BACKUP_ID_REGEX = concat!(r"^", BACKUP_ID_RE!(), r"$");
|
2019-03-05 06:18:12 +00:00
|
|
|
|
2020-11-03 05:36:50 +00:00
|
|
|
BACKUP_DATE_REGEX = concat!(r"^", BACKUP_TIME_RE!() ,r"$");
|
2019-03-05 06:18:12 +00:00
|
|
|
|
2020-11-03 05:36:50 +00:00
|
|
|
GROUP_PATH_REGEX = concat!(r"^(", BACKUP_TYPE_RE!(), ")/(", BACKUP_ID_RE!(), r")$");
|
2019-03-05 06:18:12 +00:00
|
|
|
|
2020-11-03 05:36:50 +00:00
|
|
|
SNAPSHOT_PATH_REGEX = concat!(
|
|
|
|
r"^(", BACKUP_TYPE_RE!(), ")/(", BACKUP_ID_RE!(), ")/(", BACKUP_TIME_RE!(), r")$");
|
2019-03-05 06:18:12 +00:00
|
|
|
}
|
|
|
|
|
2019-03-05 06:28:13 +00:00
|
|
|
/// BackupGroup is a directory containing a list of BackupDir
|
2020-01-17 09:39:32 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Hash, Clone)]
|
2019-03-05 06:18:12 +00:00
|
|
|
pub struct BackupGroup {
|
|
|
|
/// Type of backup
|
|
|
|
backup_type: String,
|
|
|
|
/// Unique (for this type) ID
|
|
|
|
backup_id: String,
|
|
|
|
}
|
|
|
|
|
2020-08-25 06:38:47 +00:00
|
|
|
impl std::cmp::Ord for BackupGroup {
|
|
|
|
fn cmp(&self, other: &Self) -> std::cmp::Ordering {
|
|
|
|
let type_order = self.backup_type.cmp(&other.backup_type);
|
|
|
|
if type_order != std::cmp::Ordering::Equal {
|
|
|
|
return type_order;
|
|
|
|
}
|
|
|
|
// try to compare IDs numerically
|
|
|
|
let id_self = self.backup_id.parse::<u64>();
|
|
|
|
let id_other = other.backup_id.parse::<u64>();
|
|
|
|
match (id_self, id_other) {
|
|
|
|
(Ok(id_self), Ok(id_other)) => id_self.cmp(&id_other),
|
|
|
|
(Ok(_), Err(_)) => std::cmp::Ordering::Less,
|
|
|
|
(Err(_), Ok(_)) => std::cmp::Ordering::Greater,
|
2021-03-14 18:18:35 +00:00
|
|
|
_ => self.backup_id.cmp(&other.backup_id),
|
2020-08-25 06:38:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl std::cmp::PartialOrd for BackupGroup {
|
|
|
|
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
|
|
|
|
Some(self.cmp(other))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-05 06:18:12 +00:00
|
|
|
impl BackupGroup {
|
2019-03-05 08:13:07 +00:00
|
|
|
pub fn new<T: Into<String>, U: Into<String>>(backup_type: T, backup_id: U) -> Self {
|
2021-03-14 18:18:35 +00:00
|
|
|
Self {
|
|
|
|
backup_type: backup_type.into(),
|
|
|
|
backup_id: backup_id.into(),
|
|
|
|
}
|
2019-03-05 06:18:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn backup_type(&self) -> &str {
|
|
|
|
&self.backup_type
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn backup_id(&self) -> &str {
|
|
|
|
&self.backup_id
|
|
|
|
}
|
|
|
|
|
2021-03-14 18:18:35 +00:00
|
|
|
pub fn group_path(&self) -> PathBuf {
|
2019-03-05 06:18:12 +00:00
|
|
|
let mut relative_path = PathBuf::new();
|
|
|
|
|
|
|
|
relative_path.push(&self.backup_type);
|
|
|
|
|
|
|
|
relative_path.push(&self.backup_id);
|
|
|
|
|
|
|
|
relative_path
|
|
|
|
}
|
2019-05-11 08:19:34 +00:00
|
|
|
|
|
|
|
pub fn list_backups(&self, base_path: &Path) -> Result<Vec<BackupInfo>, Error> {
|
|
|
|
let mut list = vec![];
|
|
|
|
|
|
|
|
let mut path = base_path.to_owned();
|
|
|
|
path.push(self.group_path());
|
|
|
|
|
2021-03-14 18:18:35 +00:00
|
|
|
tools::scandir(
|
|
|
|
libc::AT_FDCWD,
|
|
|
|
&path,
|
|
|
|
&BACKUP_DATE_REGEX,
|
|
|
|
|l2_fd, backup_time, file_type| {
|
|
|
|
if file_type != nix::dir::Type::Directory {
|
|
|
|
return Ok(());
|
|
|
|
}
|
2019-05-11 08:19:34 +00:00
|
|
|
|
2021-03-14 18:18:35 +00:00
|
|
|
let backup_dir =
|
|
|
|
BackupDir::with_rfc3339(&self.backup_type, &self.backup_id, backup_time)?;
|
|
|
|
let files = list_backup_files(l2_fd, backup_time)?;
|
2019-05-11 08:19:34 +00:00
|
|
|
|
2021-03-14 18:18:35 +00:00
|
|
|
list.push(BackupInfo { backup_dir, files });
|
2019-05-11 08:19:34 +00:00
|
|
|
|
2021-03-14 18:18:35 +00:00
|
|
|
Ok(())
|
|
|
|
},
|
|
|
|
)?;
|
2019-05-11 08:19:34 +00:00
|
|
|
Ok(list)
|
|
|
|
}
|
2019-12-04 14:49:11 +00:00
|
|
|
|
2021-03-14 18:18:35 +00:00
|
|
|
pub fn last_successful_backup(&self, base_path: &Path) -> Result<Option<i64>, Error> {
|
2020-01-06 10:35:22 +00:00
|
|
|
let mut last = None;
|
|
|
|
|
|
|
|
let mut path = base_path.to_owned();
|
|
|
|
path.push(self.group_path());
|
|
|
|
|
2021-03-14 18:18:35 +00:00
|
|
|
tools::scandir(
|
|
|
|
libc::AT_FDCWD,
|
|
|
|
&path,
|
|
|
|
&BACKUP_DATE_REGEX,
|
|
|
|
|l2_fd, backup_time, file_type| {
|
|
|
|
if file_type != nix::dir::Type::Directory {
|
|
|
|
return Ok(());
|
2020-01-06 10:35:22 +00:00
|
|
|
}
|
|
|
|
|
2021-03-14 18:18:35 +00:00
|
|
|
let mut manifest_path = PathBuf::from(backup_time);
|
|
|
|
manifest_path.push(MANIFEST_BLOB_NAME);
|
|
|
|
|
|
|
|
use nix::fcntl::{openat, OFlag};
|
|
|
|
match openat(
|
|
|
|
l2_fd,
|
|
|
|
&manifest_path,
|
|
|
|
OFlag::O_RDONLY,
|
|
|
|
nix::sys::stat::Mode::empty(),
|
|
|
|
) {
|
|
|
|
Ok(rawfd) => {
|
|
|
|
/* manifest exists --> assume backup was successful */
|
|
|
|
/* close else this leaks! */
|
|
|
|
nix::unistd::close(rawfd)?;
|
|
|
|
}
|
|
|
|
Err(nix::Error::Sys(nix::errno::Errno::ENOENT)) => {
|
|
|
|
return Ok(());
|
|
|
|
}
|
|
|
|
Err(err) => {
|
|
|
|
bail!("last_successful_backup: unexpected error - {}", err);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
let timestamp = proxmox::tools::time::parse_rfc3339(backup_time)?;
|
|
|
|
if let Some(last_timestamp) = last {
|
|
|
|
if timestamp > last_timestamp {
|
|
|
|
last = Some(timestamp);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
last = Some(timestamp);
|
|
|
|
}
|
2020-01-06 10:35:22 +00:00
|
|
|
|
2021-03-14 18:18:35 +00:00
|
|
|
Ok(())
|
|
|
|
},
|
|
|
|
)?;
|
2020-01-06 10:35:22 +00:00
|
|
|
|
|
|
|
Ok(last)
|
|
|
|
}
|
2019-03-05 06:18:12 +00:00
|
|
|
}
|
|
|
|
|
2020-06-24 10:25:45 +00:00
|
|
|
impl std::fmt::Display for BackupGroup {
|
|
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
|
|
let backup_type = self.backup_type();
|
|
|
|
let id = self.backup_id();
|
|
|
|
write!(f, "{}/{}", backup_type, id)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-23 06:16:56 +00:00
|
|
|
impl std::str::FromStr for BackupGroup {
|
|
|
|
type Err = Error;
|
|
|
|
|
|
|
|
/// Parse a backup group path
|
|
|
|
///
|
|
|
|
/// This parses strings like `vm/100".
|
|
|
|
fn from_str(path: &str) -> Result<Self, Self::Err> {
|
2021-03-14 18:18:35 +00:00
|
|
|
let cap = GROUP_PATH_REGEX
|
|
|
|
.captures(path)
|
2020-06-23 06:16:56 +00:00
|
|
|
.ok_or_else(|| format_err!("unable to parse backup group path '{}'", path))?;
|
|
|
|
|
|
|
|
Ok(Self {
|
|
|
|
backup_type: cap.get(1).unwrap().as_str().to_owned(),
|
|
|
|
backup_id: cap.get(2).unwrap().as_str().to_owned(),
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-05 06:18:12 +00:00
|
|
|
/// Uniquely identify a Backup (relative to data store)
|
2019-03-05 06:28:13 +00:00
|
|
|
///
|
|
|
|
/// We also call this a backup snaphost.
|
2020-08-11 08:50:40 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Clone)]
|
2019-03-05 06:18:12 +00:00
|
|
|
pub struct BackupDir {
|
|
|
|
/// Backup group
|
|
|
|
group: BackupGroup,
|
|
|
|
/// Backup timestamp
|
2020-09-12 13:10:47 +00:00
|
|
|
backup_time: i64,
|
|
|
|
// backup_time as rfc3339
|
2021-03-14 18:18:35 +00:00
|
|
|
backup_time_string: String,
|
2019-03-05 06:18:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl BackupDir {
|
2020-09-12 13:10:47 +00:00
|
|
|
pub fn new<T, U>(backup_type: T, backup_id: U, backup_time: i64) -> Result<Self, Error>
|
2019-03-05 08:16:54 +00:00
|
|
|
where
|
|
|
|
T: Into<String>,
|
|
|
|
U: Into<String>,
|
|
|
|
{
|
2020-09-11 12:34:38 +00:00
|
|
|
let group = BackupGroup::new(backup_type.into(), backup_id.into());
|
2020-09-15 07:40:03 +00:00
|
|
|
BackupDir::with_group(group, backup_time)
|
2019-03-05 06:18:12 +00:00
|
|
|
}
|
2020-09-11 12:34:38 +00:00
|
|
|
|
2021-03-14 18:18:35 +00:00
|
|
|
pub fn with_rfc3339<T, U, V>(
|
|
|
|
backup_type: T,
|
|
|
|
backup_id: U,
|
|
|
|
backup_time_string: V,
|
|
|
|
) -> Result<Self, Error>
|
2020-09-15 07:34:46 +00:00
|
|
|
where
|
|
|
|
T: Into<String>,
|
|
|
|
U: Into<String>,
|
|
|
|
V: Into<String>,
|
|
|
|
{
|
2021-03-14 18:18:35 +00:00
|
|
|
let backup_time_string = backup_time_string.into();
|
2020-09-15 07:34:46 +00:00
|
|
|
let backup_time = proxmox::tools::time::parse_rfc3339(&backup_time_string)?;
|
|
|
|
let group = BackupGroup::new(backup_type.into(), backup_id.into());
|
2021-03-14 18:18:35 +00:00
|
|
|
Ok(Self {
|
|
|
|
group,
|
|
|
|
backup_time,
|
|
|
|
backup_time_string,
|
|
|
|
})
|
2020-09-15 07:34:46 +00:00
|
|
|
}
|
|
|
|
|
2020-09-15 07:40:03 +00:00
|
|
|
pub fn with_group(group: BackupGroup, backup_time: i64) -> Result<Self, Error> {
|
2020-09-12 13:10:47 +00:00
|
|
|
let backup_time_string = Self::backup_time_to_string(backup_time)?;
|
2021-03-14 18:18:35 +00:00
|
|
|
Ok(Self {
|
|
|
|
group,
|
|
|
|
backup_time,
|
|
|
|
backup_time_string,
|
|
|
|
})
|
2019-05-11 10:07:09 +00:00
|
|
|
}
|
2019-03-05 06:18:12 +00:00
|
|
|
|
|
|
|
pub fn group(&self) -> &BackupGroup {
|
|
|
|
&self.group
|
|
|
|
}
|
|
|
|
|
2020-09-12 13:10:47 +00:00
|
|
|
pub fn backup_time(&self) -> i64 {
|
2019-03-05 06:18:12 +00:00
|
|
|
self.backup_time
|
|
|
|
}
|
|
|
|
|
2020-09-12 13:10:47 +00:00
|
|
|
pub fn backup_time_string(&self) -> &str {
|
|
|
|
&self.backup_time_string
|
|
|
|
}
|
|
|
|
|
2021-03-14 18:18:35 +00:00
|
|
|
pub fn relative_path(&self) -> PathBuf {
|
2019-03-05 06:18:12 +00:00
|
|
|
let mut relative_path = self.group.group_path();
|
|
|
|
|
2020-09-12 13:10:47 +00:00
|
|
|
relative_path.push(self.backup_time_string.clone());
|
2019-03-05 06:18:12 +00:00
|
|
|
|
|
|
|
relative_path
|
|
|
|
}
|
2019-07-22 08:12:51 +00:00
|
|
|
|
2020-09-12 13:10:47 +00:00
|
|
|
pub fn backup_time_to_string(backup_time: i64) -> Result<String, Error> {
|
|
|
|
// fixme: can this fail? (avoid unwrap)
|
|
|
|
proxmox::tools::time::epoch_to_rfc3339_utc(backup_time)
|
2019-07-22 08:12:51 +00:00
|
|
|
}
|
2019-03-05 06:18:12 +00:00
|
|
|
}
|
2020-06-23 06:16:56 +00:00
|
|
|
|
2020-06-23 06:09:52 +00:00
|
|
|
impl std::str::FromStr for BackupDir {
|
|
|
|
type Err = Error;
|
|
|
|
|
|
|
|
/// Parse a snapshot path
|
|
|
|
///
|
|
|
|
/// This parses strings like `host/elsa/2020-06-15T05:18:33Z".
|
|
|
|
fn from_str(path: &str) -> Result<Self, Self::Err> {
|
2021-03-14 18:18:35 +00:00
|
|
|
let cap = SNAPSHOT_PATH_REGEX
|
|
|
|
.captures(path)
|
2020-06-23 06:09:52 +00:00
|
|
|
.ok_or_else(|| format_err!("unable to parse backup snapshot path '{}'", path))?;
|
|
|
|
|
2020-09-15 07:34:46 +00:00
|
|
|
BackupDir::with_rfc3339(
|
|
|
|
cap.get(1).unwrap().as_str(),
|
|
|
|
cap.get(2).unwrap().as_str(),
|
|
|
|
cap.get(3).unwrap().as_str(),
|
|
|
|
)
|
2020-06-23 06:09:52 +00:00
|
|
|
}
|
|
|
|
}
|
2019-03-05 06:18:12 +00:00
|
|
|
|
2020-06-19 06:05:09 +00:00
|
|
|
impl std::fmt::Display for BackupDir {
|
|
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
|
|
let backup_type = self.group.backup_type();
|
|
|
|
let id = self.group.backup_id();
|
2020-09-12 13:10:47 +00:00
|
|
|
write!(f, "{}/{}/{}", backup_type, id, self.backup_time_string)
|
2019-03-05 08:16:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-05 06:28:13 +00:00
|
|
|
/// Detailed Backup Information, lists files inside a BackupDir
|
2019-05-11 09:21:13 +00:00
|
|
|
#[derive(Debug, Clone)]
|
2019-03-05 06:18:12 +00:00
|
|
|
pub struct BackupInfo {
|
|
|
|
/// the backup directory
|
|
|
|
pub backup_dir: BackupDir,
|
|
|
|
/// List of data files
|
|
|
|
pub files: Vec<String>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl BackupInfo {
|
2019-08-07 06:27:52 +00:00
|
|
|
pub fn new(base_path: &Path, backup_dir: BackupDir) -> Result<BackupInfo, Error> {
|
|
|
|
let mut path = base_path.to_owned();
|
|
|
|
path.push(backup_dir.relative_path());
|
|
|
|
|
|
|
|
let files = list_backup_files(libc::AT_FDCWD, &path)?;
|
|
|
|
|
|
|
|
Ok(BackupInfo { backup_dir, files })
|
|
|
|
}
|
|
|
|
|
2019-05-11 10:07:09 +00:00
|
|
|
/// Finds the latest backup inside a backup group
|
2021-03-14 18:18:35 +00:00
|
|
|
pub fn last_backup(
|
|
|
|
base_path: &Path,
|
|
|
|
group: &BackupGroup,
|
|
|
|
only_finished: bool,
|
|
|
|
) -> Result<Option<BackupInfo>, Error> {
|
2019-05-11 10:07:09 +00:00
|
|
|
let backups = group.list_backups(base_path)?;
|
2021-03-14 18:18:35 +00:00
|
|
|
Ok(backups
|
|
|
|
.into_iter()
|
2020-08-04 10:42:00 +00:00
|
|
|
.filter(|item| !only_finished || item.is_finished())
|
|
|
|
.max_by_key(|item| item.backup_dir.backup_time()))
|
2019-05-11 10:07:09 +00:00
|
|
|
}
|
|
|
|
|
2019-03-05 06:18:12 +00:00
|
|
|
pub fn sort_list(list: &mut Vec<BackupInfo>, ascendending: bool) {
|
2021-03-14 18:18:35 +00:00
|
|
|
if ascendending {
|
|
|
|
// oldest first
|
2019-03-05 06:18:12 +00:00
|
|
|
list.sort_unstable_by(|a, b| a.backup_dir.backup_time.cmp(&b.backup_dir.backup_time));
|
2021-03-14 18:18:35 +00:00
|
|
|
} else {
|
|
|
|
// newest first
|
2019-03-05 06:18:12 +00:00
|
|
|
list.sort_unstable_by(|a, b| b.backup_dir.backup_time.cmp(&a.backup_dir.backup_time));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-03-06 09:49:01 +00:00
|
|
|
pub fn list_files(base_path: &Path, backup_dir: &BackupDir) -> Result<Vec<String>, Error> {
|
|
|
|
let mut path = base_path.to_owned();
|
|
|
|
path.push(backup_dir.relative_path());
|
|
|
|
|
2019-05-11 08:19:34 +00:00
|
|
|
let files = list_backup_files(libc::AT_FDCWD, &path)?;
|
2019-03-06 09:49:01 +00:00
|
|
|
|
|
|
|
Ok(files)
|
|
|
|
}
|
|
|
|
|
2020-11-12 10:30:30 +00:00
|
|
|
pub fn list_backup_groups(base_path: &Path) -> Result<Vec<BackupGroup>, Error> {
|
2020-01-17 09:39:32 +00:00
|
|
|
let mut list = Vec::new();
|
2019-03-05 06:18:12 +00:00
|
|
|
|
2021-03-14 18:18:35 +00:00
|
|
|
tools::scandir(
|
|
|
|
libc::AT_FDCWD,
|
|
|
|
base_path,
|
|
|
|
&BACKUP_TYPE_REGEX,
|
|
|
|
|l0_fd, backup_type, file_type| {
|
|
|
|
if file_type != nix::dir::Type::Directory {
|
|
|
|
return Ok(());
|
|
|
|
}
|
|
|
|
tools::scandir(
|
|
|
|
l0_fd,
|
|
|
|
backup_type,
|
|
|
|
&BACKUP_ID_REGEX,
|
|
|
|
|_, backup_id, file_type| {
|
|
|
|
if file_type != nix::dir::Type::Directory {
|
|
|
|
return Ok(());
|
|
|
|
}
|
|
|
|
|
|
|
|
list.push(BackupGroup::new(backup_type, backup_id));
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
},
|
|
|
|
)
|
|
|
|
},
|
|
|
|
)?;
|
2020-11-12 10:30:30 +00:00
|
|
|
|
2019-03-05 06:18:12 +00:00
|
|
|
Ok(list)
|
|
|
|
}
|
2020-07-29 12:33:11 +00:00
|
|
|
|
|
|
|
pub fn is_finished(&self) -> bool {
|
|
|
|
// backup is considered unfinished if there is no manifest
|
2021-03-14 18:18:35 +00:00
|
|
|
self.files
|
|
|
|
.iter()
|
|
|
|
.any(|name| name == super::MANIFEST_BLOB_NAME)
|
2020-07-29 12:33:11 +00:00
|
|
|
}
|
2019-03-05 06:18:12 +00:00
|
|
|
}
|
2019-05-11 08:19:34 +00:00
|
|
|
|
2021-03-14 18:18:35 +00:00
|
|
|
fn list_backup_files<P: ?Sized + nix::NixPath>(
|
|
|
|
dirfd: RawFd,
|
|
|
|
path: &P,
|
|
|
|
) -> Result<Vec<String>, Error> {
|
2019-05-11 08:19:34 +00:00
|
|
|
let mut files = vec![];
|
|
|
|
|
|
|
|
tools::scandir(dirfd, path, &BACKUP_FILE_REGEX, |_, filename, file_type| {
|
2021-03-14 18:18:35 +00:00
|
|
|
if file_type != nix::dir::Type::File {
|
|
|
|
return Ok(());
|
|
|
|
}
|
2019-05-11 08:19:34 +00:00
|
|
|
files.push(filename.to_owned());
|
|
|
|
Ok(())
|
|
|
|
})?;
|
|
|
|
|
|
|
|
Ok(files)
|
|
|
|
}
|