diff --git a/Cargo.lock b/Cargo.lock index c28b380..4aeecd7 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -32,8 +32,9 @@ dependencies = [ [[package]] name = "albatross" -version = "0.2.0" +version = "0.3.0" dependencies = [ + "anvil-region", "chrono", "config", "discord-hooks-rs", @@ -55,6 +56,18 @@ dependencies = [ "winapi 0.3.8", ] +[[package]] +name = "anvil-region" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8e1613ef793128ec9fb0bacd879a09bc5590e9757d81eb3104b2fd08fb5c59f" +dependencies = [ + "bitvec", + "byteorder", + "log", + "named-binary-tag", +] + [[package]] name = "atty" version = "0.2.14" @@ -98,12 +111,28 @@ version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693" +[[package]] +name = "bitvec" +version = "0.17.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "41262f11d771fd4a61aa3ce019fca363b4b6c282fca9da2a31186d3965a47a5c" +dependencies = [ + "either", + "radium", +] + [[package]] name = "bumpalo" version = "3.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2e8c087f005730276d1096a652e92a8bacee2e2472bcc9715a74d2bec38b5820" +[[package]] +name = "byteorder" +version = "1.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de" + [[package]] name = "bytes" version = "0.5.4" @@ -211,6 +240,12 @@ version = "0.4.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4358a9e11b9a09cf52383b451b49a169e8d797b68aa02301ff586d70d9661ea3" +[[package]] +name = "either" +version = "1.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457" + [[package]] name = "encoding_rs" version = "0.8.23" @@ -562,9 +597,9 @@ checksum = "8dd5a6d5999d9907cda8ed67bbd137d3af8085216c2ac62de5be860bd41f304a" [[package]] name = "log" -version = "0.4.8" +version = "0.4.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "14b6052be84e6b71ab17edffc2eeabf5c2c3ae1fdb464aae35ac50c67a44e1f7" +checksum = "4fabed175da42fed1fa0746b0ea71f412aa9d35e76e95e59b192c64b9dc2bf8b" dependencies = [ "cfg-if 0.1.10", ] @@ -647,6 +682,17 @@ dependencies = [ "ws2_32-sys", ] +[[package]] +name = "named-binary-tag" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ae8ccc227f1ca068299ad32bcac0da2d2cf90b1b51c4679d0cc30900703ba60" +dependencies = [ + "byteorder", + "flate2", + "linked-hash-map 0.5.3", +] + [[package]] name = "native-tls" version = "0.2.4" @@ -861,6 +907,12 @@ dependencies = [ "proc-macro2", ] +[[package]] +name = "radium" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "def50a86306165861203e7f84ecffbbdfdea79f0e51039b33de1e952358c47ac" + [[package]] name = "rand" version = "0.7.3" diff --git a/Cargo.toml b/Cargo.toml index a2142a5..c04c8e2 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "albatross" -version = "0.2.0" +version = "0.3.0" authors = ["Joey Hines "] edition = "2018" @@ -17,3 +17,4 @@ flate2 = "1.0.14" tar = "0.4.28" reqwest = { version = "0.10", features = ["blocking", "json"] } discord-hooks-rs = { git = "https://github.com/joeyahines/discord-hooks-rs" } +anvil-region = "0.4.0" diff --git a/README.md b/README.md index e3fc79b..43c924f 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,7 @@ webhooks. Backups are compressed and stored as `tar.gz` archives. ## Help ``` -albatross 0.2.0 +albatross 0.3.0 Backup your Minecraft Server! USAGE: @@ -20,14 +20,32 @@ OPTIONS: -c, --config-path Path to the Albatross config [env: ALBATROSS_CONFIG=] SUBCOMMANDS: - backup Backup a server - export Export a backup as a single player world - help Prints this message or the help of the given subcommand(s) + backup Backup a server + export Export a backup as a single player world + help Prints this message or the help of the given subcommand(s) + restore Restore certain chunks from a backup Process finished with exit code 1 ``` +## Examples +Running a backup: + +`albatorss -c test.toml backup` + +Exporting a backup to a single player world: + +`albatorss -c test.toml export backups/04-11-20_01.51.27_backup.tar.gz sp.tar.gz` + +Restoring a single chunk (from -2,-2 to 2,2): + +`albatorss -c test.toml restore world backups/04-11-20_01.51.27_backup.tar.gz sp.tar.gz` (0,0) + +Restoring a range of chunks (from -2,-2 to 2,2): + +`albatorss -c test.toml restore world backups/04-11-20_01.51.27_backup.tar.gz sp.tar.gz` (-2,-2) -u (2,2) + ## Config ```toml [backup] diff --git a/src/backup.rs b/src/backup.rs index c7e8591..1bc4a46 100644 --- a/src/backup.rs +++ b/src/backup.rs @@ -198,6 +198,16 @@ pub fn compress_backup(tmp_dir: &PathBuf, output_file: &PathBuf) -> Result<(), s Ok(()) } +pub fn uncompress_backup(backup: &PathBuf) -> Result { + let backup_file = File::open(backup)?; + let dec = GzDecoder::new(backup_file); + let mut extract = Archive::new(dec); + let extract_path = PathBuf::from("tmp"); + extract.unpack(&extract_path)?; + + Ok(extract_path) +} + /// Takes an existing backup and converts it to a singleplayer world /// /// # Param @@ -209,11 +219,7 @@ pub fn convert_backup_to_sp( backup: &PathBuf, output: &PathBuf, ) -> Result<(), std::io::Error> { - let backup_file = File::open(backup)?; - let dec = GzDecoder::new(backup_file); - let mut extract = Archive::new(dec); - let extract_path = PathBuf::from("tmp"); - extract.unpack(&extract_path)?; + let extract_path = uncompress_backup(backup)?; if let Some(worlds) = &config.world_config { for world in worlds { diff --git a/src/chunk_coordinate.rs b/src/chunk_coordinate.rs new file mode 100644 index 0000000..a5ca72c --- /dev/null +++ b/src/chunk_coordinate.rs @@ -0,0 +1,62 @@ +use regex::Regex; +use std::error::Error; +use std::fmt; +use std::num::ParseIntError; +use std::str::FromStr; + +/// Chunk error +#[derive(Debug)] +pub enum ChunkCoordinateErr { + /// Error parsing integer + ParseIntError(ParseIntError), + /// Regex error + RegexError(regex::Error), + /// Invalid chunk coordinate given + InvalidChunk, +} + +impl From for ChunkCoordinateErr { + fn from(e: ParseIntError) -> Self { + Self::ParseIntError(e) + } +} + +impl From for ChunkCoordinateErr { + fn from(e: regex::Error) -> Self { + Self::RegexError(e) + } +} + +impl fmt::Display for ChunkCoordinateErr { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "Unable to parse chunk range: {:?}", self) + } +} + +impl Error for ChunkCoordinateErr {} + +/// Chunk Coordinate paiir +#[derive(Debug)] +pub struct ChunkCoordinate { + /// X Coordinate + pub x: i32, + /// Z Coordinate + pub z: i32, +} + +impl FromStr for ChunkCoordinate { + type Err = ChunkCoordinateErr; + + fn from_str(s: &str) -> Result { + let re = Regex::new(r"\((?P-?[0-9]*),(?P-?[0-9]*)\)").unwrap(); + + if let Some(cap) = re.captures(s) { + let x = cap["x"].parse::()?; + let z = cap["z"].parse::()?; + + Ok(Self { x, z }) + } else { + Err(ChunkCoordinateErr::InvalidChunk) + } + } +} diff --git a/src/main.rs b/src/main.rs index a9dc8b3..c3d5a0e 100644 --- a/src/main.rs +++ b/src/main.rs @@ -2,12 +2,16 @@ use std::path::PathBuf; use structopt::StructOpt; mod backup; +mod chunk_coordinate; mod config; mod discord; mod region; +mod restore; use crate::backup::{convert_backup_to_sp, do_backup}; +use crate::chunk_coordinate::ChunkCoordinate; use crate::config::AlbatrossConfig; +use crate::restore::{restore_chunk_from_backup, restore_range_from_backup}; #[derive(Debug, StructOpt)] #[structopt(about = "Backup your Minecraft Server!")] @@ -24,13 +28,13 @@ struct Albatross { enum SubCommand { /// Backup a server Backup { - /// Output location override + /// Output path #[structopt(short = "o", long = "ouptut", parse(from_os_str))] output: Option, }, /// Export a backup as a single player world Export { - /// Convert backup to singleplayer world + /// Backup to convert #[structopt(parse(from_os_str))] input_backup: PathBuf, @@ -38,6 +42,22 @@ enum SubCommand { #[structopt(parse(from_os_str))] output: PathBuf, }, + /// Restore certain chunks from a backup + Restore { + /// Output server directory + #[structopt(short, long, parse(from_os_str))] + server_directory: Option, + /// World to restore + world_name: String, + /// Backup to restore from + #[structopt(parse(from_os_str))] + backup_path: PathBuf, + /// Chunk to backup + chunk: ChunkCoordinate, + /// Upper chunk range bound + #[structopt(short, long)] + upper_bound: Option, + }, } fn main() { @@ -65,6 +85,43 @@ fn main() { Err(e) => println!("Error exporting backup: {:?}", e), }; } + SubCommand::Restore { + server_directory, + world_name, + backup_path, + chunk, + upper_bound, + } => { + println!("Starting restore"); + + let server_directory = match server_directory { + Some(dir) => dir, + None => cfg.backup.minecraft_dir, + }; + + if let Some(upper_bound) = upper_bound { + match restore_range_from_backup( + world_name.as_str(), + chunk, + upper_bound, + &backup_path, + &server_directory, + ) { + Ok(count) => println!("Restored {} chunks!", count), + Err(e) => println!("Error restoring backup: {:?}", e), + }; + } else { + match restore_chunk_from_backup( + world_name.as_str(), + chunk, + &backup_path, + &server_directory, + ) { + Ok(_) => println!("Restored chunk!"), + Err(e) => println!("Error restoring backup: {:?}", e), + }; + } + } } } else { println!("No worlds specified in config file!") diff --git a/src/restore.rs b/src/restore.rs new file mode 100644 index 0000000..28d4581 --- /dev/null +++ b/src/restore.rs @@ -0,0 +1,83 @@ +use crate::backup::uncompress_backup; +use crate::chunk_coordinate::ChunkCoordinate; +use anvil_region::AnvilChunkProvider; +use std::error; +use std::fs::remove_dir_all; +use std::path::PathBuf; + +/// Struct for manipulating a world from a backup +struct RestoreAccess { + /// Chunk source + src_path: PathBuf, + /// Chunk destination + dest_path: PathBuf, +} + +impl RestoreAccess { + /// Create new RestoreAccess + pub fn new( + world_name: &str, + src_path: &PathBuf, + dest_path: &PathBuf, + ) -> Result { + let src_path = uncompress_backup(src_path)?.join(world_name).join("region"); + let dest_path = dest_path.join(world_name).join("region"); + + Ok(RestoreAccess { + src_path, + dest_path, + }) + } + + /// Copy chunk from source to desination + pub fn copy_chunk(&self, x: i32, z: i32) { + let src_provider = AnvilChunkProvider::new(self.src_path.to_str().unwrap()); + let dest_provider = AnvilChunkProvider::new(self.dest_path.to_str().unwrap()); + + let chunk = src_provider.load_chunk(x, z).expect("Unable to load chunk"); + dest_provider + .save_chunk(x, z, chunk) + .expect("Unable to save chunk"); + } + + /// Cleanup process + pub fn cleanup(self) -> Result<(), std::io::Error> { + remove_dir_all("tmp") + } +} + +/// Restore a range of chunks from a backup +pub fn restore_range_from_backup( + world_name: &str, + lower: ChunkCoordinate, + upper: ChunkCoordinate, + backup_path: &PathBuf, + minecraft_dir: &PathBuf, +) -> Result> { + let chunk_access = RestoreAccess::new(world_name, backup_path, minecraft_dir)?; + let mut count = 0; + + for x in lower.x..=upper.x { + for z in lower.z..=upper.z { + chunk_access.copy_chunk(x, z); + count += 1; + } + } + + chunk_access.cleanup()?; + Ok(count) +} + +/// Restore a single chunk from a backup +pub fn restore_chunk_from_backup( + world_name: &str, + chunk: ChunkCoordinate, + backup_path: &PathBuf, + minecraft_dir: &PathBuf, +) -> Result<(), Box> { + let chunk_access = RestoreAccess::new(world_name, backup_path, minecraft_dir)?; + chunk_access.copy_chunk(chunk.x, chunk.z); + + chunk_access.cleanup()?; + Ok(()) +}