Chewing_Bever
/
alex
1
0
Fork 0
Code Issues 13 Packages Releases 10 Activity

refactor: move backup logic to separate module

incremental-backups
Jef Roosens 2023-06-09 09:25:51 +02:00 committed by Chewing_Bever
parent 90aa929b73
commit 4958257f6e
Signed by: Jef Roosens
GPG Key ID: B75D4F293C7052DB
4 changed files with 123 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@ -19,4 +19,4 @@ target/
# testing files
*.jar
data/
data*/

108
src/server/backups.rs 100644
View File

@ -0,0 +1,108 @@
use flate2::write::GzEncoder;
use flate2::Compression;
use std::fs::File;
use std::io;
use std::path::{Path, PathBuf};
#[link(name = "c")]
extern "C" {
fn geteuid() -> u32;
fn getegid() -> u32;
}
static FILENAME_FORMAT: &str = "%Y-%m-%d_%H-%M-%S.tar.gz";
pub struct BackupManager {
backup_dir: PathBuf,
config_dir: PathBuf,
world_dir: PathBuf,
max_backups: u64,
start_time: Option<chrono::DateTime<chrono::Local>>,
}
impl BackupManager {
pub fn open(
backup_dir: PathBuf,
config_dir: PathBuf,
world_dir: PathBuf,
max_backups: u64,
) -> Self {
BackupManager {
backup_dir,
config_dir,
world_dir,
max_backups,
start_time: None,
}
}
pub fn create_archive(&mut self) -> io::Result<()> {
let start_time = chrono::offset::Local::now();
self.start_time = Some(start_time);
let filename = format!("{}", start_time.format(FILENAME_FORMAT));
let path = self.backup_dir.join(filename);
let tar_gz = File::create(path)?;
let enc = GzEncoder::new(tar_gz, Compression::default());
let mut tar = tar::Builder::new(enc);
tar.append_dir_all("worlds", &self.world_dir)?;
// Add all files from the config directory that aren't the cache
for entry in self
.config_dir
.read_dir()?
.filter_map(|e| e.ok())
.filter(|e| e.file_name() != "cache")
{
let tar_path = Path::new("config").join(entry.file_name());
if entry.file_type()?.is_dir() {
tar.append_dir_all(tar_path, entry.path())?;
} else {
tar.append_path_with_name(entry.path(), tar_path)?;
}
}
// TODO re-add this info file in some way
// We add a file to the backup describing for what version it was made
// let info = format!("{} {}", self.type_, self.version);
// let info_bytes = info.as_bytes();
// let mut header = tar::Header::new_gnu();
// header.set_size(info_bytes.len().try_into().unwrap());
// header.set_mode(0o100644);
// unsafe {
// header.set_gid(getegid().into());
// header.set_uid(geteuid().into());
// }
// tar.append_data(&mut header, "info.txt", info_bytes)?;
Ok(())
}
/// Remove the oldest backups
pub fn remove_old_backups(&mut self) -> std::io::Result<()> {
// The naming format used allows us to sort the backups by name and still get a sorting by
// creation time
let mut backups = self
.backup_dir
.read_dir()?
.filter_map(|res| res.map(|e| e.path()).ok())
.collect::<Vec<PathBuf>>();
backups.sort();
let max_backups: usize = self.max_backups.try_into().unwrap();
if backups.len() > max_backups {
let excess_backups = backups.len() - max_backups;
for backup in &backups[0..excess_backups] {
std::fs::remove_file(backup)?;
}
}
Ok(())
}
}

2
src/server/mod.rs
View File

@ -1,5 +1,7 @@
mod backups;
mod command;
mod process;
pub use backups::BackupManager;
pub use command::{ServerCommand, ServerType};
pub use process::ServerProcess;

93
src/server/process.rs
View File

@ -1,3 +1,4 @@
use crate::server::BackupManager;
use crate::server::ServerType;
use flate2::write::GzEncoder;
use flate2::Compression;
@ -5,12 +6,6 @@ use std::io::Write;
use std::path::{Path, PathBuf};
use std::process::Child;
#[link(name = "c")]
extern "C" {
fn geteuid() -> u32;
fn getegid() -> u32;
}
pub struct ServerProcess {
type_: ServerType,
version: String,
@ -19,6 +14,7 @@ pub struct ServerProcess {
backup_dir: PathBuf,
max_backups: u64,
child: Child,
backups: BackupManager,
}
impl ServerProcess {
@ -31,6 +27,13 @@ impl ServerProcess {
max_backups: u64,
child: Child,
) -> ServerProcess {
let backup_manager = BackupManager::open(
backup_dir.clone(),
config_dir.clone(),
world_dir.clone(),
max_backups,
);
ServerProcess {
type_,
version,
@ -39,6 +42,7 @@ impl ServerProcess {
backup_dir,
max_backups,
child,
backups: backup_manager,
}
}
@ -85,10 +89,10 @@ impl ServerProcess {
std::thread::sleep(std::time::Duration::from_secs(10));
let start_time = chrono::offset::Local::now();
let res = self.create_backup_archive();
let res = self.backups.create_archive();
if res.is_ok() {
self.remove_old_backups()?;
self.backups.remove_old_backups()?;
}
// The server's save feature needs to be enabled again even if the archive failed to create
@ -112,77 +116,4 @@ impl ServerProcess {
res
}
/// Create a new compressed backup archive of the server's data.
fn create_backup_archive(&mut self) -> std::io::Result<()> {
// Create a gzip-compressed tarball of the worlds folder
let filename = format!(
"{}",
chrono::offset::Local::now().format("%Y-%m-%d_%H-%M-%S.tar.gz")
);
let path = self.backup_dir.join(filename);
let tar_gz = std::fs::File::create(path)?;
let enc = GzEncoder::new(tar_gz, Compression::default());
let mut tar = tar::Builder::new(enc);
tar.append_dir_all("worlds", &self.world_dir)?;
// Add all files from the config directory that aren't the cache
for entry in self
.config_dir
.read_dir()?
.filter_map(|e| e.ok())
.filter(|e| e.file_name() != "cache")
{
let tar_path = Path::new("config").join(entry.file_name());
if entry.file_type()?.is_dir() {
tar.append_dir_all(tar_path, entry.path())?;
} else {
tar.append_path_with_name(entry.path(), tar_path)?;
}
}
// We add a file to the backup describing for what version it was made
let info = format!("{} {}", self.type_, self.version);
let info_bytes = info.as_bytes();
let mut header = tar::Header::new_gnu();
header.set_size(info_bytes.len().try_into().unwrap());
header.set_mode(0o100644);
unsafe {
header.set_gid(getegid().into());
header.set_uid(geteuid().into());
}
tar.append_data(&mut header, "info.txt", info_bytes)?;
// Backup file gets finalized in the drop
Ok(())
}
/// Remove the oldest backups
fn remove_old_backups(&mut self) -> std::io::Result<()> {
// The naming format used allows us to sort the backups by name and still get a sorting by
// creation time
let mut backups = self
.backup_dir
.read_dir()?
.filter_map(|res| res.map(|e| e.path()).ok())
.collect::<Vec<PathBuf>>();
backups.sort();
let max_backups: usize = self.max_backups.try_into().unwrap();
if backups.len() > max_backups {
let excess_backups = backups.len() - max_backups;
for backup in &backups[0..excess_backups] {
std::fs::remove_file(backup)?;
}
}
Ok(())
}
}