use serde::{Deserialize, Serialize};
use crate::delta::Delta;
pub const BUILD_FINGERPRINT: &str = env!("CP2_BUILD_FINGERPRINT");
pub type FileId = u64;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum TargetOs {
Unix,
Windows,
}
impl TargetOs {
#[must_use]
pub fn from_os_name(os: &str) -> Self {
if os.to_ascii_lowercase().contains("windows") {
TargetOs::Windows
} else {
TargetOs::Unix
}
}
}
pub const VERSION_BANNER: &str = concat!(
env!("CARGO_PKG_VERSION"),
" (build ",
env!("CP2_BUILD_FINGERPRINT"),
")"
);
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum Frame {
Hello {
fingerprint: String,
},
HelloAck {
fingerprint: String,
accepted: bool,
},
IndexRequest {
file_list: Vec<FileMeta>,
path: String,
verify: bool,
},
IndexResponse { file_list: Vec<FileMeta> },
SignatureRequest {
paths: Vec<String>,
},
SignatureResponse {
signatures: Vec<SignatureEntry>,
},
PullRequest {
paths: Vec<String>,
excludes: Vec<String>,
includes: Vec<String>,
checksum: bool,
delete: bool,
delete_scope: Vec<String>,
update_only: bool,
ignore_existing: bool,
existing: bool,
ignore_times: bool,
watch: bool,
watch_delay_ms: u32,
compress: bool,
bwlimit: Option<u64>,
client_os: TargetOs,
include_root: bool,
},
ListRequest {
path: String,
excludes: Vec<String>,
includes: Vec<String>,
},
ListResponse { file_list: Vec<FileMeta> },
DeltaRecipe {
file_id: FileId,
file_path: String,
delta: Delta,
source_signature: Option<crate::delta::Signature>,
basis_path: Option<String>,
},
Batch {
recipes: Vec<BatchFile>,
},
FileStart {
file_id: FileId,
file_path: String,
size: u64,
},
FileChunk {
file_id: FileId,
data: Vec<u8>,
},
FileEnd {
file_id: FileId,
},
MakeDir {
paths: Vec<String>,
},
CreateLinks {
links: Vec<LinkSpec>,
hardlinks: Vec<HardlinkSpec>,
specials: Vec<SpecialSpec>,
},
DeleteRequest {
paths: Vec<String>,
},
ApplyMeta { paths: Vec<String> },
Done {
files: u64,
bytes: u64,
},
Ack {
files: u64,
bytes: u64,
skipped: Vec<SkippedFile>,
hashes: Vec<(String, [u8; 32])>,
},
Error {
message: String,
},
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct SkippedFile {
pub path: String,
pub reason: String,
}
impl SkippedFile {
#[must_use]
pub fn new(path: impl Into<String>, reason: impl Into<String>) -> Self {
Self {
path: path.into(),
reason: reason.into(),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SignatureEntry {
pub file_path: String,
pub signature: crate::delta::Signature,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BatchFile {
pub file_id: FileId,
pub file_path: String,
pub delta: Delta,
}
#[derive(Debug)]
pub struct BatchItem {
pub file_id: FileId,
pub file_path: String,
pub data: Vec<u8>,
pub checksum: Option<[u8; 32]>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct HardlinkSpec {
pub path: String,
pub target: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct SpecialSpec {
pub path: String,
pub kind: FileKind,
pub rdev: Option<u64>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum FileKind {
File,
Dir,
Symlink,
Fifo,
Socket,
BlockDevice,
CharDevice,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum LinkKind {
Symlink,
Lnk,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct LinkSpec {
pub path: String,
pub target: String,
pub kind: LinkKind,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FileMeta {
pub path: String,
pub size: u64,
pub mtime: u64,
pub mtime_nsec: u32,
pub mode: u32,
pub hash: Option<[u8; 32]>,
pub kind: FileKind,
pub link_target: Option<String>,
pub inode: Option<u64>,
pub rdev: Option<u64>,
pub uid: Option<u32>,
pub gid: Option<u32>,
pub atime: u64,
pub atime_nsec: u32,
pub xattrs: Option<Vec<(String, Vec<u8>)>>,
}
impl FileMeta {
#[expect(clippy::too_many_arguments)]
#[must_use]
pub fn new(
path: String,
size: u64,
mtime: u64,
mtime_nsec: u32,
mode: u32,
hash: Option<[u8; 32]>,
kind: FileKind,
link_target: Option<String>,
inode: Option<u64>,
rdev: Option<u64>,
uid: Option<u32>,
gid: Option<u32>,
atime: u64,
atime_nsec: u32,
xattrs: Option<Vec<(String, Vec<u8>)>>,
) -> Self {
FileMeta {
path,
size,
mtime,
mtime_nsec,
mode,
hash,
kind,
link_target,
inode,
rdev,
uid,
gid,
atime,
atime_nsec,
xattrs,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn banner_matches_fingerprint() {
assert!(
VERSION_BANNER.contains(BUILD_FINGERPRINT),
"banner {VERSION_BANNER:?} must carry the build fingerprint"
);
}
#[test]
fn fingerprint_is_hex() {
assert_eq!(BUILD_FINGERPRINT.len(), 16);
assert!(BUILD_FINGERPRINT
.chars()
.all(|c| c.is_ascii_hexdigit()));
}
#[test]
fn core_frames_roundtrip() {
let frames = vec![
Frame::Hello {
fingerprint: BUILD_FINGERPRINT.to_string(),
},
Frame::HelloAck {
fingerprint: BUILD_FINGERPRINT.to_string(),
accepted: true,
},
Frame::IndexRequest {
file_list: vec![FileMeta::new(
"a.txt".to_string(),
5,
0,
0,
0o644,
None,
FileKind::File,
None,
Some(42),
None,
Some(1000),
Some(1000),
1_600_000_000,
0,
None,
)],
path: "/".to_string(),
verify: true,
},
Frame::IndexResponse {
file_list: Vec::new(),
},
Frame::SignatureRequest {
paths: vec!["a.bin".to_string()],
},
Frame::PullRequest {
paths: vec!["/backup".to_string()],
excludes: vec![],
includes: vec![],
checksum: false,
delete: false,
delete_scope: vec![],
update_only: false,
ignore_existing: false,
existing: true,
ignore_times: false,
watch: true,
watch_delay_ms: 250,
compress: false,
bwlimit: None,
client_os: TargetOs::Unix,
include_root: true,
},
Frame::ListRequest {
path: "/backup".to_string(),
excludes: vec!["*.tmp".to_string()],
includes: vec![],
},
Frame::ListResponse { file_list: Vec::new() },
Frame::CreateLinks {
links: vec![LinkSpec {
path: "link.txt".to_string(),
target: "target.txt".to_string(),
kind: LinkKind::Symlink,
}],
hardlinks: vec![HardlinkSpec {
path: "dup.txt".to_string(),
target: "orig.txt".to_string(),
}],
specials: vec![SpecialSpec {
path: "pipe".to_string(),
kind: FileKind::Fifo,
rdev: None,
}],
},
Frame::Ack {
files: 1,
bytes: 100,
skipped: vec![SkippedFile {
path: "locked.bin".into(),
reason: "another process holds it open".into(),
}],
hashes: vec![("a.txt".to_string(), [0u8; 32])],
},
];
for frame in &frames {
let bytes = postcard::to_allocvec(frame).unwrap();
let decoded: Frame = postcard::from_bytes(&bytes).unwrap();
assert_eq!(format!("{frame:?}"), format!("{decoded:?}"));
}
}
#[test]
fn signature_request_response_roundtrip() {
let request = Frame::SignatureRequest {
paths: vec!["a.bin".to_string(), "sub/c.bin".to_string()],
};
let bytes = postcard::to_allocvec(&request).unwrap();
let decoded: Frame = postcard::from_bytes(&bytes).unwrap();
assert_eq!(format!("{request:?}"), format!("{decoded:?}"));
let response = Frame::SignatureResponse {
signatures: vec![SignatureEntry {
file_path: "a.bin".to_string(),
signature: crate::delta::Signature::new(1234),
}],
};
let bytes = postcard::to_allocvec(&response).unwrap();
let decoded: Frame = postcard::from_bytes(&bytes).unwrap();
assert_eq!(format!("{response:?}"), format!("{decoded:?}"));
}
}