mirror of https://github.com/chipsenkbeil/distant
Refactor into protocol crate & change capabilities -> version (#189)
Chip Senkbeil
12 months ago
committed by
GitHub
parent
95c0d0c0d1
commit
76dc7cf1fa
@ -1,572 +0,0 @@
|
|||||||
use std::io;
|
|
||||||
use std::path::PathBuf;
|
|
||||||
|
|
||||||
use derive_more::{From, IsVariant};
|
|
||||||
use serde::{Deserialize, Serialize};
|
|
||||||
use strum::{AsRefStr, EnumDiscriminants, EnumIter, EnumMessage, EnumString};
|
|
||||||
|
|
||||||
mod capabilities;
|
|
||||||
pub use capabilities::*;
|
|
||||||
|
|
||||||
mod change;
|
|
||||||
pub use change::*;
|
|
||||||
|
|
||||||
mod cmd;
|
|
||||||
pub use cmd::*;
|
|
||||||
|
|
||||||
mod error;
|
|
||||||
pub use error::*;
|
|
||||||
|
|
||||||
mod filesystem;
|
|
||||||
pub use filesystem::*;
|
|
||||||
|
|
||||||
mod metadata;
|
|
||||||
pub use metadata::*;
|
|
||||||
|
|
||||||
mod permissions;
|
|
||||||
pub use permissions::*;
|
|
||||||
|
|
||||||
mod pty;
|
|
||||||
pub use pty::*;
|
|
||||||
|
|
||||||
mod search;
|
|
||||||
pub use search::*;
|
|
||||||
|
|
||||||
mod system;
|
|
||||||
pub use system::*;
|
|
||||||
|
|
||||||
mod utils;
|
|
||||||
pub(crate) use utils::*;
|
|
||||||
|
|
||||||
/// Id for a remote process
|
|
||||||
pub type ProcessId = u32;
|
|
||||||
|
|
||||||
/// Mapping of environment variables
|
|
||||||
pub type Environment = distant_net::common::Map;
|
|
||||||
|
|
||||||
/// Represents a wrapper around a distant message, supporting single and batch requests
|
|
||||||
#[derive(Clone, Debug, From, PartialEq, Eq, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
#[serde(untagged)]
|
|
||||||
pub enum Msg<T> {
|
|
||||||
Single(T),
|
|
||||||
Batch(Vec<T>),
|
|
||||||
}
|
|
||||||
|
|
||||||
impl<T> Msg<T> {
|
|
||||||
/// Returns true if msg has a single payload
|
|
||||||
pub fn is_single(&self) -> bool {
|
|
||||||
matches!(self, Self::Single(_))
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns reference to single value if msg is single variant
|
|
||||||
pub fn as_single(&self) -> Option<&T> {
|
|
||||||
match self {
|
|
||||||
Self::Single(x) => Some(x),
|
|
||||||
_ => None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns mutable reference to single value if msg is single variant
|
|
||||||
pub fn as_mut_single(&mut self) -> Option<&T> {
|
|
||||||
match self {
|
|
||||||
Self::Single(x) => Some(x),
|
|
||||||
_ => None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the single value if msg is single variant
|
|
||||||
pub fn into_single(self) -> Option<T> {
|
|
||||||
match self {
|
|
||||||
Self::Single(x) => Some(x),
|
|
||||||
_ => None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns true if msg has a batch of payloads
|
|
||||||
pub fn is_batch(&self) -> bool {
|
|
||||||
matches!(self, Self::Batch(_))
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns reference to batch value if msg is batch variant
|
|
||||||
pub fn as_batch(&self) -> Option<&[T]> {
|
|
||||||
match self {
|
|
||||||
Self::Batch(x) => Some(x),
|
|
||||||
_ => None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns mutable reference to batch value if msg is batch variant
|
|
||||||
pub fn as_mut_batch(&mut self) -> Option<&mut [T]> {
|
|
||||||
match self {
|
|
||||||
Self::Batch(x) => Some(x),
|
|
||||||
_ => None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the batch value if msg is batch variant
|
|
||||||
pub fn into_batch(self) -> Option<Vec<T>> {
|
|
||||||
match self {
|
|
||||||
Self::Batch(x) => Some(x),
|
|
||||||
_ => None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Convert into a collection of payload data
|
|
||||||
pub fn into_vec(self) -> Vec<T> {
|
|
||||||
match self {
|
|
||||||
Self::Single(x) => vec![x],
|
|
||||||
Self::Batch(x) => x,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl<T: schemars::JsonSchema> Msg<T> {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(Msg<T>)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Represents the payload of a request to be performed on the remote machine
|
|
||||||
#[derive(Clone, Debug, PartialEq, Eq, EnumDiscriminants, IsVariant, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
#[strum_discriminants(derive(
|
|
||||||
AsRefStr,
|
|
||||||
strum::Display,
|
|
||||||
EnumIter,
|
|
||||||
EnumMessage,
|
|
||||||
EnumString,
|
|
||||||
Hash,
|
|
||||||
PartialOrd,
|
|
||||||
Ord,
|
|
||||||
IsVariant,
|
|
||||||
Serialize,
|
|
||||||
Deserialize
|
|
||||||
))]
|
|
||||||
#[cfg_attr(
|
|
||||||
feature = "schemars",
|
|
||||||
strum_discriminants(derive(schemars::JsonSchema))
|
|
||||||
)]
|
|
||||||
#[strum_discriminants(name(CapabilityKind))]
|
|
||||||
#[strum_discriminants(strum(serialize_all = "snake_case"))]
|
|
||||||
#[serde(rename_all = "snake_case", deny_unknown_fields, tag = "type")]
|
|
||||||
pub enum Request {
|
|
||||||
/// Retrieve information about the server's capabilities
|
|
||||||
#[strum_discriminants(strum(message = "Supports retrieving capabilities"))]
|
|
||||||
Capabilities {},
|
|
||||||
|
|
||||||
/// Reads a file from the specified path on the remote machine
|
|
||||||
#[strum_discriminants(strum(message = "Supports reading binary file"))]
|
|
||||||
FileRead {
|
|
||||||
/// The path to the file on the remote machine
|
|
||||||
path: PathBuf,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Reads a file from the specified path on the remote machine
|
|
||||||
/// and treats the contents as text
|
|
||||||
#[strum_discriminants(strum(message = "Supports reading text file"))]
|
|
||||||
FileReadText {
|
|
||||||
/// The path to the file on the remote machine
|
|
||||||
path: PathBuf,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Writes a file, creating it if it does not exist, and overwriting any existing content
|
|
||||||
/// on the remote machine
|
|
||||||
#[strum_discriminants(strum(message = "Supports writing binary file"))]
|
|
||||||
FileWrite {
|
|
||||||
/// The path to the file on the remote machine
|
|
||||||
path: PathBuf,
|
|
||||||
|
|
||||||
/// Data for server-side writing of content
|
|
||||||
#[serde(with = "serde_bytes")]
|
|
||||||
#[cfg_attr(feature = "schemars", schemars(with = "Vec<u8>"))]
|
|
||||||
data: Vec<u8>,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Writes a file using text instead of bytes, creating it if it does not exist,
|
|
||||||
/// and overwriting any existing content on the remote machine
|
|
||||||
#[strum_discriminants(strum(message = "Supports writing text file"))]
|
|
||||||
FileWriteText {
|
|
||||||
/// The path to the file on the remote machine
|
|
||||||
path: PathBuf,
|
|
||||||
|
|
||||||
/// Data for server-side writing of content
|
|
||||||
text: String,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Appends to a file, creating it if it does not exist, on the remote machine
|
|
||||||
#[strum_discriminants(strum(message = "Supports appending to binary file"))]
|
|
||||||
FileAppend {
|
|
||||||
/// The path to the file on the remote machine
|
|
||||||
path: PathBuf,
|
|
||||||
|
|
||||||
/// Data for server-side writing of content
|
|
||||||
#[serde(with = "serde_bytes")]
|
|
||||||
#[cfg_attr(feature = "schemars", schemars(with = "Vec<u8>"))]
|
|
||||||
data: Vec<u8>,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Appends text to a file, creating it if it does not exist, on the remote machine
|
|
||||||
#[strum_discriminants(strum(message = "Supports appending to text file"))]
|
|
||||||
FileAppendText {
|
|
||||||
/// The path to the file on the remote machine
|
|
||||||
path: PathBuf,
|
|
||||||
|
|
||||||
/// Data for server-side writing of content
|
|
||||||
text: String,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Reads a directory from the specified path on the remote machine
|
|
||||||
#[strum_discriminants(strum(message = "Supports reading directory"))]
|
|
||||||
DirRead {
|
|
||||||
/// The path to the directory on the remote machine
|
|
||||||
path: PathBuf,
|
|
||||||
|
|
||||||
/// Maximum depth to traverse with 0 indicating there is no maximum
|
|
||||||
/// depth and 1 indicating the most immediate children within the
|
|
||||||
/// directory
|
|
||||||
#[serde(default = "one")]
|
|
||||||
depth: usize,
|
|
||||||
|
|
||||||
/// Whether or not to return absolute or relative paths
|
|
||||||
#[serde(default)]
|
|
||||||
absolute: bool,
|
|
||||||
|
|
||||||
/// Whether or not to canonicalize the resulting paths, meaning
|
|
||||||
/// returning the canonical, absolute form of a path with all
|
|
||||||
/// intermediate components normalized and symbolic links resolved
|
|
||||||
///
|
|
||||||
/// Note that the flag absolute must be true to have absolute paths
|
|
||||||
/// returned, even if canonicalize is flagged as true
|
|
||||||
#[serde(default)]
|
|
||||||
canonicalize: bool,
|
|
||||||
|
|
||||||
/// Whether or not to include the root directory in the retrieved
|
|
||||||
/// entries
|
|
||||||
///
|
|
||||||
/// If included, the root directory will also be a canonicalized,
|
|
||||||
/// absolute path and will not follow any of the other flags
|
|
||||||
#[serde(default)]
|
|
||||||
include_root: bool,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Creates a directory on the remote machine
|
|
||||||
#[strum_discriminants(strum(message = "Supports creating directory"))]
|
|
||||||
DirCreate {
|
|
||||||
/// The path to the directory on the remote machine
|
|
||||||
path: PathBuf,
|
|
||||||
|
|
||||||
/// Whether or not to create all parent directories
|
|
||||||
#[serde(default)]
|
|
||||||
all: bool,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Removes a file or directory on the remote machine
|
|
||||||
#[strum_discriminants(strum(message = "Supports removing files, directories, and symlinks"))]
|
|
||||||
Remove {
|
|
||||||
/// The path to the file or directory on the remote machine
|
|
||||||
path: PathBuf,
|
|
||||||
|
|
||||||
/// Whether or not to remove all contents within directory if is a directory.
|
|
||||||
/// Does nothing different for files
|
|
||||||
#[serde(default)]
|
|
||||||
force: bool,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Copies a file or directory on the remote machine
|
|
||||||
#[strum_discriminants(strum(message = "Supports copying files, directories, and symlinks"))]
|
|
||||||
Copy {
|
|
||||||
/// The path to the file or directory on the remote machine
|
|
||||||
src: PathBuf,
|
|
||||||
|
|
||||||
/// New location on the remote machine for copy of file or directory
|
|
||||||
dst: PathBuf,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Moves/renames a file or directory on the remote machine
|
|
||||||
#[strum_discriminants(strum(message = "Supports renaming files, directories, and symlinks"))]
|
|
||||||
Rename {
|
|
||||||
/// The path to the file or directory on the remote machine
|
|
||||||
src: PathBuf,
|
|
||||||
|
|
||||||
/// New location on the remote machine for the file or directory
|
|
||||||
dst: PathBuf,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Watches a path for changes
|
|
||||||
#[strum_discriminants(strum(message = "Supports watching filesystem for changes"))]
|
|
||||||
Watch {
|
|
||||||
/// The path to the file, directory, or symlink on the remote machine
|
|
||||||
path: PathBuf,
|
|
||||||
|
|
||||||
/// If true, will recursively watch for changes within directories, othewise
|
|
||||||
/// will only watch for changes immediately within directories
|
|
||||||
#[serde(default)]
|
|
||||||
recursive: bool,
|
|
||||||
|
|
||||||
/// Filter to only report back specified changes
|
|
||||||
#[serde(default)]
|
|
||||||
only: Vec<ChangeKind>,
|
|
||||||
|
|
||||||
/// Filter to report back changes except these specified changes
|
|
||||||
#[serde(default)]
|
|
||||||
except: Vec<ChangeKind>,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Unwatches a path for changes, meaning no additional changes will be reported
|
|
||||||
#[strum_discriminants(strum(message = "Supports unwatching filesystem for changes"))]
|
|
||||||
Unwatch {
|
|
||||||
/// The path to the file, directory, or symlink on the remote machine
|
|
||||||
path: PathBuf,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Checks whether the given path exists
|
|
||||||
#[strum_discriminants(strum(message = "Supports checking if a path exists"))]
|
|
||||||
Exists {
|
|
||||||
/// The path to the file or directory on the remote machine
|
|
||||||
path: PathBuf,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Retrieves filesystem metadata for the specified path on the remote machine
|
|
||||||
#[strum_discriminants(strum(
|
|
||||||
message = "Supports retrieving metadata about a file, directory, or symlink"
|
|
||||||
))]
|
|
||||||
Metadata {
|
|
||||||
/// The path to the file, directory, or symlink on the remote machine
|
|
||||||
path: PathBuf,
|
|
||||||
|
|
||||||
/// Whether or not to include a canonicalized version of the path, meaning
|
|
||||||
/// returning the canonical, absolute form of a path with all
|
|
||||||
/// intermediate components normalized and symbolic links resolved
|
|
||||||
#[serde(default)]
|
|
||||||
canonicalize: bool,
|
|
||||||
|
|
||||||
/// Whether or not to follow symlinks to determine absolute file type (dir/file)
|
|
||||||
#[serde(default)]
|
|
||||||
resolve_file_type: bool,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Sets permissions on a file, directory, or symlink on the remote machine
|
|
||||||
#[strum_discriminants(strum(
|
|
||||||
message = "Supports setting permissions on a file, directory, or symlink"
|
|
||||||
))]
|
|
||||||
SetPermissions {
|
|
||||||
/// The path to the file, directory, or symlink on the remote machine
|
|
||||||
path: PathBuf,
|
|
||||||
|
|
||||||
/// New permissions to apply to the file, directory, or symlink
|
|
||||||
permissions: Permissions,
|
|
||||||
|
|
||||||
/// Additional options to supply when setting permissions
|
|
||||||
#[serde(default)]
|
|
||||||
options: SetPermissionsOptions,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Searches filesystem using the provided query
|
|
||||||
#[strum_discriminants(strum(message = "Supports searching filesystem using queries"))]
|
|
||||||
Search {
|
|
||||||
/// Query to perform against the filesystem
|
|
||||||
query: SearchQuery,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Cancels an active search being run against the filesystem
|
|
||||||
#[strum_discriminants(strum(
|
|
||||||
message = "Supports canceling an active search against the filesystem"
|
|
||||||
))]
|
|
||||||
CancelSearch {
|
|
||||||
/// Id of the search to cancel
|
|
||||||
id: SearchId,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Spawns a new process on the remote machine
|
|
||||||
#[strum_discriminants(strum(message = "Supports spawning a process"))]
|
|
||||||
ProcSpawn {
|
|
||||||
/// The full command to run including arguments
|
|
||||||
cmd: Cmd,
|
|
||||||
|
|
||||||
/// Environment to provide to the remote process
|
|
||||||
#[serde(default)]
|
|
||||||
environment: Environment,
|
|
||||||
|
|
||||||
/// Alternative current directory for the remote process
|
|
||||||
#[serde(default)]
|
|
||||||
current_dir: Option<PathBuf>,
|
|
||||||
|
|
||||||
/// If provided, will spawn process in a pty, otherwise spawns directly
|
|
||||||
#[serde(default)]
|
|
||||||
pty: Option<PtySize>,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Kills a process running on the remote machine
|
|
||||||
#[strum_discriminants(strum(message = "Supports killing a spawned process"))]
|
|
||||||
ProcKill {
|
|
||||||
/// Id of the actively-running process
|
|
||||||
id: ProcessId,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Sends additional data to stdin of running process
|
|
||||||
#[strum_discriminants(strum(message = "Supports sending stdin to a spawned process"))]
|
|
||||||
ProcStdin {
|
|
||||||
/// Id of the actively-running process to send stdin data
|
|
||||||
id: ProcessId,
|
|
||||||
|
|
||||||
/// Data to send to a process's stdin pipe
|
|
||||||
#[serde(with = "serde_bytes")]
|
|
||||||
#[cfg_attr(feature = "schemars", schemars(with = "Vec<u8>"))]
|
|
||||||
data: Vec<u8>,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Resize pty of remote process
|
|
||||||
#[strum_discriminants(strum(message = "Supports resizing the pty of a spawned process"))]
|
|
||||||
ProcResizePty {
|
|
||||||
/// Id of the actively-running process whose pty to resize
|
|
||||||
id: ProcessId,
|
|
||||||
|
|
||||||
/// The new pty dimensions
|
|
||||||
size: PtySize,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Retrieve information about the server and the system it is on
|
|
||||||
#[strum_discriminants(strum(message = "Supports retrieving system information"))]
|
|
||||||
SystemInfo {},
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl Request {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(Request)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Represents the payload of a successful response
|
|
||||||
#[derive(Clone, Debug, PartialEq, Eq, AsRefStr, IsVariant, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
#[serde(rename_all = "snake_case", deny_unknown_fields, tag = "type")]
|
|
||||||
#[strum(serialize_all = "snake_case")]
|
|
||||||
pub enum Response {
|
|
||||||
/// General okay with no extra data, returned in cases like
|
|
||||||
/// creating or removing a directory, copying a file, or renaming
|
|
||||||
/// a file
|
|
||||||
Ok,
|
|
||||||
|
|
||||||
/// General-purpose failure that occurred from some request
|
|
||||||
Error(Error),
|
|
||||||
|
|
||||||
/// Response containing some arbitrary, binary data
|
|
||||||
Blob {
|
|
||||||
/// Binary data associated with the response
|
|
||||||
#[serde(with = "serde_bytes")]
|
|
||||||
#[cfg_attr(feature = "schemars", schemars(with = "Vec<u8>"))]
|
|
||||||
data: Vec<u8>,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Response containing some arbitrary, text data
|
|
||||||
Text {
|
|
||||||
/// Text data associated with the response
|
|
||||||
data: String,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Response to reading a directory
|
|
||||||
DirEntries {
|
|
||||||
/// Entries contained within the requested directory
|
|
||||||
entries: Vec<DirEntry>,
|
|
||||||
|
|
||||||
/// Errors encountered while scanning for entries
|
|
||||||
errors: Vec<Error>,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Response to a filesystem change for some watched file, directory, or symlink
|
|
||||||
Changed(Change),
|
|
||||||
|
|
||||||
/// Response to checking if a path exists
|
|
||||||
Exists { value: bool },
|
|
||||||
|
|
||||||
/// Represents metadata about some filesystem object (file, directory, symlink) on remote machine
|
|
||||||
Metadata(Metadata),
|
|
||||||
|
|
||||||
/// Represents a search being started
|
|
||||||
SearchStarted {
|
|
||||||
/// Arbitrary id associated with search
|
|
||||||
id: SearchId,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Represents some subset of results for a search query (may not be all of them)
|
|
||||||
SearchResults {
|
|
||||||
/// Arbitrary id associated with search
|
|
||||||
id: SearchId,
|
|
||||||
|
|
||||||
/// Collection of matches from performing a query
|
|
||||||
matches: Vec<SearchQueryMatch>,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Represents a search being completed
|
|
||||||
SearchDone {
|
|
||||||
/// Arbitrary id associated with search
|
|
||||||
id: SearchId,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Response to starting a new process
|
|
||||||
ProcSpawned {
|
|
||||||
/// Arbitrary id associated with running process
|
|
||||||
id: ProcessId,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Actively-transmitted stdout as part of running process
|
|
||||||
ProcStdout {
|
|
||||||
/// Arbitrary id associated with running process
|
|
||||||
id: ProcessId,
|
|
||||||
|
|
||||||
/// Data read from a process' stdout pipe
|
|
||||||
#[serde(with = "serde_bytes")]
|
|
||||||
#[cfg_attr(feature = "schemars", schemars(with = "Vec<u8>"))]
|
|
||||||
data: Vec<u8>,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Actively-transmitted stderr as part of running process
|
|
||||||
ProcStderr {
|
|
||||||
/// Arbitrary id associated with running process
|
|
||||||
id: ProcessId,
|
|
||||||
|
|
||||||
/// Data read from a process' stderr pipe
|
|
||||||
#[serde(with = "serde_bytes")]
|
|
||||||
#[cfg_attr(feature = "schemars", schemars(with = "Vec<u8>"))]
|
|
||||||
data: Vec<u8>,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Response to a process finishing
|
|
||||||
ProcDone {
|
|
||||||
/// Arbitrary id associated with running process
|
|
||||||
id: ProcessId,
|
|
||||||
|
|
||||||
/// Whether or not termination was successful
|
|
||||||
success: bool,
|
|
||||||
|
|
||||||
/// Exit code associated with termination, will be missing if terminated by signal
|
|
||||||
code: Option<i32>,
|
|
||||||
},
|
|
||||||
|
|
||||||
/// Response to retrieving information about the server and the system it is on
|
|
||||||
SystemInfo(SystemInfo),
|
|
||||||
|
|
||||||
/// Response to retrieving information about the server's capabilities
|
|
||||||
Capabilities { supported: Capabilities },
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl Response {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(Response)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<io::Error> for Response {
|
|
||||||
fn from(x: io::Error) -> Self {
|
|
||||||
Self::Error(Error::from(x))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Used to provide a default serde value of 1
|
|
||||||
const fn one() -> usize {
|
|
||||||
1
|
|
||||||
}
|
|
||||||
@ -1,207 +0,0 @@
|
|||||||
use std::cmp::Ordering;
|
|
||||||
use std::collections::HashSet;
|
|
||||||
use std::hash::{Hash, Hasher};
|
|
||||||
use std::ops::{BitAnd, BitOr, BitXor};
|
|
||||||
use std::str::FromStr;
|
|
||||||
|
|
||||||
use derive_more::{From, Into, IntoIterator};
|
|
||||||
use serde::{Deserialize, Serialize};
|
|
||||||
use strum::{EnumMessage, IntoEnumIterator};
|
|
||||||
|
|
||||||
use super::CapabilityKind;
|
|
||||||
|
|
||||||
/// Set of supported capabilities for a server
|
|
||||||
#[derive(Clone, Debug, From, Into, PartialEq, Eq, IntoIterator, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
#[serde(transparent)]
|
|
||||||
pub struct Capabilities(#[into_iterator(owned, ref)] HashSet<Capability>);
|
|
||||||
|
|
||||||
impl Capabilities {
|
|
||||||
/// Return set of capabilities encompassing all possible capabilities
|
|
||||||
pub fn all() -> Self {
|
|
||||||
Self(CapabilityKind::iter().map(Capability::from).collect())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Return empty set of capabilities
|
|
||||||
pub fn none() -> Self {
|
|
||||||
Self(HashSet::new())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns true if the capability with described kind is included
|
|
||||||
pub fn contains(&self, kind: impl AsRef<str>) -> bool {
|
|
||||||
let cap = Capability {
|
|
||||||
kind: kind.as_ref().to_string(),
|
|
||||||
description: String::new(),
|
|
||||||
};
|
|
||||||
self.0.contains(&cap)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Adds the specified capability to the set of capabilities
|
|
||||||
///
|
|
||||||
/// * If the set did not have this capability, returns `true`
|
|
||||||
/// * If the set did have this capability, returns `false`
|
|
||||||
pub fn insert(&mut self, cap: impl Into<Capability>) -> bool {
|
|
||||||
self.0.insert(cap.into())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Removes the capability with the described kind, returning the capability
|
|
||||||
pub fn take(&mut self, kind: impl AsRef<str>) -> Option<Capability> {
|
|
||||||
let cap = Capability {
|
|
||||||
kind: kind.as_ref().to_string(),
|
|
||||||
description: String::new(),
|
|
||||||
};
|
|
||||||
self.0.take(&cap)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Removes the capability with the described kind, returning true if it existed
|
|
||||||
pub fn remove(&mut self, kind: impl AsRef<str>) -> bool {
|
|
||||||
let cap = Capability {
|
|
||||||
kind: kind.as_ref().to_string(),
|
|
||||||
description: String::new(),
|
|
||||||
};
|
|
||||||
self.0.remove(&cap)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Converts into vec of capabilities sorted by kind
|
|
||||||
pub fn into_sorted_vec(self) -> Vec<Capability> {
|
|
||||||
let mut this = self.0.into_iter().collect::<Vec<_>>();
|
|
||||||
|
|
||||||
this.sort_unstable();
|
|
||||||
|
|
||||||
this
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl Capabilities {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(Capabilities)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl BitAnd for &Capabilities {
|
|
||||||
type Output = Capabilities;
|
|
||||||
|
|
||||||
fn bitand(self, rhs: Self) -> Self::Output {
|
|
||||||
Capabilities(self.0.bitand(&rhs.0))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl BitOr for &Capabilities {
|
|
||||||
type Output = Capabilities;
|
|
||||||
|
|
||||||
fn bitor(self, rhs: Self) -> Self::Output {
|
|
||||||
Capabilities(self.0.bitor(&rhs.0))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl BitOr<Capability> for &Capabilities {
|
|
||||||
type Output = Capabilities;
|
|
||||||
|
|
||||||
fn bitor(self, rhs: Capability) -> Self::Output {
|
|
||||||
let mut other = Capabilities::none();
|
|
||||||
other.0.insert(rhs);
|
|
||||||
|
|
||||||
self.bitor(&other)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl BitXor for &Capabilities {
|
|
||||||
type Output = Capabilities;
|
|
||||||
|
|
||||||
fn bitxor(self, rhs: Self) -> Self::Output {
|
|
||||||
Capabilities(self.0.bitxor(&rhs.0))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl FromIterator<Capability> for Capabilities {
|
|
||||||
fn from_iter<I: IntoIterator<Item = Capability>>(iter: I) -> Self {
|
|
||||||
let mut this = Capabilities::none();
|
|
||||||
|
|
||||||
for capability in iter {
|
|
||||||
this.0.insert(capability);
|
|
||||||
}
|
|
||||||
|
|
||||||
this
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Capability tied to a server. A capability is equivalent based on its kind and not description.
|
|
||||||
#[derive(Clone, Debug, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
#[serde(rename_all = "snake_case", deny_unknown_fields)]
|
|
||||||
pub struct Capability {
|
|
||||||
/// Label describing the kind of capability
|
|
||||||
pub kind: String,
|
|
||||||
|
|
||||||
/// Information about the capability
|
|
||||||
pub description: String,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Capability {
|
|
||||||
/// Will convert the [`Capability`]'s `kind` into a known [`CapabilityKind`] if possible,
|
|
||||||
/// returning None if the capability is unknown
|
|
||||||
pub fn to_capability_kind(&self) -> Option<CapabilityKind> {
|
|
||||||
CapabilityKind::from_str(&self.kind).ok()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns true if the described capability is unknown
|
|
||||||
pub fn is_unknown(&self) -> bool {
|
|
||||||
self.to_capability_kind().is_none()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl PartialEq for Capability {
|
|
||||||
fn eq(&self, other: &Self) -> bool {
|
|
||||||
self.kind.eq_ignore_ascii_case(&other.kind)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Eq for Capability {}
|
|
||||||
|
|
||||||
impl PartialOrd for Capability {
|
|
||||||
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
|
||||||
Some(self.cmp(other))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Ord for Capability {
|
|
||||||
fn cmp(&self, other: &Self) -> Ordering {
|
|
||||||
self.kind
|
|
||||||
.to_ascii_lowercase()
|
|
||||||
.cmp(&other.kind.to_ascii_lowercase())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Hash for Capability {
|
|
||||||
fn hash<H: Hasher>(&self, state: &mut H) {
|
|
||||||
self.kind.to_ascii_lowercase().hash(state);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<CapabilityKind> for Capability {
|
|
||||||
/// Creates a new capability using the kind's default message
|
|
||||||
fn from(kind: CapabilityKind) -> Self {
|
|
||||||
Self {
|
|
||||||
kind: kind.to_string(),
|
|
||||||
description: kind
|
|
||||||
.get_message()
|
|
||||||
.map(ToString::to_string)
|
|
||||||
.unwrap_or_default(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl Capability {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(Capability)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl CapabilityKind {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(CapabilityKind)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,516 +0,0 @@
|
|||||||
use std::collections::HashSet;
|
|
||||||
use std::fmt;
|
|
||||||
use std::hash::{Hash, Hasher};
|
|
||||||
use std::iter::FromIterator;
|
|
||||||
use std::ops::{BitOr, Sub};
|
|
||||||
use std::path::PathBuf;
|
|
||||||
use std::str::FromStr;
|
|
||||||
|
|
||||||
use derive_more::{Deref, DerefMut, IntoIterator};
|
|
||||||
use notify::event::Event as NotifyEvent;
|
|
||||||
use notify::EventKind as NotifyEventKind;
|
|
||||||
use serde::{Deserialize, Serialize};
|
|
||||||
use strum::{EnumString, EnumVariantNames, VariantNames};
|
|
||||||
|
|
||||||
/// Change to one or more paths on the filesystem
|
|
||||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
#[serde(rename_all = "snake_case", deny_unknown_fields)]
|
|
||||||
pub struct Change {
|
|
||||||
/// Label describing the kind of change
|
|
||||||
pub kind: ChangeKind,
|
|
||||||
|
|
||||||
/// Paths that were changed
|
|
||||||
pub paths: Vec<PathBuf>,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl Change {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(Change)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<NotifyEvent> for Change {
|
|
||||||
fn from(x: NotifyEvent) -> Self {
|
|
||||||
Self {
|
|
||||||
kind: x.kind.into(),
|
|
||||||
paths: x.paths,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(
|
|
||||||
Copy,
|
|
||||||
Clone,
|
|
||||||
Debug,
|
|
||||||
strum::Display,
|
|
||||||
EnumString,
|
|
||||||
EnumVariantNames,
|
|
||||||
Hash,
|
|
||||||
PartialEq,
|
|
||||||
Eq,
|
|
||||||
PartialOrd,
|
|
||||||
Ord,
|
|
||||||
Serialize,
|
|
||||||
Deserialize,
|
|
||||||
)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
#[serde(rename_all = "snake_case", deny_unknown_fields)]
|
|
||||||
#[strum(serialize_all = "snake_case")]
|
|
||||||
pub enum ChangeKind {
|
|
||||||
/// Something about a file or directory was accessed, but
|
|
||||||
/// no specific details were known
|
|
||||||
Access,
|
|
||||||
|
|
||||||
/// A file was closed for executing
|
|
||||||
AccessCloseExecute,
|
|
||||||
|
|
||||||
/// A file was closed for reading
|
|
||||||
AccessCloseRead,
|
|
||||||
|
|
||||||
/// A file was closed for writing
|
|
||||||
AccessCloseWrite,
|
|
||||||
|
|
||||||
/// A file was opened for executing
|
|
||||||
AccessOpenExecute,
|
|
||||||
|
|
||||||
/// A file was opened for reading
|
|
||||||
AccessOpenRead,
|
|
||||||
|
|
||||||
/// A file was opened for writing
|
|
||||||
AccessOpenWrite,
|
|
||||||
|
|
||||||
/// A file or directory was read
|
|
||||||
AccessRead,
|
|
||||||
|
|
||||||
/// The access time of a file or directory was changed
|
|
||||||
AccessTime,
|
|
||||||
|
|
||||||
/// A file, directory, or something else was created
|
|
||||||
Create,
|
|
||||||
|
|
||||||
/// The content of a file or directory changed
|
|
||||||
Content,
|
|
||||||
|
|
||||||
/// The data of a file or directory was modified, but
|
|
||||||
/// no specific details were known
|
|
||||||
Data,
|
|
||||||
|
|
||||||
/// The metadata of a file or directory was modified, but
|
|
||||||
/// no specific details were known
|
|
||||||
Metadata,
|
|
||||||
|
|
||||||
/// Something about a file or directory was modified, but
|
|
||||||
/// no specific details were known
|
|
||||||
Modify,
|
|
||||||
|
|
||||||
/// A file, directory, or something else was removed
|
|
||||||
Remove,
|
|
||||||
|
|
||||||
/// A file or directory was renamed, but no specific details were known
|
|
||||||
Rename,
|
|
||||||
|
|
||||||
/// A file or directory was renamed, and the provided paths
|
|
||||||
/// are the source and target in that order (from, to)
|
|
||||||
RenameBoth,
|
|
||||||
|
|
||||||
/// A file or directory was renamed, and the provided path
|
|
||||||
/// is the origin of the rename (before being renamed)
|
|
||||||
RenameFrom,
|
|
||||||
|
|
||||||
/// A file or directory was renamed, and the provided path
|
|
||||||
/// is the result of the rename
|
|
||||||
RenameTo,
|
|
||||||
|
|
||||||
/// A file's size changed
|
|
||||||
Size,
|
|
||||||
|
|
||||||
/// The ownership of a file or directory was changed
|
|
||||||
Ownership,
|
|
||||||
|
|
||||||
/// The permissions of a file or directory was changed
|
|
||||||
Permissions,
|
|
||||||
|
|
||||||
/// The write or modify time of a file or directory was changed
|
|
||||||
WriteTime,
|
|
||||||
|
|
||||||
// Catchall in case we have no insight as to the type of change
|
|
||||||
Unknown,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl ChangeKind {
|
|
||||||
/// Returns a list of all variants as str names
|
|
||||||
pub const fn variants() -> &'static [&'static str] {
|
|
||||||
Self::VARIANTS
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns a list of all variants as a vec
|
|
||||||
pub fn all() -> Vec<ChangeKind> {
|
|
||||||
ChangeKindSet::all().into_sorted_vec()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns true if the change is a kind of access
|
|
||||||
pub fn is_access_kind(&self) -> bool {
|
|
||||||
self.is_open_access_kind()
|
|
||||||
|| self.is_close_access_kind()
|
|
||||||
|| matches!(self, Self::Access | Self::AccessRead)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns true if the change is a kind of open access
|
|
||||||
pub fn is_open_access_kind(&self) -> bool {
|
|
||||||
matches!(
|
|
||||||
self,
|
|
||||||
Self::AccessOpenExecute | Self::AccessOpenRead | Self::AccessOpenWrite
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns true if the change is a kind of close access
|
|
||||||
pub fn is_close_access_kind(&self) -> bool {
|
|
||||||
matches!(
|
|
||||||
self,
|
|
||||||
Self::AccessCloseExecute | Self::AccessCloseRead | Self::AccessCloseWrite
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns true if the change is a kind of creation
|
|
||||||
pub fn is_create_kind(&self) -> bool {
|
|
||||||
matches!(self, Self::Create)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns true if the change is a kind of modification
|
|
||||||
pub fn is_modify_kind(&self) -> bool {
|
|
||||||
self.is_data_modify_kind() || self.is_metadata_modify_kind() || matches!(self, Self::Modify)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns true if the change is a kind of data modification
|
|
||||||
pub fn is_data_modify_kind(&self) -> bool {
|
|
||||||
matches!(self, Self::Content | Self::Data | Self::Size)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns true if the change is a kind of metadata modification
|
|
||||||
pub fn is_metadata_modify_kind(&self) -> bool {
|
|
||||||
matches!(
|
|
||||||
self,
|
|
||||||
Self::AccessTime
|
|
||||||
| Self::Metadata
|
|
||||||
| Self::Ownership
|
|
||||||
| Self::Permissions
|
|
||||||
| Self::WriteTime
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns true if the change is a kind of rename
|
|
||||||
pub fn is_rename_kind(&self) -> bool {
|
|
||||||
matches!(
|
|
||||||
self,
|
|
||||||
Self::Rename | Self::RenameBoth | Self::RenameFrom | Self::RenameTo
|
|
||||||
)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns true if the change is a kind of removal
|
|
||||||
pub fn is_remove_kind(&self) -> bool {
|
|
||||||
matches!(self, Self::Remove)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns true if the change kind is unknown
|
|
||||||
pub fn is_unknown_kind(&self) -> bool {
|
|
||||||
matches!(self, Self::Unknown)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl ChangeKind {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(ChangeKind)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl BitOr for ChangeKind {
|
|
||||||
type Output = ChangeKindSet;
|
|
||||||
|
|
||||||
fn bitor(self, rhs: Self) -> Self::Output {
|
|
||||||
let mut set = ChangeKindSet::empty();
|
|
||||||
set.insert(self);
|
|
||||||
set.insert(rhs);
|
|
||||||
set
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<NotifyEventKind> for ChangeKind {
|
|
||||||
fn from(x: NotifyEventKind) -> Self {
|
|
||||||
use notify::event::{
|
|
||||||
AccessKind, AccessMode, DataChange, MetadataKind, ModifyKind, RenameMode,
|
|
||||||
};
|
|
||||||
match x {
|
|
||||||
// File/directory access events
|
|
||||||
NotifyEventKind::Access(AccessKind::Read) => Self::AccessRead,
|
|
||||||
NotifyEventKind::Access(AccessKind::Open(AccessMode::Execute)) => {
|
|
||||||
Self::AccessOpenExecute
|
|
||||||
}
|
|
||||||
NotifyEventKind::Access(AccessKind::Open(AccessMode::Read)) => Self::AccessOpenRead,
|
|
||||||
NotifyEventKind::Access(AccessKind::Open(AccessMode::Write)) => Self::AccessOpenWrite,
|
|
||||||
NotifyEventKind::Access(AccessKind::Close(AccessMode::Execute)) => {
|
|
||||||
Self::AccessCloseExecute
|
|
||||||
}
|
|
||||||
NotifyEventKind::Access(AccessKind::Close(AccessMode::Read)) => Self::AccessCloseRead,
|
|
||||||
NotifyEventKind::Access(AccessKind::Close(AccessMode::Write)) => Self::AccessCloseWrite,
|
|
||||||
NotifyEventKind::Access(_) => Self::Access,
|
|
||||||
|
|
||||||
// File/directory creation events
|
|
||||||
NotifyEventKind::Create(_) => Self::Create,
|
|
||||||
|
|
||||||
// Rename-oriented events
|
|
||||||
NotifyEventKind::Modify(ModifyKind::Name(RenameMode::Both)) => Self::RenameBoth,
|
|
||||||
NotifyEventKind::Modify(ModifyKind::Name(RenameMode::From)) => Self::RenameFrom,
|
|
||||||
NotifyEventKind::Modify(ModifyKind::Name(RenameMode::To)) => Self::RenameTo,
|
|
||||||
NotifyEventKind::Modify(ModifyKind::Name(_)) => Self::Rename,
|
|
||||||
|
|
||||||
// Data-modification events
|
|
||||||
NotifyEventKind::Modify(ModifyKind::Data(DataChange::Content)) => Self::Content,
|
|
||||||
NotifyEventKind::Modify(ModifyKind::Data(DataChange::Size)) => Self::Size,
|
|
||||||
NotifyEventKind::Modify(ModifyKind::Data(_)) => Self::Data,
|
|
||||||
|
|
||||||
// Metadata-modification events
|
|
||||||
NotifyEventKind::Modify(ModifyKind::Metadata(MetadataKind::AccessTime)) => {
|
|
||||||
Self::AccessTime
|
|
||||||
}
|
|
||||||
NotifyEventKind::Modify(ModifyKind::Metadata(MetadataKind::WriteTime)) => {
|
|
||||||
Self::WriteTime
|
|
||||||
}
|
|
||||||
NotifyEventKind::Modify(ModifyKind::Metadata(MetadataKind::Permissions)) => {
|
|
||||||
Self::Permissions
|
|
||||||
}
|
|
||||||
NotifyEventKind::Modify(ModifyKind::Metadata(MetadataKind::Ownership)) => {
|
|
||||||
Self::Ownership
|
|
||||||
}
|
|
||||||
NotifyEventKind::Modify(ModifyKind::Metadata(_)) => Self::Metadata,
|
|
||||||
|
|
||||||
// General modification events
|
|
||||||
NotifyEventKind::Modify(_) => Self::Modify,
|
|
||||||
|
|
||||||
// File/directory removal events
|
|
||||||
NotifyEventKind::Remove(_) => Self::Remove,
|
|
||||||
|
|
||||||
// Catch-all for other events
|
|
||||||
NotifyEventKind::Any | NotifyEventKind::Other => Self::Unknown,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Represents a distinct set of different change kinds
|
|
||||||
#[derive(Clone, Debug, Deref, DerefMut, IntoIterator, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
pub struct ChangeKindSet(HashSet<ChangeKind>);
|
|
||||||
|
|
||||||
impl ChangeKindSet {
|
|
||||||
/// Produces an empty set of [`ChangeKind`]
|
|
||||||
pub fn empty() -> Self {
|
|
||||||
Self(HashSet::new())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Produces a set of all [`ChangeKind`]
|
|
||||||
pub fn all() -> Self {
|
|
||||||
vec![
|
|
||||||
ChangeKind::Access,
|
|
||||||
ChangeKind::AccessCloseExecute,
|
|
||||||
ChangeKind::AccessCloseRead,
|
|
||||||
ChangeKind::AccessCloseWrite,
|
|
||||||
ChangeKind::AccessOpenExecute,
|
|
||||||
ChangeKind::AccessOpenRead,
|
|
||||||
ChangeKind::AccessOpenWrite,
|
|
||||||
ChangeKind::AccessRead,
|
|
||||||
ChangeKind::AccessTime,
|
|
||||||
ChangeKind::Create,
|
|
||||||
ChangeKind::Content,
|
|
||||||
ChangeKind::Data,
|
|
||||||
ChangeKind::Metadata,
|
|
||||||
ChangeKind::Modify,
|
|
||||||
ChangeKind::Remove,
|
|
||||||
ChangeKind::Rename,
|
|
||||||
ChangeKind::RenameBoth,
|
|
||||||
ChangeKind::RenameFrom,
|
|
||||||
ChangeKind::RenameTo,
|
|
||||||
ChangeKind::Size,
|
|
||||||
ChangeKind::Ownership,
|
|
||||||
ChangeKind::Permissions,
|
|
||||||
ChangeKind::WriteTime,
|
|
||||||
ChangeKind::Unknown,
|
|
||||||
]
|
|
||||||
.into_iter()
|
|
||||||
.collect()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Produces a changeset containing all of the access kinds
|
|
||||||
pub fn access_set() -> Self {
|
|
||||||
Self::access_open_set()
|
|
||||||
| Self::access_close_set()
|
|
||||||
| ChangeKind::AccessRead
|
|
||||||
| ChangeKind::Access
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Produces a changeset containing all of the open access kinds
|
|
||||||
pub fn access_open_set() -> Self {
|
|
||||||
ChangeKind::AccessOpenExecute | ChangeKind::AccessOpenRead | ChangeKind::AccessOpenWrite
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Produces a changeset containing all of the close access kinds
|
|
||||||
pub fn access_close_set() -> Self {
|
|
||||||
ChangeKind::AccessCloseExecute | ChangeKind::AccessCloseRead | ChangeKind::AccessCloseWrite
|
|
||||||
}
|
|
||||||
|
|
||||||
// Produces a changeset containing all of the modification kinds
|
|
||||||
pub fn modify_set() -> Self {
|
|
||||||
Self::modify_data_set() | Self::modify_metadata_set() | ChangeKind::Modify
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Produces a changeset containing all of the data modification kinds
|
|
||||||
pub fn modify_data_set() -> Self {
|
|
||||||
ChangeKind::Content | ChangeKind::Data | ChangeKind::Size
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Produces a changeset containing all of the metadata modification kinds
|
|
||||||
pub fn modify_metadata_set() -> Self {
|
|
||||||
ChangeKind::AccessTime
|
|
||||||
| ChangeKind::Metadata
|
|
||||||
| ChangeKind::Ownership
|
|
||||||
| ChangeKind::Permissions
|
|
||||||
| ChangeKind::WriteTime
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Produces a changeset containing all of the rename kinds
|
|
||||||
pub fn rename_set() -> Self {
|
|
||||||
ChangeKind::Rename | ChangeKind::RenameBoth | ChangeKind::RenameFrom | ChangeKind::RenameTo
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Consumes set and returns a sorted vec of the kinds of changes
|
|
||||||
pub fn into_sorted_vec(self) -> Vec<ChangeKind> {
|
|
||||||
let mut v = self.0.into_iter().collect::<Vec<_>>();
|
|
||||||
v.sort();
|
|
||||||
v
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl ChangeKindSet {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(ChangeKindSet)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl fmt::Display for ChangeKindSet {
|
|
||||||
/// Outputs a comma-separated series of [`ChangeKind`] as string that are sorted
|
|
||||||
/// such that this will always be consistent output
|
|
||||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
||||||
let mut kinds = self
|
|
||||||
.0
|
|
||||||
.iter()
|
|
||||||
.map(ToString::to_string)
|
|
||||||
.collect::<Vec<String>>();
|
|
||||||
kinds.sort_unstable();
|
|
||||||
write!(f, "{}", kinds.join(","))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl PartialEq for ChangeKindSet {
|
|
||||||
fn eq(&self, other: &Self) -> bool {
|
|
||||||
self.to_string() == other.to_string()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Eq for ChangeKindSet {}
|
|
||||||
|
|
||||||
impl Hash for ChangeKindSet {
|
|
||||||
/// Hashes based on the output of [`fmt::Display`]
|
|
||||||
fn hash<H: Hasher>(&self, state: &mut H) {
|
|
||||||
self.to_string().hash(state);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl BitOr<ChangeKindSet> for ChangeKindSet {
|
|
||||||
type Output = Self;
|
|
||||||
|
|
||||||
fn bitor(mut self, rhs: ChangeKindSet) -> Self::Output {
|
|
||||||
self.extend(rhs.0);
|
|
||||||
self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl BitOr<ChangeKind> for ChangeKindSet {
|
|
||||||
type Output = Self;
|
|
||||||
|
|
||||||
fn bitor(mut self, rhs: ChangeKind) -> Self::Output {
|
|
||||||
self.0.insert(rhs);
|
|
||||||
self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl BitOr<ChangeKindSet> for ChangeKind {
|
|
||||||
type Output = ChangeKindSet;
|
|
||||||
|
|
||||||
fn bitor(self, rhs: ChangeKindSet) -> Self::Output {
|
|
||||||
rhs | self
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Sub<ChangeKindSet> for ChangeKindSet {
|
|
||||||
type Output = Self;
|
|
||||||
|
|
||||||
fn sub(self, other: Self) -> Self::Output {
|
|
||||||
ChangeKindSet(&self.0 - &other.0)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Sub<&'_ ChangeKindSet> for &ChangeKindSet {
|
|
||||||
type Output = ChangeKindSet;
|
|
||||||
|
|
||||||
fn sub(self, other: &ChangeKindSet) -> Self::Output {
|
|
||||||
ChangeKindSet(&self.0 - &other.0)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl FromStr for ChangeKindSet {
|
|
||||||
type Err = strum::ParseError;
|
|
||||||
|
|
||||||
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
||||||
let mut change_set = HashSet::new();
|
|
||||||
|
|
||||||
for word in s.split(',') {
|
|
||||||
change_set.insert(ChangeKind::from_str(word.trim())?);
|
|
||||||
}
|
|
||||||
|
|
||||||
Ok(ChangeKindSet(change_set))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl FromIterator<ChangeKind> for ChangeKindSet {
|
|
||||||
fn from_iter<I: IntoIterator<Item = ChangeKind>>(iter: I) -> Self {
|
|
||||||
let mut change_set = HashSet::new();
|
|
||||||
|
|
||||||
for i in iter {
|
|
||||||
change_set.insert(i);
|
|
||||||
}
|
|
||||||
|
|
||||||
ChangeKindSet(change_set)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<ChangeKind> for ChangeKindSet {
|
|
||||||
fn from(change_kind: ChangeKind) -> Self {
|
|
||||||
let mut set = Self::empty();
|
|
||||||
set.insert(change_kind);
|
|
||||||
set
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<Vec<ChangeKind>> for ChangeKindSet {
|
|
||||||
fn from(changes: Vec<ChangeKind>) -> Self {
|
|
||||||
changes.into_iter().collect()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Default for ChangeKindSet {
|
|
||||||
fn default() -> Self {
|
|
||||||
Self::empty()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,53 +0,0 @@
|
|||||||
use std::ops::{Deref, DerefMut};
|
|
||||||
|
|
||||||
use derive_more::{Display, From, Into};
|
|
||||||
use serde::{Deserialize, Serialize};
|
|
||||||
|
|
||||||
/// Represents some command with arguments to execute
|
|
||||||
#[derive(Clone, Debug, Display, From, Into, Hash, PartialEq, Eq, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
pub struct Cmd(String);
|
|
||||||
|
|
||||||
impl Cmd {
|
|
||||||
/// Creates a new command from the given `cmd`
|
|
||||||
pub fn new(cmd: impl Into<String>) -> Self {
|
|
||||||
Self(cmd.into())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns reference to the program portion of the command
|
|
||||||
pub fn program(&self) -> &str {
|
|
||||||
match self.0.split_once(' ') {
|
|
||||||
Some((program, _)) => program.trim(),
|
|
||||||
None => self.0.trim(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns reference to the arguments portion of the command
|
|
||||||
pub fn arguments(&self) -> &str {
|
|
||||||
match self.0.split_once(' ') {
|
|
||||||
Some((_, arguments)) => arguments.trim(),
|
|
||||||
None => "",
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl Cmd {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(Cmd)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Deref for Cmd {
|
|
||||||
type Target = String;
|
|
||||||
|
|
||||||
fn deref(&self) -> &Self::Target {
|
|
||||||
&self.0
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl DerefMut for Cmd {
|
|
||||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
||||||
&mut self.0
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,59 +0,0 @@
|
|||||||
use std::fs::FileType as StdFileType;
|
|
||||||
use std::path::PathBuf;
|
|
||||||
|
|
||||||
use derive_more::IsVariant;
|
|
||||||
use serde::{Deserialize, Serialize};
|
|
||||||
use strum::AsRefStr;
|
|
||||||
|
|
||||||
/// Represents information about a single entry within a directory
|
|
||||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
#[serde(rename_all = "snake_case", deny_unknown_fields)]
|
|
||||||
pub struct DirEntry {
|
|
||||||
/// Represents the full path to the entry
|
|
||||||
pub path: PathBuf,
|
|
||||||
|
|
||||||
/// Represents the type of the entry as a file/dir/symlink
|
|
||||||
pub file_type: FileType,
|
|
||||||
|
|
||||||
/// Depth at which this entry was created relative to the root (0 being immediately within
|
|
||||||
/// root)
|
|
||||||
pub depth: usize,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl DirEntry {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(DirEntry)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Represents the type associated with a dir entry
|
|
||||||
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, AsRefStr, IsVariant, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
#[serde(rename_all = "snake_case", deny_unknown_fields)]
|
|
||||||
#[strum(serialize_all = "snake_case")]
|
|
||||||
pub enum FileType {
|
|
||||||
Dir,
|
|
||||||
File,
|
|
||||||
Symlink,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<StdFileType> for FileType {
|
|
||||||
fn from(ft: StdFileType) -> Self {
|
|
||||||
if ft.is_dir() {
|
|
||||||
Self::Dir
|
|
||||||
} else if ft.is_symlink() {
|
|
||||||
Self::Symlink
|
|
||||||
} else {
|
|
||||||
Self::File
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl FileType {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(FileType)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,404 +0,0 @@
|
|||||||
use std::io;
|
|
||||||
use std::path::{Path, PathBuf};
|
|
||||||
use std::time::SystemTime;
|
|
||||||
|
|
||||||
use bitflags::bitflags;
|
|
||||||
use serde::{Deserialize, Serialize};
|
|
||||||
|
|
||||||
use super::{deserialize_u128_option, serialize_u128_option, FileType};
|
|
||||||
|
|
||||||
/// Represents metadata about some path on a remote machine
|
|
||||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
pub struct Metadata {
|
|
||||||
/// Canonicalized path to the file or directory, resolving symlinks, only included
|
|
||||||
/// if flagged during the request
|
|
||||||
pub canonicalized_path: Option<PathBuf>,
|
|
||||||
|
|
||||||
/// Represents the type of the entry as a file/dir/symlink
|
|
||||||
pub file_type: FileType,
|
|
||||||
|
|
||||||
/// Size of the file/directory/symlink in bytes
|
|
||||||
pub len: u64,
|
|
||||||
|
|
||||||
/// Whether or not the file/directory/symlink is marked as unwriteable
|
|
||||||
pub readonly: bool,
|
|
||||||
|
|
||||||
/// Represents the last time (in milliseconds) when the file/directory/symlink was accessed;
|
|
||||||
/// can be optional as certain systems don't support this
|
|
||||||
#[serde(serialize_with = "serialize_u128_option")]
|
|
||||||
#[serde(deserialize_with = "deserialize_u128_option")]
|
|
||||||
pub accessed: Option<u128>,
|
|
||||||
|
|
||||||
/// Represents when (in milliseconds) the file/directory/symlink was created;
|
|
||||||
/// can be optional as certain systems don't support this
|
|
||||||
#[serde(serialize_with = "serialize_u128_option")]
|
|
||||||
#[serde(deserialize_with = "deserialize_u128_option")]
|
|
||||||
pub created: Option<u128>,
|
|
||||||
|
|
||||||
/// Represents the last time (in milliseconds) when the file/directory/symlink was modified;
|
|
||||||
/// can be optional as certain systems don't support this
|
|
||||||
#[serde(serialize_with = "serialize_u128_option")]
|
|
||||||
#[serde(deserialize_with = "deserialize_u128_option")]
|
|
||||||
pub modified: Option<u128>,
|
|
||||||
|
|
||||||
/// Represents metadata that is specific to a unix remote machine
|
|
||||||
pub unix: Option<UnixMetadata>,
|
|
||||||
|
|
||||||
/// Represents metadata that is specific to a windows remote machine
|
|
||||||
pub windows: Option<WindowsMetadata>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Metadata {
|
|
||||||
pub async fn read(
|
|
||||||
path: impl AsRef<Path>,
|
|
||||||
canonicalize: bool,
|
|
||||||
resolve_file_type: bool,
|
|
||||||
) -> io::Result<Self> {
|
|
||||||
let metadata = tokio::fs::symlink_metadata(path.as_ref()).await?;
|
|
||||||
let canonicalized_path = if canonicalize {
|
|
||||||
Some(tokio::fs::canonicalize(path.as_ref()).await?)
|
|
||||||
} else {
|
|
||||||
None
|
|
||||||
};
|
|
||||||
|
|
||||||
// If asking for resolved file type and current type is symlink, then we want to refresh
|
|
||||||
// our metadata to get the filetype for the resolved link
|
|
||||||
let file_type = if resolve_file_type && metadata.file_type().is_symlink() {
|
|
||||||
tokio::fs::metadata(path).await?.file_type()
|
|
||||||
} else {
|
|
||||||
metadata.file_type()
|
|
||||||
};
|
|
||||||
|
|
||||||
Ok(Self {
|
|
||||||
canonicalized_path,
|
|
||||||
accessed: metadata
|
|
||||||
.accessed()
|
|
||||||
.ok()
|
|
||||||
.and_then(|t| t.duration_since(SystemTime::UNIX_EPOCH).ok())
|
|
||||||
.map(|d| d.as_millis()),
|
|
||||||
created: metadata
|
|
||||||
.created()
|
|
||||||
.ok()
|
|
||||||
.and_then(|t| t.duration_since(SystemTime::UNIX_EPOCH).ok())
|
|
||||||
.map(|d| d.as_millis()),
|
|
||||||
modified: metadata
|
|
||||||
.modified()
|
|
||||||
.ok()
|
|
||||||
.and_then(|t| t.duration_since(SystemTime::UNIX_EPOCH).ok())
|
|
||||||
.map(|d| d.as_millis()),
|
|
||||||
len: metadata.len(),
|
|
||||||
readonly: metadata.permissions().readonly(),
|
|
||||||
file_type: if file_type.is_dir() {
|
|
||||||
FileType::Dir
|
|
||||||
} else if file_type.is_file() {
|
|
||||||
FileType::File
|
|
||||||
} else {
|
|
||||||
FileType::Symlink
|
|
||||||
},
|
|
||||||
|
|
||||||
#[cfg(unix)]
|
|
||||||
unix: Some({
|
|
||||||
use std::os::unix::prelude::*;
|
|
||||||
let mode = metadata.mode();
|
|
||||||
crate::protocol::UnixMetadata::from(mode)
|
|
||||||
}),
|
|
||||||
#[cfg(not(unix))]
|
|
||||||
unix: None,
|
|
||||||
|
|
||||||
#[cfg(windows)]
|
|
||||||
windows: Some({
|
|
||||||
use std::os::windows::prelude::*;
|
|
||||||
let attributes = metadata.file_attributes();
|
|
||||||
crate::protocol::WindowsMetadata::from(attributes)
|
|
||||||
}),
|
|
||||||
#[cfg(not(windows))]
|
|
||||||
windows: None,
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl Metadata {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(Metadata)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Represents unix-specific metadata about some path on a remote machine
|
|
||||||
#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
pub struct UnixMetadata {
|
|
||||||
/// Represents whether or not owner can read from the file
|
|
||||||
pub owner_read: bool,
|
|
||||||
|
|
||||||
/// Represents whether or not owner can write to the file
|
|
||||||
pub owner_write: bool,
|
|
||||||
|
|
||||||
/// Represents whether or not owner can execute the file
|
|
||||||
pub owner_exec: bool,
|
|
||||||
|
|
||||||
/// Represents whether or not associated group can read from the file
|
|
||||||
pub group_read: bool,
|
|
||||||
|
|
||||||
/// Represents whether or not associated group can write to the file
|
|
||||||
pub group_write: bool,
|
|
||||||
|
|
||||||
/// Represents whether or not associated group can execute the file
|
|
||||||
pub group_exec: bool,
|
|
||||||
|
|
||||||
/// Represents whether or not other can read from the file
|
|
||||||
pub other_read: bool,
|
|
||||||
|
|
||||||
/// Represents whether or not other can write to the file
|
|
||||||
pub other_write: bool,
|
|
||||||
|
|
||||||
/// Represents whether or not other can execute the file
|
|
||||||
pub other_exec: bool,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl UnixMetadata {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(UnixMetadata)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<u32> for UnixMetadata {
|
|
||||||
/// Create from a unix mode bitset
|
|
||||||
fn from(mode: u32) -> Self {
|
|
||||||
let flags = UnixFilePermissionFlags::from_bits_truncate(mode);
|
|
||||||
Self {
|
|
||||||
owner_read: flags.contains(UnixFilePermissionFlags::OWNER_READ),
|
|
||||||
owner_write: flags.contains(UnixFilePermissionFlags::OWNER_WRITE),
|
|
||||||
owner_exec: flags.contains(UnixFilePermissionFlags::OWNER_EXEC),
|
|
||||||
group_read: flags.contains(UnixFilePermissionFlags::GROUP_READ),
|
|
||||||
group_write: flags.contains(UnixFilePermissionFlags::GROUP_WRITE),
|
|
||||||
group_exec: flags.contains(UnixFilePermissionFlags::GROUP_EXEC),
|
|
||||||
other_read: flags.contains(UnixFilePermissionFlags::OTHER_READ),
|
|
||||||
other_write: flags.contains(UnixFilePermissionFlags::OTHER_WRITE),
|
|
||||||
other_exec: flags.contains(UnixFilePermissionFlags::OTHER_EXEC),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<UnixMetadata> for u32 {
|
|
||||||
/// Convert to a unix mode bitset
|
|
||||||
fn from(metadata: UnixMetadata) -> Self {
|
|
||||||
let mut flags = UnixFilePermissionFlags::empty();
|
|
||||||
|
|
||||||
if metadata.owner_read {
|
|
||||||
flags.insert(UnixFilePermissionFlags::OWNER_READ);
|
|
||||||
}
|
|
||||||
if metadata.owner_write {
|
|
||||||
flags.insert(UnixFilePermissionFlags::OWNER_WRITE);
|
|
||||||
}
|
|
||||||
if metadata.owner_exec {
|
|
||||||
flags.insert(UnixFilePermissionFlags::OWNER_EXEC);
|
|
||||||
}
|
|
||||||
|
|
||||||
if metadata.group_read {
|
|
||||||
flags.insert(UnixFilePermissionFlags::GROUP_READ);
|
|
||||||
}
|
|
||||||
if metadata.group_write {
|
|
||||||
flags.insert(UnixFilePermissionFlags::GROUP_WRITE);
|
|
||||||
}
|
|
||||||
if metadata.group_exec {
|
|
||||||
flags.insert(UnixFilePermissionFlags::GROUP_EXEC);
|
|
||||||
}
|
|
||||||
|
|
||||||
if metadata.other_read {
|
|
||||||
flags.insert(UnixFilePermissionFlags::OTHER_READ);
|
|
||||||
}
|
|
||||||
if metadata.other_write {
|
|
||||||
flags.insert(UnixFilePermissionFlags::OTHER_WRITE);
|
|
||||||
}
|
|
||||||
if metadata.other_exec {
|
|
||||||
flags.insert(UnixFilePermissionFlags::OTHER_EXEC);
|
|
||||||
}
|
|
||||||
|
|
||||||
flags.bits()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl UnixMetadata {
|
|
||||||
pub fn is_readonly(self) -> bool {
|
|
||||||
!(self.owner_read || self.group_read || self.other_read)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
bitflags! {
|
|
||||||
struct UnixFilePermissionFlags: u32 {
|
|
||||||
const OWNER_READ = 0o400;
|
|
||||||
const OWNER_WRITE = 0o200;
|
|
||||||
const OWNER_EXEC = 0o100;
|
|
||||||
const GROUP_READ = 0o40;
|
|
||||||
const GROUP_WRITE = 0o20;
|
|
||||||
const GROUP_EXEC = 0o10;
|
|
||||||
const OTHER_READ = 0o4;
|
|
||||||
const OTHER_WRITE = 0o2;
|
|
||||||
const OTHER_EXEC = 0o1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Represents windows-specific metadata about some path on a remote machine
|
|
||||||
#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
pub struct WindowsMetadata {
|
|
||||||
/// Represents whether or not a file or directory is an archive
|
|
||||||
pub archive: bool,
|
|
||||||
|
|
||||||
/// Represents whether or not a file or directory is compressed
|
|
||||||
pub compressed: bool,
|
|
||||||
|
|
||||||
/// Represents whether or not the file or directory is encrypted
|
|
||||||
pub encrypted: bool,
|
|
||||||
|
|
||||||
/// Represents whether or not a file or directory is hidden
|
|
||||||
pub hidden: bool,
|
|
||||||
|
|
||||||
/// Represents whether or not a directory or user data stream is configured with integrity
|
|
||||||
pub integrity_stream: bool,
|
|
||||||
|
|
||||||
/// Represents whether or not a file does not have other attributes set
|
|
||||||
pub normal: bool,
|
|
||||||
|
|
||||||
/// Represents whether or not a file or directory is not to be indexed by content indexing
|
|
||||||
/// service
|
|
||||||
pub not_content_indexed: bool,
|
|
||||||
|
|
||||||
/// Represents whether or not a user data stream is not to be read by the background data
|
|
||||||
/// integrity scanner
|
|
||||||
pub no_scrub_data: bool,
|
|
||||||
|
|
||||||
/// Represents whether or not the data of a file is not available immediately
|
|
||||||
pub offline: bool,
|
|
||||||
|
|
||||||
/// Represents whether or not a file or directory is not fully present locally
|
|
||||||
pub recall_on_data_access: bool,
|
|
||||||
|
|
||||||
/// Represents whether or not a file or directory has no physical representation on the local
|
|
||||||
/// system (is virtual)
|
|
||||||
pub recall_on_open: bool,
|
|
||||||
|
|
||||||
/// Represents whether or not a file or directory has an associated reparse point, or a file is
|
|
||||||
/// a symbolic link
|
|
||||||
pub reparse_point: bool,
|
|
||||||
|
|
||||||
/// Represents whether or not a file is a sparse file
|
|
||||||
pub sparse_file: bool,
|
|
||||||
|
|
||||||
/// Represents whether or not a file or directory is used partially or exclusively by the
|
|
||||||
/// operating system
|
|
||||||
pub system: bool,
|
|
||||||
|
|
||||||
/// Represents whether or not a file is being used for temporary storage
|
|
||||||
pub temporary: bool,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl WindowsMetadata {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(WindowsMetadata)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<u32> for WindowsMetadata {
|
|
||||||
/// Create from a windows file attribute bitset
|
|
||||||
fn from(file_attributes: u32) -> Self {
|
|
||||||
let flags = WindowsFileAttributeFlags::from_bits_truncate(file_attributes);
|
|
||||||
Self {
|
|
||||||
archive: flags.contains(WindowsFileAttributeFlags::ARCHIVE),
|
|
||||||
compressed: flags.contains(WindowsFileAttributeFlags::COMPRESSED),
|
|
||||||
encrypted: flags.contains(WindowsFileAttributeFlags::ENCRYPTED),
|
|
||||||
hidden: flags.contains(WindowsFileAttributeFlags::HIDDEN),
|
|
||||||
integrity_stream: flags.contains(WindowsFileAttributeFlags::INTEGRITY_SYSTEM),
|
|
||||||
normal: flags.contains(WindowsFileAttributeFlags::NORMAL),
|
|
||||||
not_content_indexed: flags.contains(WindowsFileAttributeFlags::NOT_CONTENT_INDEXED),
|
|
||||||
no_scrub_data: flags.contains(WindowsFileAttributeFlags::NO_SCRUB_DATA),
|
|
||||||
offline: flags.contains(WindowsFileAttributeFlags::OFFLINE),
|
|
||||||
recall_on_data_access: flags.contains(WindowsFileAttributeFlags::RECALL_ON_DATA_ACCESS),
|
|
||||||
recall_on_open: flags.contains(WindowsFileAttributeFlags::RECALL_ON_OPEN),
|
|
||||||
reparse_point: flags.contains(WindowsFileAttributeFlags::REPARSE_POINT),
|
|
||||||
sparse_file: flags.contains(WindowsFileAttributeFlags::SPARSE_FILE),
|
|
||||||
system: flags.contains(WindowsFileAttributeFlags::SYSTEM),
|
|
||||||
temporary: flags.contains(WindowsFileAttributeFlags::TEMPORARY),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<WindowsMetadata> for u32 {
|
|
||||||
/// Convert to a windows file attribute bitset
|
|
||||||
fn from(metadata: WindowsMetadata) -> Self {
|
|
||||||
let mut flags = WindowsFileAttributeFlags::empty();
|
|
||||||
|
|
||||||
if metadata.archive {
|
|
||||||
flags.insert(WindowsFileAttributeFlags::ARCHIVE);
|
|
||||||
}
|
|
||||||
if metadata.compressed {
|
|
||||||
flags.insert(WindowsFileAttributeFlags::COMPRESSED);
|
|
||||||
}
|
|
||||||
if metadata.encrypted {
|
|
||||||
flags.insert(WindowsFileAttributeFlags::ENCRYPTED);
|
|
||||||
}
|
|
||||||
if metadata.hidden {
|
|
||||||
flags.insert(WindowsFileAttributeFlags::HIDDEN);
|
|
||||||
}
|
|
||||||
if metadata.integrity_stream {
|
|
||||||
flags.insert(WindowsFileAttributeFlags::INTEGRITY_SYSTEM);
|
|
||||||
}
|
|
||||||
if metadata.normal {
|
|
||||||
flags.insert(WindowsFileAttributeFlags::NORMAL);
|
|
||||||
}
|
|
||||||
if metadata.not_content_indexed {
|
|
||||||
flags.insert(WindowsFileAttributeFlags::NOT_CONTENT_INDEXED);
|
|
||||||
}
|
|
||||||
if metadata.no_scrub_data {
|
|
||||||
flags.insert(WindowsFileAttributeFlags::NO_SCRUB_DATA);
|
|
||||||
}
|
|
||||||
if metadata.offline {
|
|
||||||
flags.insert(WindowsFileAttributeFlags::OFFLINE);
|
|
||||||
}
|
|
||||||
if metadata.recall_on_data_access {
|
|
||||||
flags.insert(WindowsFileAttributeFlags::RECALL_ON_DATA_ACCESS);
|
|
||||||
}
|
|
||||||
if metadata.recall_on_open {
|
|
||||||
flags.insert(WindowsFileAttributeFlags::RECALL_ON_OPEN);
|
|
||||||
}
|
|
||||||
if metadata.reparse_point {
|
|
||||||
flags.insert(WindowsFileAttributeFlags::REPARSE_POINT);
|
|
||||||
}
|
|
||||||
if metadata.sparse_file {
|
|
||||||
flags.insert(WindowsFileAttributeFlags::SPARSE_FILE);
|
|
||||||
}
|
|
||||||
if metadata.system {
|
|
||||||
flags.insert(WindowsFileAttributeFlags::SYSTEM);
|
|
||||||
}
|
|
||||||
if metadata.temporary {
|
|
||||||
flags.insert(WindowsFileAttributeFlags::TEMPORARY);
|
|
||||||
}
|
|
||||||
|
|
||||||
flags.bits()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
bitflags! {
|
|
||||||
struct WindowsFileAttributeFlags: u32 {
|
|
||||||
const ARCHIVE = 0x20;
|
|
||||||
const COMPRESSED = 0x800;
|
|
||||||
const ENCRYPTED = 0x4000;
|
|
||||||
const HIDDEN = 0x2;
|
|
||||||
const INTEGRITY_SYSTEM = 0x8000;
|
|
||||||
const NORMAL = 0x80;
|
|
||||||
const NOT_CONTENT_INDEXED = 0x2000;
|
|
||||||
const NO_SCRUB_DATA = 0x20000;
|
|
||||||
const OFFLINE = 0x1000;
|
|
||||||
const RECALL_ON_DATA_ACCESS = 0x400000;
|
|
||||||
const RECALL_ON_OPEN = 0x40000;
|
|
||||||
const REPARSE_POINT = 0x400;
|
|
||||||
const SPARSE_FILE = 0x200;
|
|
||||||
const SYSTEM = 0x4;
|
|
||||||
const TEMPORARY = 0x100;
|
|
||||||
const VIRTUAL = 0x10000;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,294 +0,0 @@
|
|||||||
use bitflags::bitflags;
|
|
||||||
use serde::{Deserialize, Serialize};
|
|
||||||
|
|
||||||
#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
#[serde(default, deny_unknown_fields, rename_all = "snake_case")]
|
|
||||||
pub struct SetPermissionsOptions {
|
|
||||||
/// Whether or not to exclude symlinks from traversal entirely, meaning that permissions will
|
|
||||||
/// not be set on symlinks (usually resolving the symlink and setting the permission of the
|
|
||||||
/// referenced file or directory) that are explicitly provided or show up during recursion.
|
|
||||||
pub exclude_symlinks: bool,
|
|
||||||
|
|
||||||
/// Whether or not to traverse symlinks when recursively setting permissions. Note that this
|
|
||||||
/// does NOT influence setting permissions when encountering a symlink as most platforms will
|
|
||||||
/// resolve the symlink before setting permissions.
|
|
||||||
pub follow_symlinks: bool,
|
|
||||||
|
|
||||||
/// Whether or not to set the permissions of the file hierarchies rooted in the paths, instead
|
|
||||||
/// of just the paths themselves.
|
|
||||||
pub recursive: bool,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl SetPermissionsOptions {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(SetPermissionsOptions)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Represents permissions to apply to some path on a remote machine
|
|
||||||
///
|
|
||||||
/// When used to set permissions on a file, directory, or symlink,
|
|
||||||
/// only fields that are set (not `None`) will be applied.
|
|
||||||
///
|
|
||||||
/// On `Unix` platforms, this translates directly into the mode that
|
|
||||||
/// you would find with `chmod`. On all other platforms, this uses the
|
|
||||||
/// write flags to determine whether or not to set the readonly status.
|
|
||||||
#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
pub struct Permissions {
|
|
||||||
/// Represents whether or not owner can read from the file
|
|
||||||
pub owner_read: Option<bool>,
|
|
||||||
|
|
||||||
/// Represents whether or not owner can write to the file
|
|
||||||
pub owner_write: Option<bool>,
|
|
||||||
|
|
||||||
/// Represents whether or not owner can execute the file
|
|
||||||
pub owner_exec: Option<bool>,
|
|
||||||
|
|
||||||
/// Represents whether or not associated group can read from the file
|
|
||||||
pub group_read: Option<bool>,
|
|
||||||
|
|
||||||
/// Represents whether or not associated group can write to the file
|
|
||||||
pub group_write: Option<bool>,
|
|
||||||
|
|
||||||
/// Represents whether or not associated group can execute the file
|
|
||||||
pub group_exec: Option<bool>,
|
|
||||||
|
|
||||||
/// Represents whether or not other can read from the file
|
|
||||||
pub other_read: Option<bool>,
|
|
||||||
|
|
||||||
/// Represents whether or not other can write to the file
|
|
||||||
pub other_write: Option<bool>,
|
|
||||||
|
|
||||||
/// Represents whether or not other can execute the file
|
|
||||||
pub other_exec: Option<bool>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Permissions {
|
|
||||||
/// Creates a set of [`Permissions`] that indicate readonly status.
|
|
||||||
///
|
|
||||||
/// ```
|
|
||||||
/// use distant_core::protocol::Permissions;
|
|
||||||
///
|
|
||||||
/// let permissions = Permissions::readonly();
|
|
||||||
/// assert_eq!(permissions.is_readonly(), Some(true));
|
|
||||||
/// assert_eq!(permissions.is_writable(), Some(false));
|
|
||||||
/// ```
|
|
||||||
pub fn readonly() -> Self {
|
|
||||||
Self {
|
|
||||||
owner_write: Some(false),
|
|
||||||
group_write: Some(false),
|
|
||||||
other_write: Some(false),
|
|
||||||
|
|
||||||
owner_read: Some(true),
|
|
||||||
group_read: Some(true),
|
|
||||||
other_read: Some(true),
|
|
||||||
|
|
||||||
owner_exec: None,
|
|
||||||
group_exec: None,
|
|
||||||
other_exec: None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
/// Creates a set of [`Permissions`] that indicate globally writable status.
|
|
||||||
///
|
|
||||||
/// ```
|
|
||||||
/// use distant_core::protocol::Permissions;
|
|
||||||
///
|
|
||||||
/// let permissions = Permissions::writable();
|
|
||||||
/// assert_eq!(permissions.is_readonly(), Some(false));
|
|
||||||
/// assert_eq!(permissions.is_writable(), Some(true));
|
|
||||||
/// ```
|
|
||||||
pub fn writable() -> Self {
|
|
||||||
Self {
|
|
||||||
owner_write: Some(true),
|
|
||||||
group_write: Some(true),
|
|
||||||
other_write: Some(true),
|
|
||||||
|
|
||||||
owner_read: Some(true),
|
|
||||||
group_read: Some(true),
|
|
||||||
other_read: Some(true),
|
|
||||||
|
|
||||||
owner_exec: None,
|
|
||||||
group_exec: None,
|
|
||||||
other_exec: None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns true if the permission set has a value specified for each permission (no `None`
|
|
||||||
/// settings).
|
|
||||||
pub fn is_complete(&self) -> bool {
|
|
||||||
self.owner_read.is_some()
|
|
||||||
&& self.owner_write.is_some()
|
|
||||||
&& self.owner_exec.is_some()
|
|
||||||
&& self.group_read.is_some()
|
|
||||||
&& self.group_write.is_some()
|
|
||||||
&& self.group_exec.is_some()
|
|
||||||
&& self.other_read.is_some()
|
|
||||||
&& self.other_write.is_some()
|
|
||||||
&& self.other_exec.is_some()
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns `true` if permissions represent readonly, `false` if permissions represent
|
|
||||||
/// writable, and `None` if no permissions have been set to indicate either status.
|
|
||||||
#[inline]
|
|
||||||
pub fn is_readonly(&self) -> Option<bool> {
|
|
||||||
// Negate the writable status to indicate whether or not readonly
|
|
||||||
self.is_writable().map(|x| !x)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns `true` if permissions represent ability to write, `false` if permissions represent
|
|
||||||
/// inability to write, and `None` if no permissions have been set to indicate either status.
|
|
||||||
#[inline]
|
|
||||||
pub fn is_writable(&self) -> Option<bool> {
|
|
||||||
self.owner_write
|
|
||||||
.zip(self.group_write)
|
|
||||||
.zip(self.other_write)
|
|
||||||
.map(|((owner, group), other)| owner || group || other)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Applies `other` settings to `self`, overwriting any of the permissions in `self` with `other`.
|
|
||||||
#[inline]
|
|
||||||
pub fn apply_from(&mut self, other: &Self) {
|
|
||||||
macro_rules! apply {
|
|
||||||
($key:ident) => {{
|
|
||||||
if let Some(value) = other.$key {
|
|
||||||
self.$key = Some(value);
|
|
||||||
}
|
|
||||||
}};
|
|
||||||
}
|
|
||||||
|
|
||||||
apply!(owner_read);
|
|
||||||
apply!(owner_write);
|
|
||||||
apply!(owner_exec);
|
|
||||||
apply!(group_read);
|
|
||||||
apply!(group_write);
|
|
||||||
apply!(group_exec);
|
|
||||||
apply!(other_read);
|
|
||||||
apply!(other_write);
|
|
||||||
apply!(other_exec);
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Applies `self` settings to `other`, overwriting any of the permissions in `other` with
|
|
||||||
/// `self`.
|
|
||||||
#[inline]
|
|
||||||
pub fn apply_to(&self, other: &mut Self) {
|
|
||||||
Self::apply_from(other, self)
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Converts a Unix `mode` into the permission set.
|
|
||||||
pub fn from_unix_mode(mode: u32) -> Self {
|
|
||||||
let flags = UnixFilePermissionFlags::from_bits_truncate(mode);
|
|
||||||
Self {
|
|
||||||
owner_read: Some(flags.contains(UnixFilePermissionFlags::OWNER_READ)),
|
|
||||||
owner_write: Some(flags.contains(UnixFilePermissionFlags::OWNER_WRITE)),
|
|
||||||
owner_exec: Some(flags.contains(UnixFilePermissionFlags::OWNER_EXEC)),
|
|
||||||
group_read: Some(flags.contains(UnixFilePermissionFlags::GROUP_READ)),
|
|
||||||
group_write: Some(flags.contains(UnixFilePermissionFlags::GROUP_WRITE)),
|
|
||||||
group_exec: Some(flags.contains(UnixFilePermissionFlags::GROUP_EXEC)),
|
|
||||||
other_read: Some(flags.contains(UnixFilePermissionFlags::OTHER_READ)),
|
|
||||||
other_write: Some(flags.contains(UnixFilePermissionFlags::OTHER_WRITE)),
|
|
||||||
other_exec: Some(flags.contains(UnixFilePermissionFlags::OTHER_EXEC)),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Converts to a Unix `mode` from a permission set. For any missing setting, a 0 bit is used.
|
|
||||||
pub fn to_unix_mode(&self) -> u32 {
|
|
||||||
let mut flags = UnixFilePermissionFlags::empty();
|
|
||||||
|
|
||||||
macro_rules! is_true {
|
|
||||||
($opt:expr) => {{
|
|
||||||
$opt.is_some() && $opt.unwrap()
|
|
||||||
}};
|
|
||||||
}
|
|
||||||
|
|
||||||
if is_true!(self.owner_read) {
|
|
||||||
flags.insert(UnixFilePermissionFlags::OWNER_READ);
|
|
||||||
}
|
|
||||||
if is_true!(self.owner_write) {
|
|
||||||
flags.insert(UnixFilePermissionFlags::OWNER_WRITE);
|
|
||||||
}
|
|
||||||
if is_true!(self.owner_exec) {
|
|
||||||
flags.insert(UnixFilePermissionFlags::OWNER_EXEC);
|
|
||||||
}
|
|
||||||
|
|
||||||
if is_true!(self.group_read) {
|
|
||||||
flags.insert(UnixFilePermissionFlags::GROUP_READ);
|
|
||||||
}
|
|
||||||
if is_true!(self.group_write) {
|
|
||||||
flags.insert(UnixFilePermissionFlags::GROUP_WRITE);
|
|
||||||
}
|
|
||||||
if is_true!(self.group_exec) {
|
|
||||||
flags.insert(UnixFilePermissionFlags::GROUP_EXEC);
|
|
||||||
}
|
|
||||||
|
|
||||||
if is_true!(self.other_read) {
|
|
||||||
flags.insert(UnixFilePermissionFlags::OTHER_READ);
|
|
||||||
}
|
|
||||||
if is_true!(self.other_write) {
|
|
||||||
flags.insert(UnixFilePermissionFlags::OTHER_WRITE);
|
|
||||||
}
|
|
||||||
if is_true!(self.other_exec) {
|
|
||||||
flags.insert(UnixFilePermissionFlags::OTHER_EXEC);
|
|
||||||
}
|
|
||||||
|
|
||||||
flags.bits()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl Permissions {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(Permissions)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(unix)]
|
|
||||||
impl From<std::fs::Permissions> for Permissions {
|
|
||||||
/// Converts [`std::fs::Permissions`] into [`Permissions`] using
|
|
||||||
/// [`std::os::unix::fs::PermissionsExt::mode`] to supply the bitset.
|
|
||||||
fn from(permissions: std::fs::Permissions) -> Self {
|
|
||||||
use std::os::unix::prelude::*;
|
|
||||||
Self::from_unix_mode(permissions.mode())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(not(unix))]
|
|
||||||
impl From<std::fs::Permissions> for Permissions {
|
|
||||||
/// Converts [`std::fs::Permissions`] into [`Permissions`] using the `readonly` flag.
|
|
||||||
///
|
|
||||||
/// This will not set executable flags, but will set all read and write flags with write flags
|
|
||||||
/// being `false` if `readonly`, otherwise set to `true`.
|
|
||||||
fn from(permissions: std::fs::Permissions) -> Self {
|
|
||||||
if permissions.readonly() {
|
|
||||||
Self::readonly()
|
|
||||||
} else {
|
|
||||||
Self::writable()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(unix)]
|
|
||||||
impl From<Permissions> for std::fs::Permissions {
|
|
||||||
/// Converts [`Permissions`] into [`std::fs::Permissions`] using
|
|
||||||
/// [`std::os::unix::fs::PermissionsExt::from_mode`].
|
|
||||||
fn from(permissions: Permissions) -> Self {
|
|
||||||
use std::os::unix::prelude::*;
|
|
||||||
std::fs::Permissions::from_mode(permissions.to_unix_mode())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
bitflags! {
|
|
||||||
struct UnixFilePermissionFlags: u32 {
|
|
||||||
const OWNER_READ = 0o400;
|
|
||||||
const OWNER_WRITE = 0o200;
|
|
||||||
const OWNER_EXEC = 0o100;
|
|
||||||
const GROUP_READ = 0o40;
|
|
||||||
const GROUP_WRITE = 0o20;
|
|
||||||
const GROUP_EXEC = 0o10;
|
|
||||||
const OTHER_READ = 0o4;
|
|
||||||
const OTHER_WRITE = 0o2;
|
|
||||||
const OTHER_EXEC = 0o1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,140 +0,0 @@
|
|||||||
use std::fmt;
|
|
||||||
use std::num::ParseIntError;
|
|
||||||
use std::str::FromStr;
|
|
||||||
|
|
||||||
use derive_more::{Display, Error};
|
|
||||||
use portable_pty::PtySize as PortablePtySize;
|
|
||||||
use serde::{Deserialize, Serialize};
|
|
||||||
|
|
||||||
/// Represents the size associated with a remote PTY
|
|
||||||
#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
pub struct PtySize {
|
|
||||||
/// Number of lines of text
|
|
||||||
pub rows: u16,
|
|
||||||
|
|
||||||
/// Number of columns of text
|
|
||||||
pub cols: u16,
|
|
||||||
|
|
||||||
/// Width of a cell in pixels. Note that some systems never fill this value and ignore it.
|
|
||||||
#[serde(default)]
|
|
||||||
pub pixel_width: u16,
|
|
||||||
|
|
||||||
/// Height of a cell in pixels. Note that some systems never fill this value and ignore it.
|
|
||||||
#[serde(default)]
|
|
||||||
pub pixel_height: u16,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl PtySize {
|
|
||||||
/// Creates new size using just rows and columns
|
|
||||||
pub fn from_rows_and_cols(rows: u16, cols: u16) -> Self {
|
|
||||||
Self {
|
|
||||||
rows,
|
|
||||||
cols,
|
|
||||||
..Default::default()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl PtySize {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(PtySize)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<PortablePtySize> for PtySize {
|
|
||||||
fn from(size: PortablePtySize) -> Self {
|
|
||||||
Self {
|
|
||||||
rows: size.rows,
|
|
||||||
cols: size.cols,
|
|
||||||
pixel_width: size.pixel_width,
|
|
||||||
pixel_height: size.pixel_height,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl From<PtySize> for PortablePtySize {
|
|
||||||
fn from(size: PtySize) -> Self {
|
|
||||||
Self {
|
|
||||||
rows: size.rows,
|
|
||||||
cols: size.cols,
|
|
||||||
pixel_width: size.pixel_width,
|
|
||||||
pixel_height: size.pixel_height,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl fmt::Display for PtySize {
|
|
||||||
/// Prints out `rows,cols[,pixel_width,pixel_height]` where the
|
|
||||||
/// pixel width and pixel height are only included if either
|
|
||||||
/// one of them is not zero
|
|
||||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
||||||
write!(f, "{},{}", self.rows, self.cols)?;
|
|
||||||
if self.pixel_width > 0 || self.pixel_height > 0 {
|
|
||||||
write!(f, ",{},{}", self.pixel_width, self.pixel_height)?;
|
|
||||||
}
|
|
||||||
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Default for PtySize {
|
|
||||||
fn default() -> Self {
|
|
||||||
PtySize {
|
|
||||||
rows: 24,
|
|
||||||
cols: 80,
|
|
||||||
pixel_width: 0,
|
|
||||||
pixel_height: 0,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Clone, Debug, PartialEq, Eq, Display, Error)]
|
|
||||||
pub enum PtySizeParseError {
|
|
||||||
MissingRows,
|
|
||||||
MissingColumns,
|
|
||||||
InvalidRows(ParseIntError),
|
|
||||||
InvalidColumns(ParseIntError),
|
|
||||||
InvalidPixelWidth(ParseIntError),
|
|
||||||
InvalidPixelHeight(ParseIntError),
|
|
||||||
}
|
|
||||||
|
|
||||||
impl FromStr for PtySize {
|
|
||||||
type Err = PtySizeParseError;
|
|
||||||
|
|
||||||
/// Attempts to parse a str into PtySize using one of the following formats:
|
|
||||||
///
|
|
||||||
/// * rows,cols (defaults to 0 for pixel_width & pixel_height)
|
|
||||||
/// * rows,cols,pixel_width,pixel_height
|
|
||||||
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
||||||
let mut tokens = s.split(',');
|
|
||||||
|
|
||||||
Ok(Self {
|
|
||||||
rows: tokens
|
|
||||||
.next()
|
|
||||||
.ok_or(PtySizeParseError::MissingRows)?
|
|
||||||
.trim()
|
|
||||||
.parse()
|
|
||||||
.map_err(PtySizeParseError::InvalidRows)?,
|
|
||||||
cols: tokens
|
|
||||||
.next()
|
|
||||||
.ok_or(PtySizeParseError::MissingColumns)?
|
|
||||||
.trim()
|
|
||||||
.parse()
|
|
||||||
.map_err(PtySizeParseError::InvalidColumns)?,
|
|
||||||
pixel_width: tokens
|
|
||||||
.next()
|
|
||||||
.map(|s| s.trim().parse())
|
|
||||||
.transpose()
|
|
||||||
.map_err(PtySizeParseError::InvalidPixelWidth)?
|
|
||||||
.unwrap_or(0),
|
|
||||||
pixel_height: tokens
|
|
||||||
.next()
|
|
||||||
.map(|s| s.trim().parse())
|
|
||||||
.transpose()
|
|
||||||
.map_err(PtySizeParseError::InvalidPixelHeight)?
|
|
||||||
.unwrap_or(0),
|
|
||||||
})
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,425 +0,0 @@
|
|||||||
use std::borrow::Cow;
|
|
||||||
use std::collections::HashSet;
|
|
||||||
use std::path::PathBuf;
|
|
||||||
use std::str::FromStr;
|
|
||||||
|
|
||||||
use serde::{Deserialize, Serialize};
|
|
||||||
|
|
||||||
use super::FileType;
|
|
||||||
|
|
||||||
/// Id associated with a search
|
|
||||||
pub type SearchId = u32;
|
|
||||||
|
|
||||||
/// Represents a query to perform against the filesystem
|
|
||||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
pub struct SearchQuery {
|
|
||||||
/// Kind of data to examine using condition
|
|
||||||
pub target: SearchQueryTarget,
|
|
||||||
|
|
||||||
/// Condition to meet to be considered a match
|
|
||||||
pub condition: SearchQueryCondition,
|
|
||||||
|
|
||||||
/// Paths in which to perform the query
|
|
||||||
pub paths: Vec<PathBuf>,
|
|
||||||
|
|
||||||
/// Options to apply to the query
|
|
||||||
#[serde(default)]
|
|
||||||
pub options: SearchQueryOptions,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl SearchQuery {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(SearchQuery)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl FromStr for SearchQuery {
|
|
||||||
type Err = serde_json::error::Error;
|
|
||||||
|
|
||||||
/// Parses search query from a JSON string
|
|
||||||
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
||||||
serde_json::from_str(s)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Kind of data to examine using conditions
|
|
||||||
#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
#[serde(rename_all = "snake_case")]
|
|
||||||
pub enum SearchQueryTarget {
|
|
||||||
/// Checks path of file, directory, or symlink
|
|
||||||
Path,
|
|
||||||
|
|
||||||
/// Checks contents of files
|
|
||||||
Contents,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl SearchQueryTarget {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(SearchQueryTarget)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Condition used to find a match in a search query
|
|
||||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
#[serde(rename_all = "snake_case", deny_unknown_fields, tag = "type")]
|
|
||||||
pub enum SearchQueryCondition {
|
|
||||||
/// Text is found anywhere (all regex patterns are escaped)
|
|
||||||
Contains { value: String },
|
|
||||||
|
|
||||||
/// Begins with some text (all regex patterns are escaped)
|
|
||||||
EndsWith { value: String },
|
|
||||||
|
|
||||||
/// Matches some text exactly (all regex patterns are escaped)
|
|
||||||
Equals { value: String },
|
|
||||||
|
|
||||||
/// Any of the conditions match
|
|
||||||
Or { value: Vec<SearchQueryCondition> },
|
|
||||||
|
|
||||||
/// Matches some regex
|
|
||||||
Regex { value: String },
|
|
||||||
|
|
||||||
/// Begins with some text (all regex patterns are escaped)
|
|
||||||
StartsWith { value: String },
|
|
||||||
}
|
|
||||||
|
|
||||||
impl SearchQueryCondition {
|
|
||||||
/// Creates a new instance with `Contains` variant
|
|
||||||
pub fn contains(value: impl Into<String>) -> Self {
|
|
||||||
Self::Contains {
|
|
||||||
value: value.into(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Creates a new instance with `EndsWith` variant
|
|
||||||
pub fn ends_with(value: impl Into<String>) -> Self {
|
|
||||||
Self::EndsWith {
|
|
||||||
value: value.into(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Creates a new instance with `Equals` variant
|
|
||||||
pub fn equals(value: impl Into<String>) -> Self {
|
|
||||||
Self::Equals {
|
|
||||||
value: value.into(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Creates a new instance with `Or` variant
|
|
||||||
pub fn or<I, C>(value: I) -> Self
|
|
||||||
where
|
|
||||||
I: IntoIterator<Item = C>,
|
|
||||||
C: Into<SearchQueryCondition>,
|
|
||||||
{
|
|
||||||
Self::Or {
|
|
||||||
value: value.into_iter().map(|s| s.into()).collect(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Creates a new instance with `Regex` variant
|
|
||||||
pub fn regex(value: impl Into<String>) -> Self {
|
|
||||||
Self::Regex {
|
|
||||||
value: value.into(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Creates a new instance with `StartsWith` variant
|
|
||||||
pub fn starts_with(value: impl Into<String>) -> Self {
|
|
||||||
Self::StartsWith {
|
|
||||||
value: value.into(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Converts the condition in a regex string
|
|
||||||
pub fn to_regex_string(&self) -> String {
|
|
||||||
match self {
|
|
||||||
Self::Contains { value } => regex::escape(value),
|
|
||||||
Self::EndsWith { value } => format!(r"{}$", regex::escape(value)),
|
|
||||||
Self::Equals { value } => format!(r"^{}$", regex::escape(value)),
|
|
||||||
Self::Regex { value } => value.to_string(),
|
|
||||||
Self::StartsWith { value } => format!(r"^{}", regex::escape(value)),
|
|
||||||
Self::Or { value } => {
|
|
||||||
let mut s = String::new();
|
|
||||||
for (i, condition) in value.iter().enumerate() {
|
|
||||||
if i > 0 {
|
|
||||||
s.push('|');
|
|
||||||
}
|
|
||||||
s.push_str(&condition.to_regex_string());
|
|
||||||
}
|
|
||||||
s
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl SearchQueryCondition {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(SearchQueryCondition)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl FromStr for SearchQueryCondition {
|
|
||||||
type Err = std::convert::Infallible;
|
|
||||||
|
|
||||||
/// Parses search query from a JSON string
|
|
||||||
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
||||||
Ok(Self::regex(s))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Options associated with a search query
|
|
||||||
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
#[serde(default)]
|
|
||||||
pub struct SearchQueryOptions {
|
|
||||||
/// Restrict search to only these file types (otherwise all are allowed).
|
|
||||||
pub allowed_file_types: HashSet<FileType>,
|
|
||||||
|
|
||||||
/// Regex to use to filter paths being searched to only those that match the include condition.
|
|
||||||
pub include: Option<SearchQueryCondition>,
|
|
||||||
|
|
||||||
/// Regex to use to filter paths being searched to only those that do not match the exclude.
|
|
||||||
/// condition
|
|
||||||
pub exclude: Option<SearchQueryCondition>,
|
|
||||||
|
|
||||||
/// If true, will search upward through parent directories rather than the traditional downward
|
|
||||||
/// search that recurses through all children directories.
|
|
||||||
///
|
|
||||||
/// Note that this will use maximum depth to apply to the reverse direction, and will only look
|
|
||||||
/// through each ancestor directory's immediate entries. In other words, this will not result
|
|
||||||
/// in recursing through sibling directories.
|
|
||||||
///
|
|
||||||
/// An upward search will ALWAYS search the contents of a directory, so this means providing a
|
|
||||||
/// path to a directory will search its entries EVEN if the max_depth is 0.
|
|
||||||
pub upward: bool,
|
|
||||||
|
|
||||||
/// Search should follow symbolic links.
|
|
||||||
pub follow_symbolic_links: bool,
|
|
||||||
|
|
||||||
/// Maximum results to return before stopping the query.
|
|
||||||
pub limit: Option<u64>,
|
|
||||||
|
|
||||||
/// Maximum depth (directories) to search
|
|
||||||
///
|
|
||||||
/// The smallest depth is 0 and always corresponds to the path given to the new function on
|
|
||||||
/// this type. Its direct descendents have depth 1, and their descendents have depth 2, and so
|
|
||||||
/// on.
|
|
||||||
///
|
|
||||||
/// Note that this will not simply filter the entries of the iterator, but it will actually
|
|
||||||
/// avoid descending into directories when the depth is exceeded.
|
|
||||||
pub max_depth: Option<u64>,
|
|
||||||
|
|
||||||
/// Amount of results to batch before sending back excluding final submission that will always
|
|
||||||
/// include the remaining results even if less than pagination request.
|
|
||||||
pub pagination: Option<u64>,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl SearchQueryOptions {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(SearchQueryOptions)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Represents a match for a search query
|
|
||||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
#[serde(rename_all = "snake_case", deny_unknown_fields, tag = "type")]
|
|
||||||
pub enum SearchQueryMatch {
|
|
||||||
/// Matches part of a file's path
|
|
||||||
Path(SearchQueryPathMatch),
|
|
||||||
|
|
||||||
/// Matches part of a file's contents
|
|
||||||
Contents(SearchQueryContentsMatch),
|
|
||||||
}
|
|
||||||
|
|
||||||
impl SearchQueryMatch {
|
|
||||||
pub fn into_path_match(self) -> Option<SearchQueryPathMatch> {
|
|
||||||
match self {
|
|
||||||
Self::Path(x) => Some(x),
|
|
||||||
_ => None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn into_contents_match(self) -> Option<SearchQueryContentsMatch> {
|
|
||||||
match self {
|
|
||||||
Self::Contents(x) => Some(x),
|
|
||||||
_ => None,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl SearchQueryMatch {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(SearchQueryMatch)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Represents details for a match on a path
|
|
||||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
pub struct SearchQueryPathMatch {
|
|
||||||
/// Path associated with the match
|
|
||||||
pub path: PathBuf,
|
|
||||||
|
|
||||||
/// Collection of matches tied to `path` where each submatch's byte offset is relative to
|
|
||||||
/// `path`
|
|
||||||
pub submatches: Vec<SearchQuerySubmatch>,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl SearchQueryPathMatch {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(SearchQueryPathMatch)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Represents details for a match on a file's contents
|
|
||||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
pub struct SearchQueryContentsMatch {
|
|
||||||
/// Path to file whose contents match
|
|
||||||
pub path: PathBuf,
|
|
||||||
|
|
||||||
/// Line(s) that matched
|
|
||||||
pub lines: SearchQueryMatchData,
|
|
||||||
|
|
||||||
/// Line number where match starts (base index 1)
|
|
||||||
pub line_number: u64,
|
|
||||||
|
|
||||||
/// Absolute byte offset corresponding to the start of `lines` in the data being searched
|
|
||||||
pub absolute_offset: u64,
|
|
||||||
|
|
||||||
/// Collection of matches tied to `lines` where each submatch's byte offset is relative to
|
|
||||||
/// `lines` and not the overall content
|
|
||||||
pub submatches: Vec<SearchQuerySubmatch>,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl SearchQueryContentsMatch {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(SearchQueryContentsMatch)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
pub struct SearchQuerySubmatch {
|
|
||||||
/// Content matched by query
|
|
||||||
pub r#match: SearchQueryMatchData,
|
|
||||||
|
|
||||||
/// Byte offset representing start of submatch (inclusive)
|
|
||||||
pub start: u64,
|
|
||||||
|
|
||||||
/// Byte offset representing end of submatch (exclusive)
|
|
||||||
pub end: u64,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl SearchQuerySubmatch {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(SearchQuerySubmatch)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
#[serde(
|
|
||||||
rename_all = "snake_case",
|
|
||||||
deny_unknown_fields,
|
|
||||||
tag = "type",
|
|
||||||
content = "value"
|
|
||||||
)]
|
|
||||||
pub enum SearchQueryMatchData {
|
|
||||||
/// Match represented as UTF-8 text
|
|
||||||
Text(String),
|
|
||||||
|
|
||||||
/// Match represented as bytes
|
|
||||||
Bytes(Vec<u8>),
|
|
||||||
}
|
|
||||||
|
|
||||||
impl SearchQueryMatchData {
|
|
||||||
/// Creates a new instance with `Text` variant
|
|
||||||
pub fn text(value: impl Into<String>) -> Self {
|
|
||||||
Self::Text(value.into())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Creates a new instance with `Bytes` variant
|
|
||||||
pub fn bytes(value: impl Into<Vec<u8>>) -> Self {
|
|
||||||
Self::Bytes(value.into())
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the UTF-8 str reference to the data, if is valid UTF-8
|
|
||||||
pub fn to_str(&self) -> Option<&str> {
|
|
||||||
match self {
|
|
||||||
Self::Text(x) => Some(x),
|
|
||||||
Self::Bytes(x) => std::str::from_utf8(x).ok(),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Converts data to a UTF-8 string, replacing any invalid UTF-8 sequences with
|
|
||||||
/// [`U+FFFD REPLACEMENT CHARACTER`](https://doc.rust-lang.org/nightly/core/char/const.REPLACEMENT_CHARACTER.html)
|
|
||||||
pub fn to_string_lossy(&self) -> Cow<'_, str> {
|
|
||||||
match self {
|
|
||||||
Self::Text(x) => Cow::Borrowed(x),
|
|
||||||
Self::Bytes(x) => String::from_utf8_lossy(x),
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl SearchQueryMatchData {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(SearchQueryMatchData)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(test)]
|
|
||||||
mod tests {
|
|
||||||
use super::*;
|
|
||||||
|
|
||||||
mod search_query_condition {
|
|
||||||
use test_log::test;
|
|
||||||
|
|
||||||
use super::*;
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn to_regex_string_should_convert_to_appropriate_regex_and_escape_as_needed() {
|
|
||||||
assert_eq!(
|
|
||||||
SearchQueryCondition::contains("t^es$t").to_regex_string(),
|
|
||||||
r"t\^es\$t"
|
|
||||||
);
|
|
||||||
assert_eq!(
|
|
||||||
SearchQueryCondition::ends_with("t^es$t").to_regex_string(),
|
|
||||||
r"t\^es\$t$"
|
|
||||||
);
|
|
||||||
assert_eq!(
|
|
||||||
SearchQueryCondition::equals("t^es$t").to_regex_string(),
|
|
||||||
r"^t\^es\$t$"
|
|
||||||
);
|
|
||||||
assert_eq!(
|
|
||||||
SearchQueryCondition::or([
|
|
||||||
SearchQueryCondition::contains("t^es$t"),
|
|
||||||
SearchQueryCondition::equals("t^es$t"),
|
|
||||||
SearchQueryCondition::regex("^test$"),
|
|
||||||
])
|
|
||||||
.to_regex_string(),
|
|
||||||
r"t\^es\$t|^t\^es\$t$|^test$"
|
|
||||||
);
|
|
||||||
assert_eq!(
|
|
||||||
SearchQueryCondition::regex("test").to_regex_string(),
|
|
||||||
"test"
|
|
||||||
);
|
|
||||||
assert_eq!(
|
|
||||||
SearchQueryCondition::starts_with("t^es$t").to_regex_string(),
|
|
||||||
r"^t\^es\$t"
|
|
||||||
);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,59 +0,0 @@
|
|||||||
use std::env;
|
|
||||||
use std::path::PathBuf;
|
|
||||||
|
|
||||||
use serde::{Deserialize, Serialize};
|
|
||||||
|
|
||||||
/// Represents information about a system
|
|
||||||
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
||||||
#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
|
|
||||||
pub struct SystemInfo {
|
|
||||||
/// Family of the operating system as described in
|
|
||||||
/// https://doc.rust-lang.org/std/env/consts/constant.FAMILY.html
|
|
||||||
pub family: String,
|
|
||||||
|
|
||||||
/// Name of the specific operating system as described in
|
|
||||||
/// https://doc.rust-lang.org/std/env/consts/constant.OS.html
|
|
||||||
pub os: String,
|
|
||||||
|
|
||||||
/// Architecture of the CPI as described in
|
|
||||||
/// https://doc.rust-lang.org/std/env/consts/constant.ARCH.html
|
|
||||||
pub arch: String,
|
|
||||||
|
|
||||||
/// Current working directory of the running server process
|
|
||||||
pub current_dir: PathBuf,
|
|
||||||
|
|
||||||
/// Primary separator for path components for the current platform
|
|
||||||
/// as defined in https://doc.rust-lang.org/std/path/constant.MAIN_SEPARATOR.html
|
|
||||||
pub main_separator: char,
|
|
||||||
|
|
||||||
/// Name of the user running the server process
|
|
||||||
pub username: String,
|
|
||||||
|
|
||||||
/// Default shell tied to user running the server process
|
|
||||||
pub shell: String,
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(feature = "schemars")]
|
|
||||||
impl SystemInfo {
|
|
||||||
pub fn root_schema() -> schemars::schema::RootSchema {
|
|
||||||
schemars::schema_for!(SystemInfo)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Default for SystemInfo {
|
|
||||||
fn default() -> Self {
|
|
||||||
Self {
|
|
||||||
family: env::consts::FAMILY.to_string(),
|
|
||||||
os: env::consts::OS.to_string(),
|
|
||||||
arch: env::consts::ARCH.to_string(),
|
|
||||||
current_dir: env::current_dir().unwrap_or_default(),
|
|
||||||
main_separator: std::path::MAIN_SEPARATOR,
|
|
||||||
username: whoami::username(),
|
|
||||||
shell: if cfg!(windows) {
|
|
||||||
env::var("ComSpec").unwrap_or_else(|_| String::from("cmd.exe"))
|
|
||||||
} else {
|
|
||||||
env::var("SHELL").unwrap_or_else(|_| String::from("/bin/sh"))
|
|
||||||
},
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -0,0 +1,29 @@
|
|||||||
|
[package]
|
||||||
|
name = "distant-protocol"
|
||||||
|
description = "Protocol library for distant, providing data structures used between the client and server"
|
||||||
|
categories = ["data-structures"]
|
||||||
|
keywords = ["protocol"]
|
||||||
|
version = "0.20.0-alpha.7"
|
||||||
|
authors = ["Chip Senkbeil <chip@senkbeil.org>"]
|
||||||
|
edition = "2021"
|
||||||
|
homepage = "https://github.com/chipsenkbeil/distant"
|
||||||
|
repository = "https://github.com/chipsenkbeil/distant"
|
||||||
|
readme = "README.md"
|
||||||
|
license = "MIT OR Apache-2.0"
|
||||||
|
|
||||||
|
[features]
|
||||||
|
default = []
|
||||||
|
tests = []
|
||||||
|
|
||||||
|
[dependencies]
|
||||||
|
bitflags = "2.0.2"
|
||||||
|
derive_more = { version = "0.99.17", default-features = false, features = ["deref", "deref_mut", "display", "from", "error", "into", "into_iterator", "is_variant"] }
|
||||||
|
regex = "1.7.3"
|
||||||
|
serde = { version = "1.0.159", features = ["derive"] }
|
||||||
|
serde_bytes = "0.11.9"
|
||||||
|
strum = { version = "0.24.1", features = ["derive"] }
|
||||||
|
|
||||||
|
[dev-dependencies]
|
||||||
|
rmp = "0.8.11"
|
||||||
|
rmp-serde = "1.1.1"
|
||||||
|
serde_json = "1.0.96"
|
||||||
@ -0,0 +1,29 @@
|
|||||||
|
mod capabilities;
|
||||||
|
mod change;
|
||||||
|
mod cmd;
|
||||||
|
mod error;
|
||||||
|
mod filesystem;
|
||||||
|
mod metadata;
|
||||||
|
mod permissions;
|
||||||
|
mod pty;
|
||||||
|
mod search;
|
||||||
|
mod system;
|
||||||
|
mod version;
|
||||||
|
|
||||||
|
pub use capabilities::*;
|
||||||
|
pub use change::*;
|
||||||
|
pub use cmd::*;
|
||||||
|
pub use error::*;
|
||||||
|
pub use filesystem::*;
|
||||||
|
pub use metadata::*;
|
||||||
|
pub use permissions::*;
|
||||||
|
pub use pty::*;
|
||||||
|
pub use search::*;
|
||||||
|
pub use system::*;
|
||||||
|
pub use version::*;
|
||||||
|
|
||||||
|
/// Id for a remote process
|
||||||
|
pub type ProcessId = u32;
|
||||||
|
|
||||||
|
/// Version indicated by the tuple of (major, minor, patch).
|
||||||
|
pub type SemVer = (u8, u8, u8);
|
||||||
@ -0,0 +1,380 @@
|
|||||||
|
use std::cmp::Ordering;
|
||||||
|
use std::collections::HashSet;
|
||||||
|
use std::hash::{Hash, Hasher};
|
||||||
|
use std::ops::{BitAnd, BitOr, BitXor, Deref, DerefMut};
|
||||||
|
use std::str::FromStr;
|
||||||
|
|
||||||
|
use derive_more::{From, Into, IntoIterator};
|
||||||
|
use serde::{Deserialize, Serialize};
|
||||||
|
use strum::{EnumMessage, IntoEnumIterator};
|
||||||
|
|
||||||
|
/// Represents the kinds of capabilities available.
|
||||||
|
pub use crate::request::RequestKind as CapabilityKind;
|
||||||
|
|
||||||
|
/// Set of supported capabilities for a server
|
||||||
|
#[derive(Clone, Debug, From, Into, PartialEq, Eq, IntoIterator, Serialize, Deserialize)]
|
||||||
|
#[serde(transparent)]
|
||||||
|
pub struct Capabilities(#[into_iterator(owned, ref)] HashSet<Capability>);
|
||||||
|
|
||||||
|
impl Capabilities {
|
||||||
|
/// Return set of capabilities encompassing all possible capabilities
|
||||||
|
pub fn all() -> Self {
|
||||||
|
Self(CapabilityKind::iter().map(Capability::from).collect())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Return empty set of capabilities
|
||||||
|
pub fn none() -> Self {
|
||||||
|
Self(HashSet::new())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns true if the capability with described kind is included
|
||||||
|
pub fn contains(&self, kind: impl AsRef<str>) -> bool {
|
||||||
|
let cap = Capability {
|
||||||
|
kind: kind.as_ref().to_string(),
|
||||||
|
description: String::new(),
|
||||||
|
};
|
||||||
|
self.0.contains(&cap)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Adds the specified capability to the set of capabilities
|
||||||
|
///
|
||||||
|
/// * If the set did not have this capability, returns `true`
|
||||||
|
/// * If the set did have this capability, returns `false`
|
||||||
|
pub fn insert(&mut self, cap: impl Into<Capability>) -> bool {
|
||||||
|
self.0.insert(cap.into())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Removes the capability with the described kind, returning the capability
|
||||||
|
pub fn take(&mut self, kind: impl AsRef<str>) -> Option<Capability> {
|
||||||
|
let cap = Capability {
|
||||||
|
kind: kind.as_ref().to_string(),
|
||||||
|
description: String::new(),
|
||||||
|
};
|
||||||
|
self.0.take(&cap)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Removes the capability with the described kind, returning true if it existed
|
||||||
|
pub fn remove(&mut self, kind: impl AsRef<str>) -> bool {
|
||||||
|
let cap = Capability {
|
||||||
|
kind: kind.as_ref().to_string(),
|
||||||
|
description: String::new(),
|
||||||
|
};
|
||||||
|
self.0.remove(&cap)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Converts into vec of capabilities sorted by kind
|
||||||
|
pub fn into_sorted_vec(self) -> Vec<Capability> {
|
||||||
|
let mut this = self.0.into_iter().collect::<Vec<_>>();
|
||||||
|
|
||||||
|
this.sort_unstable();
|
||||||
|
|
||||||
|
this
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl AsRef<HashSet<Capability>> for Capabilities {
|
||||||
|
fn as_ref(&self) -> &HashSet<Capability> {
|
||||||
|
&self.0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl AsMut<HashSet<Capability>> for Capabilities {
|
||||||
|
fn as_mut(&mut self) -> &mut HashSet<Capability> {
|
||||||
|
&mut self.0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Deref for Capabilities {
|
||||||
|
type Target = HashSet<Capability>;
|
||||||
|
|
||||||
|
fn deref(&self) -> &Self::Target {
|
||||||
|
&self.0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl DerefMut for Capabilities {
|
||||||
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||||
|
&mut self.0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl BitAnd for &Capabilities {
|
||||||
|
type Output = Capabilities;
|
||||||
|
|
||||||
|
fn bitand(self, rhs: Self) -> Self::Output {
|
||||||
|
Capabilities(self.0.bitand(&rhs.0))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl BitOr for &Capabilities {
|
||||||
|
type Output = Capabilities;
|
||||||
|
|
||||||
|
fn bitor(self, rhs: Self) -> Self::Output {
|
||||||
|
Capabilities(self.0.bitor(&rhs.0))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl BitOr<Capability> for &Capabilities {
|
||||||
|
type Output = Capabilities;
|
||||||
|
|
||||||
|
fn bitor(self, rhs: Capability) -> Self::Output {
|
||||||
|
let mut other = Capabilities::none();
|
||||||
|
other.0.insert(rhs);
|
||||||
|
|
||||||
|
self.bitor(&other)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl BitXor for &Capabilities {
|
||||||
|
type Output = Capabilities;
|
||||||
|
|
||||||
|
fn bitxor(self, rhs: Self) -> Self::Output {
|
||||||
|
Capabilities(self.0.bitxor(&rhs.0))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl FromIterator<Capability> for Capabilities {
|
||||||
|
fn from_iter<I: IntoIterator<Item = Capability>>(iter: I) -> Self {
|
||||||
|
let mut this = Capabilities::none();
|
||||||
|
|
||||||
|
for capability in iter {
|
||||||
|
this.0.insert(capability);
|
||||||
|
}
|
||||||
|
|
||||||
|
this
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Capability tied to a server. A capability is equivalent based on its kind and not description.
|
||||||
|
#[derive(Clone, Debug, Serialize, Deserialize)]
|
||||||
|
#[serde(rename_all = "snake_case", deny_unknown_fields)]
|
||||||
|
pub struct Capability {
|
||||||
|
/// Label describing the kind of capability
|
||||||
|
pub kind: String,
|
||||||
|
|
||||||
|
/// Information about the capability
|
||||||
|
pub description: String,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Capability {
|
||||||
|
/// Will convert the [`Capability`]'s `kind` into a known [`CapabilityKind`] if possible,
|
||||||
|
/// returning None if the capability is unknown
|
||||||
|
pub fn to_capability_kind(&self) -> Option<CapabilityKind> {
|
||||||
|
CapabilityKind::from_str(&self.kind).ok()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns true if the described capability is unknown
|
||||||
|
pub fn is_unknown(&self) -> bool {
|
||||||
|
self.to_capability_kind().is_none()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl PartialEq for Capability {
|
||||||
|
fn eq(&self, other: &Self) -> bool {
|
||||||
|
self.kind.eq_ignore_ascii_case(&other.kind)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Eq for Capability {}
|
||||||
|
|
||||||
|
impl PartialOrd for Capability {
|
||||||
|
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
|
||||||
|
Some(self.cmp(other))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Ord for Capability {
|
||||||
|
fn cmp(&self, other: &Self) -> Ordering {
|
||||||
|
self.kind
|
||||||
|
.to_ascii_lowercase()
|
||||||
|
.cmp(&other.kind.to_ascii_lowercase())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Hash for Capability {
|
||||||
|
fn hash<H: Hasher>(&self, state: &mut H) {
|
||||||
|
self.kind.to_ascii_lowercase().hash(state);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl From<CapabilityKind> for Capability {
|
||||||
|
/// Creates a new capability using the kind's default message
|
||||||
|
fn from(kind: CapabilityKind) -> Self {
|
||||||
|
Self {
|
||||||
|
kind: kind.to_string(),
|
||||||
|
description: kind
|
||||||
|
.get_message()
|
||||||
|
.map(ToString::to_string)
|
||||||
|
.unwrap_or_default(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
mod capabilities {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_json() {
|
||||||
|
let capabilities: Capabilities = [Capability {
|
||||||
|
kind: "some kind".to_string(),
|
||||||
|
description: "some description".to_string(),
|
||||||
|
}]
|
||||||
|
.into_iter()
|
||||||
|
.collect();
|
||||||
|
|
||||||
|
let value = serde_json::to_value(capabilities).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
value,
|
||||||
|
serde_json::json!([
|
||||||
|
{
|
||||||
|
"kind": "some kind",
|
||||||
|
"description": "some description",
|
||||||
|
}
|
||||||
|
])
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_from_json() {
|
||||||
|
let value = serde_json::json!([
|
||||||
|
{
|
||||||
|
"kind": "some kind",
|
||||||
|
"description": "some description",
|
||||||
|
}
|
||||||
|
]);
|
||||||
|
|
||||||
|
let capabilities: Capabilities = serde_json::from_value(value).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
capabilities,
|
||||||
|
[Capability {
|
||||||
|
kind: "some kind".to_string(),
|
||||||
|
description: "some description".to_string(),
|
||||||
|
}]
|
||||||
|
.into_iter()
|
||||||
|
.collect()
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_msgpack() {
|
||||||
|
let capabilities: Capabilities = [Capability {
|
||||||
|
kind: "some kind".to_string(),
|
||||||
|
description: "some description".to_string(),
|
||||||
|
}]
|
||||||
|
.into_iter()
|
||||||
|
.collect();
|
||||||
|
|
||||||
|
// NOTE: We don't actually check the output here because it's an implementation detail
|
||||||
|
// and could change as we change how serialization is done. This is merely to verify
|
||||||
|
// that we can serialize since there are times when serde fails to serialize at
|
||||||
|
// runtime.
|
||||||
|
let _ = rmp_serde::encode::to_vec_named(&capabilities).unwrap();
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_from_msgpack() {
|
||||||
|
// NOTE: It may seem odd that we are serializing just to deserialize, but this is to
|
||||||
|
// verify that we are not corrupting or preventing issues when serializing on a
|
||||||
|
// client/server and then trying to deserialize on the other side. This has happened
|
||||||
|
// enough times with minor changes that we need tests to verify.
|
||||||
|
let buf = rmp_serde::encode::to_vec_named(
|
||||||
|
&[Capability {
|
||||||
|
kind: "some kind".to_string(),
|
||||||
|
description: "some description".to_string(),
|
||||||
|
}]
|
||||||
|
.into_iter()
|
||||||
|
.collect::<Capabilities>(),
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
let capabilities: Capabilities = rmp_serde::decode::from_slice(&buf).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
capabilities,
|
||||||
|
[Capability {
|
||||||
|
kind: "some kind".to_string(),
|
||||||
|
description: "some description".to_string(),
|
||||||
|
}]
|
||||||
|
.into_iter()
|
||||||
|
.collect()
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
mod capability {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_json() {
|
||||||
|
let capability = Capability {
|
||||||
|
kind: "some kind".to_string(),
|
||||||
|
description: "some description".to_string(),
|
||||||
|
};
|
||||||
|
|
||||||
|
let value = serde_json::to_value(capability).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
value,
|
||||||
|
serde_json::json!({
|
||||||
|
"kind": "some kind",
|
||||||
|
"description": "some description",
|
||||||
|
})
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_from_json() {
|
||||||
|
let value = serde_json::json!({
|
||||||
|
"kind": "some kind",
|
||||||
|
"description": "some description",
|
||||||
|
});
|
||||||
|
|
||||||
|
let capability: Capability = serde_json::from_value(value).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
capability,
|
||||||
|
Capability {
|
||||||
|
kind: "some kind".to_string(),
|
||||||
|
description: "some description".to_string(),
|
||||||
|
}
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_msgpack() {
|
||||||
|
let capability = Capability {
|
||||||
|
kind: "some kind".to_string(),
|
||||||
|
description: "some description".to_string(),
|
||||||
|
};
|
||||||
|
|
||||||
|
// NOTE: We don't actually check the output here because it's an implementation detail
|
||||||
|
// and could change as we change how serialization is done. This is merely to verify
|
||||||
|
// that we can serialize since there are times when serde fails to serialize at
|
||||||
|
// runtime.
|
||||||
|
let _ = rmp_serde::encode::to_vec_named(&capability).unwrap();
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_from_msgpack() {
|
||||||
|
// NOTE: It may seem odd that we are serializing just to deserialize, but this is to
|
||||||
|
// verify that we are not corrupting or causing issues when serializing on a
|
||||||
|
// client/server and then trying to deserialize on the other side. This has happened
|
||||||
|
// enough times with minor changes that we need tests to verify.
|
||||||
|
let buf = rmp_serde::encode::to_vec_named(&Capability {
|
||||||
|
kind: "some kind".to_string(),
|
||||||
|
description: "some description".to_string(),
|
||||||
|
})
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
let capability: Capability = rmp_serde::decode::from_slice(&buf).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
capability,
|
||||||
|
Capability {
|
||||||
|
kind: "some kind".to_string(),
|
||||||
|
description: "some description".to_string(),
|
||||||
|
}
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,380 @@
|
|||||||
|
use std::collections::HashSet;
|
||||||
|
use std::fmt;
|
||||||
|
use std::hash::{Hash, Hasher};
|
||||||
|
use std::iter::FromIterator;
|
||||||
|
use std::ops::{BitOr, Sub};
|
||||||
|
use std::path::PathBuf;
|
||||||
|
use std::str::FromStr;
|
||||||
|
|
||||||
|
use derive_more::{Deref, DerefMut, IntoIterator};
|
||||||
|
use serde::{Deserialize, Serialize};
|
||||||
|
use strum::{EnumString, EnumVariantNames, VariantNames};
|
||||||
|
|
||||||
|
/// Change to one or more paths on the filesystem.
|
||||||
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||||
|
#[serde(rename_all = "snake_case", deny_unknown_fields)]
|
||||||
|
pub struct Change {
|
||||||
|
/// Label describing the kind of change
|
||||||
|
pub kind: ChangeKind,
|
||||||
|
|
||||||
|
/// Paths that were changed
|
||||||
|
pub paths: Vec<PathBuf>,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Represents a label attached to a [`Change`] that describes the kind of change.
|
||||||
|
///
|
||||||
|
/// This mirrors events seen from `incron`.
|
||||||
|
#[derive(
|
||||||
|
Copy,
|
||||||
|
Clone,
|
||||||
|
Debug,
|
||||||
|
strum::Display,
|
||||||
|
EnumString,
|
||||||
|
EnumVariantNames,
|
||||||
|
Hash,
|
||||||
|
PartialEq,
|
||||||
|
Eq,
|
||||||
|
PartialOrd,
|
||||||
|
Ord,
|
||||||
|
Serialize,
|
||||||
|
Deserialize,
|
||||||
|
)]
|
||||||
|
#[serde(rename_all = "snake_case", deny_unknown_fields)]
|
||||||
|
#[strum(serialize_all = "snake_case")]
|
||||||
|
pub enum ChangeKind {
|
||||||
|
/// A file was read
|
||||||
|
Access,
|
||||||
|
|
||||||
|
/// A file's or directory's attributes were changed
|
||||||
|
Attribute,
|
||||||
|
|
||||||
|
/// A file open for writing was closed
|
||||||
|
CloseWrite,
|
||||||
|
|
||||||
|
/// A file not open for writing was closed
|
||||||
|
CloseNoWrite,
|
||||||
|
|
||||||
|
/// A file, directory, or something else was created within a watched directory
|
||||||
|
Create,
|
||||||
|
|
||||||
|
/// A file, directory, or something else was deleted
|
||||||
|
Delete,
|
||||||
|
|
||||||
|
/// A file's content was modified
|
||||||
|
Modify,
|
||||||
|
|
||||||
|
/// A file was opened
|
||||||
|
Open,
|
||||||
|
|
||||||
|
/// A file, directory, or something else was renamed in some way
|
||||||
|
Rename,
|
||||||
|
|
||||||
|
/// Catch-all for any other change
|
||||||
|
Unknown,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl ChangeKind {
|
||||||
|
/// Returns a list of all variants as str names
|
||||||
|
pub const fn variants() -> &'static [&'static str] {
|
||||||
|
Self::VARIANTS
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns a list of all variants as a vec
|
||||||
|
pub fn all() -> Vec<ChangeKind> {
|
||||||
|
ChangeKindSet::all().into_sorted_vec()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns true if kind is part of the access family.
|
||||||
|
pub fn is_access(&self) -> bool {
|
||||||
|
matches!(
|
||||||
|
self,
|
||||||
|
Self::Access | Self::CloseWrite | Self::CloseNoWrite | Self::Open
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns true if kind is part of the create family.
|
||||||
|
pub fn is_create(&self) -> bool {
|
||||||
|
matches!(self, Self::Create)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns true if kind is part of the delete family.
|
||||||
|
pub fn is_delete(&self) -> bool {
|
||||||
|
matches!(self, Self::Delete)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns true if kind is part of the modify family.
|
||||||
|
pub fn is_modify(&self) -> bool {
|
||||||
|
matches!(self, Self::Attribute | Self::Modify)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns true if kind is part of the rename family.
|
||||||
|
pub fn is_rename(&self) -> bool {
|
||||||
|
matches!(self, Self::Rename)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns true if kind is unknown.
|
||||||
|
pub fn is_unknown(&self) -> bool {
|
||||||
|
matches!(self, Self::Unknown)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl BitOr for ChangeKind {
|
||||||
|
type Output = ChangeKindSet;
|
||||||
|
|
||||||
|
fn bitor(self, rhs: Self) -> Self::Output {
|
||||||
|
let mut set = ChangeKindSet::empty();
|
||||||
|
set.insert(self);
|
||||||
|
set.insert(rhs);
|
||||||
|
set
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Represents a distinct set of different change kinds
|
||||||
|
#[derive(Clone, Debug, Deref, DerefMut, IntoIterator, Serialize, Deserialize)]
|
||||||
|
pub struct ChangeKindSet(HashSet<ChangeKind>);
|
||||||
|
|
||||||
|
impl ChangeKindSet {
|
||||||
|
pub fn new(set: impl IntoIterator<Item = ChangeKind>) -> Self {
|
||||||
|
set.into_iter().collect()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Produces an empty set of [`ChangeKind`]
|
||||||
|
pub fn empty() -> Self {
|
||||||
|
Self(HashSet::new())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Produces a set of all [`ChangeKind`]
|
||||||
|
pub fn all() -> Self {
|
||||||
|
vec![
|
||||||
|
ChangeKind::Access,
|
||||||
|
ChangeKind::Attribute,
|
||||||
|
ChangeKind::CloseWrite,
|
||||||
|
ChangeKind::CloseNoWrite,
|
||||||
|
ChangeKind::Create,
|
||||||
|
ChangeKind::Delete,
|
||||||
|
ChangeKind::Modify,
|
||||||
|
ChangeKind::Open,
|
||||||
|
ChangeKind::Rename,
|
||||||
|
ChangeKind::Unknown,
|
||||||
|
]
|
||||||
|
.into_iter()
|
||||||
|
.collect()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Consumes set and returns a sorted vec of the kinds of changes
|
||||||
|
pub fn into_sorted_vec(self) -> Vec<ChangeKind> {
|
||||||
|
let mut v = self.0.into_iter().collect::<Vec<_>>();
|
||||||
|
v.sort();
|
||||||
|
v
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl fmt::Display for ChangeKindSet {
|
||||||
|
/// Outputs a comma-separated series of [`ChangeKind`] as string that are sorted
|
||||||
|
/// such that this will always be consistent output
|
||||||
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||||
|
let mut kinds = self
|
||||||
|
.0
|
||||||
|
.iter()
|
||||||
|
.map(ToString::to_string)
|
||||||
|
.collect::<Vec<String>>();
|
||||||
|
kinds.sort_unstable();
|
||||||
|
write!(f, "{}", kinds.join(","))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl PartialEq for ChangeKindSet {
|
||||||
|
fn eq(&self, other: &Self) -> bool {
|
||||||
|
self.to_string() == other.to_string()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Eq for ChangeKindSet {}
|
||||||
|
|
||||||
|
impl Hash for ChangeKindSet {
|
||||||
|
/// Hashes based on the output of [`fmt::Display`]
|
||||||
|
fn hash<H: Hasher>(&self, state: &mut H) {
|
||||||
|
self.to_string().hash(state);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl BitOr<ChangeKindSet> for ChangeKindSet {
|
||||||
|
type Output = Self;
|
||||||
|
|
||||||
|
fn bitor(mut self, rhs: ChangeKindSet) -> Self::Output {
|
||||||
|
self.extend(rhs.0);
|
||||||
|
self
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl BitOr<ChangeKind> for ChangeKindSet {
|
||||||
|
type Output = Self;
|
||||||
|
|
||||||
|
fn bitor(mut self, rhs: ChangeKind) -> Self::Output {
|
||||||
|
self.0.insert(rhs);
|
||||||
|
self
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl BitOr<ChangeKindSet> for ChangeKind {
|
||||||
|
type Output = ChangeKindSet;
|
||||||
|
|
||||||
|
fn bitor(self, rhs: ChangeKindSet) -> Self::Output {
|
||||||
|
rhs | self
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Sub<ChangeKindSet> for ChangeKindSet {
|
||||||
|
type Output = Self;
|
||||||
|
|
||||||
|
fn sub(self, other: Self) -> Self::Output {
|
||||||
|
ChangeKindSet(&self.0 - &other.0)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Sub<&'_ ChangeKindSet> for &ChangeKindSet {
|
||||||
|
type Output = ChangeKindSet;
|
||||||
|
|
||||||
|
fn sub(self, other: &ChangeKindSet) -> Self::Output {
|
||||||
|
ChangeKindSet(&self.0 - &other.0)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl FromStr for ChangeKindSet {
|
||||||
|
type Err = strum::ParseError;
|
||||||
|
|
||||||
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
||||||
|
let mut change_set = HashSet::new();
|
||||||
|
|
||||||
|
for word in s.split(',') {
|
||||||
|
change_set.insert(ChangeKind::from_str(word.trim())?);
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(ChangeKindSet(change_set))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl FromIterator<ChangeKind> for ChangeKindSet {
|
||||||
|
fn from_iter<I: IntoIterator<Item = ChangeKind>>(iter: I) -> Self {
|
||||||
|
let mut change_set = HashSet::new();
|
||||||
|
|
||||||
|
for i in iter {
|
||||||
|
change_set.insert(i);
|
||||||
|
}
|
||||||
|
|
||||||
|
ChangeKindSet(change_set)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl From<ChangeKind> for ChangeKindSet {
|
||||||
|
fn from(change_kind: ChangeKind) -> Self {
|
||||||
|
let mut set = Self::empty();
|
||||||
|
set.insert(change_kind);
|
||||||
|
set
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl From<Vec<ChangeKind>> for ChangeKindSet {
|
||||||
|
fn from(changes: Vec<ChangeKind>) -> Self {
|
||||||
|
changes.into_iter().collect()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Default for ChangeKindSet {
|
||||||
|
fn default() -> Self {
|
||||||
|
Self::empty()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
mod change_kind_set {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_json() {
|
||||||
|
let set = ChangeKindSet::new([ChangeKind::CloseWrite]);
|
||||||
|
|
||||||
|
let value = serde_json::to_value(set).unwrap();
|
||||||
|
assert_eq!(value, serde_json::json!(["close_write"]));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_from_json() {
|
||||||
|
let value = serde_json::json!(["close_write"]);
|
||||||
|
|
||||||
|
let set: ChangeKindSet = serde_json::from_value(value).unwrap();
|
||||||
|
assert_eq!(set, ChangeKindSet::new([ChangeKind::CloseWrite]));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_msgpack() {
|
||||||
|
let set = ChangeKindSet::new([ChangeKind::CloseWrite]);
|
||||||
|
|
||||||
|
// NOTE: We don't actually check the output here because it's an implementation detail
|
||||||
|
// and could change as we change how serialization is done. This is merely to verify
|
||||||
|
// that we can serialize since there are times when serde fails to serialize at
|
||||||
|
// runtime.
|
||||||
|
let _ = rmp_serde::encode::to_vec_named(&set).unwrap();
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_from_msgpack() {
|
||||||
|
// NOTE: It may seem odd that we are serializing just to deserialize, but this is to
|
||||||
|
// verify that we are not corrupting or causing issues when serializing on a
|
||||||
|
// client/server and then trying to deserialize on the other side. This has happened
|
||||||
|
// enough times with minor changes that we need tests to verify.
|
||||||
|
let buf =
|
||||||
|
rmp_serde::encode::to_vec_named(&ChangeKindSet::new([ChangeKind::CloseWrite]))
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
let set: ChangeKindSet = rmp_serde::decode::from_slice(&buf).unwrap();
|
||||||
|
assert_eq!(set, ChangeKindSet::new([ChangeKind::CloseWrite]));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
mod change_kind {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_json() {
|
||||||
|
let kind = ChangeKind::CloseWrite;
|
||||||
|
|
||||||
|
let value = serde_json::to_value(kind).unwrap();
|
||||||
|
assert_eq!(value, serde_json::json!("close_write"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_from_json() {
|
||||||
|
let value = serde_json::json!("close_write");
|
||||||
|
|
||||||
|
let kind: ChangeKind = serde_json::from_value(value).unwrap();
|
||||||
|
assert_eq!(kind, ChangeKind::CloseWrite);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_msgpack() {
|
||||||
|
let kind = ChangeKind::CloseWrite;
|
||||||
|
|
||||||
|
// NOTE: We don't actually check the output here because it's an implementation detail
|
||||||
|
// and could change as we change how serialization is done. This is merely to verify
|
||||||
|
// that we can serialize since there are times when serde fails to serialize at
|
||||||
|
// runtime.
|
||||||
|
let _ = rmp_serde::encode::to_vec_named(&kind).unwrap();
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_from_msgpack() {
|
||||||
|
// NOTE: It may seem odd that we are serializing just to deserialize, but this is to
|
||||||
|
// verify that we are not corrupting or causing issues when serializing on a
|
||||||
|
// client/server and then trying to deserialize on the other side. This has happened
|
||||||
|
// enough times with minor changes that we need tests to verify.
|
||||||
|
let buf = rmp_serde::encode::to_vec_named(&ChangeKind::CloseWrite).unwrap();
|
||||||
|
|
||||||
|
let kind: ChangeKind = rmp_serde::decode::from_slice(&buf).unwrap();
|
||||||
|
assert_eq!(kind, ChangeKind::CloseWrite);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,89 @@
|
|||||||
|
use std::ops::{Deref, DerefMut};
|
||||||
|
|
||||||
|
use derive_more::{Display, From, Into};
|
||||||
|
use serde::{Deserialize, Serialize};
|
||||||
|
|
||||||
|
/// Represents some command with arguments to execute
|
||||||
|
#[derive(Clone, Debug, Display, From, Into, Hash, PartialEq, Eq, Serialize, Deserialize)]
|
||||||
|
pub struct Cmd(String);
|
||||||
|
|
||||||
|
impl Cmd {
|
||||||
|
/// Creates a new command from the given `cmd`
|
||||||
|
pub fn new(cmd: impl Into<String>) -> Self {
|
||||||
|
Self(cmd.into())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns reference to the program portion of the command
|
||||||
|
pub fn program(&self) -> &str {
|
||||||
|
match self.0.split_once(' ') {
|
||||||
|
Some((program, _)) => program.trim(),
|
||||||
|
None => self.0.trim(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns reference to the arguments portion of the command
|
||||||
|
pub fn arguments(&self) -> &str {
|
||||||
|
match self.0.split_once(' ') {
|
||||||
|
Some((_, arguments)) => arguments.trim(),
|
||||||
|
None => "",
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Deref for Cmd {
|
||||||
|
type Target = String;
|
||||||
|
|
||||||
|
fn deref(&self) -> &Self::Target {
|
||||||
|
&self.0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl DerefMut for Cmd {
|
||||||
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||||
|
&mut self.0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_json() {
|
||||||
|
let cmd = Cmd::new("echo some text");
|
||||||
|
|
||||||
|
let value = serde_json::to_value(cmd).unwrap();
|
||||||
|
assert_eq!(value, serde_json::json!("echo some text"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_from_json() {
|
||||||
|
let value = serde_json::json!("echo some text");
|
||||||
|
|
||||||
|
let cmd: Cmd = serde_json::from_value(value).unwrap();
|
||||||
|
assert_eq!(cmd, Cmd::new("echo some text"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_msgpack() {
|
||||||
|
let cmd = Cmd::new("echo some text");
|
||||||
|
|
||||||
|
// NOTE: We don't actually check the output here because it's an implementation detail
|
||||||
|
// and could change as we change how serialization is done. This is merely to verify
|
||||||
|
// that we can serialize since there are times when serde fails to serialize at
|
||||||
|
// runtime.
|
||||||
|
let _ = rmp_serde::encode::to_vec_named(&cmd).unwrap();
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_from_msgpack() {
|
||||||
|
// NOTE: It may seem odd that we are serializing just to deserialize, but this is to
|
||||||
|
// verify that we are not corrupting or causing issues when serializing on a
|
||||||
|
// client/server and then trying to deserialize on the other side. This has happened
|
||||||
|
// enough times with minor changes that we need tests to verify.
|
||||||
|
let buf = rmp_serde::encode::to_vec_named(&Cmd::new("echo some text")).unwrap();
|
||||||
|
|
||||||
|
let cmd: Cmd = rmp_serde::decode::from_slice(&buf).unwrap();
|
||||||
|
assert_eq!(cmd, Cmd::new("echo some text"));
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,173 @@
|
|||||||
|
use std::fs::FileType as StdFileType;
|
||||||
|
use std::path::PathBuf;
|
||||||
|
|
||||||
|
use derive_more::IsVariant;
|
||||||
|
use serde::{Deserialize, Serialize};
|
||||||
|
use strum::AsRefStr;
|
||||||
|
|
||||||
|
/// Represents information about a single entry within a directory
|
||||||
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||||
|
#[serde(rename_all = "snake_case", deny_unknown_fields)]
|
||||||
|
pub struct DirEntry {
|
||||||
|
/// Represents the full path to the entry
|
||||||
|
pub path: PathBuf,
|
||||||
|
|
||||||
|
/// Represents the type of the entry as a file/dir/symlink
|
||||||
|
pub file_type: FileType,
|
||||||
|
|
||||||
|
/// Depth at which this entry was created relative to the root (0 being immediately within
|
||||||
|
/// root)
|
||||||
|
pub depth: usize,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Represents the type associated with a dir entry
|
||||||
|
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, AsRefStr, IsVariant, Serialize, Deserialize)]
|
||||||
|
#[serde(rename_all = "snake_case", deny_unknown_fields)]
|
||||||
|
#[strum(serialize_all = "snake_case")]
|
||||||
|
pub enum FileType {
|
||||||
|
Dir,
|
||||||
|
File,
|
||||||
|
Symlink,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl From<StdFileType> for FileType {
|
||||||
|
fn from(ft: StdFileType) -> Self {
|
||||||
|
if ft.is_dir() {
|
||||||
|
Self::Dir
|
||||||
|
} else if ft.is_symlink() {
|
||||||
|
Self::Symlink
|
||||||
|
} else {
|
||||||
|
Self::File
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
mod dir_entry {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_json() {
|
||||||
|
let entry = DirEntry {
|
||||||
|
path: PathBuf::from("dir").join("file"),
|
||||||
|
file_type: FileType::File,
|
||||||
|
depth: 1,
|
||||||
|
};
|
||||||
|
|
||||||
|
let path = entry.path.to_str().unwrap().to_string();
|
||||||
|
let value = serde_json::to_value(entry).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
value,
|
||||||
|
serde_json::json!({
|
||||||
|
"path": path,
|
||||||
|
"file_type": "file",
|
||||||
|
"depth": 1,
|
||||||
|
})
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_from_json() {
|
||||||
|
let value = serde_json::json!({
|
||||||
|
"path": "test-file",
|
||||||
|
"file_type": "file",
|
||||||
|
"depth": 0,
|
||||||
|
});
|
||||||
|
|
||||||
|
let entry: DirEntry = serde_json::from_value(value).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
entry,
|
||||||
|
DirEntry {
|
||||||
|
path: PathBuf::from("test-file"),
|
||||||
|
file_type: FileType::File,
|
||||||
|
depth: 0,
|
||||||
|
}
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_msgpack() {
|
||||||
|
let entry = DirEntry {
|
||||||
|
path: PathBuf::from("dir").join("file"),
|
||||||
|
file_type: FileType::File,
|
||||||
|
depth: 1,
|
||||||
|
};
|
||||||
|
|
||||||
|
// NOTE: We don't actually check the output here because it's an implementation detail
|
||||||
|
// and could change as we change how serialization is done. This is merely to verify
|
||||||
|
// that we can serialize since there are times when serde fails to serialize at
|
||||||
|
// runtime.
|
||||||
|
let _ = rmp_serde::encode::to_vec_named(&entry).unwrap();
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_from_msgpack() {
|
||||||
|
// NOTE: It may seem odd that we are serializing just to deserialize, but this is to
|
||||||
|
// verify that we are not corrupting or causing issues when serializing on a
|
||||||
|
// client/server and then trying to deserialize on the other side. This has happened
|
||||||
|
// enough times with minor changes that we need tests to verify.
|
||||||
|
let buf = rmp_serde::encode::to_vec_named(&DirEntry {
|
||||||
|
path: PathBuf::from("test-file"),
|
||||||
|
file_type: FileType::File,
|
||||||
|
depth: 0,
|
||||||
|
})
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
let entry: DirEntry = rmp_serde::decode::from_slice(&buf).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
entry,
|
||||||
|
DirEntry {
|
||||||
|
path: PathBuf::from("test-file"),
|
||||||
|
file_type: FileType::File,
|
||||||
|
depth: 0,
|
||||||
|
}
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
mod file_type {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_json() {
|
||||||
|
let ty = FileType::File;
|
||||||
|
|
||||||
|
let value = serde_json::to_value(ty).unwrap();
|
||||||
|
assert_eq!(value, serde_json::json!("file"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_from_json() {
|
||||||
|
let value = serde_json::json!("file");
|
||||||
|
|
||||||
|
let ty: FileType = serde_json::from_value(value).unwrap();
|
||||||
|
assert_eq!(ty, FileType::File);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_msgpack() {
|
||||||
|
let ty = FileType::File;
|
||||||
|
|
||||||
|
// NOTE: We don't actually check the output here because it's an implementation detail
|
||||||
|
// and could change as we change how serialization is done. This is merely to verify
|
||||||
|
// that we can serialize since there are times when serde fails to serialize at
|
||||||
|
// runtime.
|
||||||
|
let _ = rmp_serde::encode::to_vec_named(&ty).unwrap();
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_from_msgpack() {
|
||||||
|
// NOTE: It may seem odd that we are serializing just to deserialize, but this is to
|
||||||
|
// verify that we are not corrupting or causing issues when serializing on a
|
||||||
|
// client/server and then trying to deserialize on the other side. This has happened
|
||||||
|
// enough times with minor changes that we need tests to verify.
|
||||||
|
let buf = rmp_serde::encode::to_vec_named(&FileType::File).unwrap();
|
||||||
|
|
||||||
|
let ty: FileType = rmp_serde::decode::from_slice(&buf).unwrap();
|
||||||
|
assert_eq!(ty, FileType::File);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,658 @@
|
|||||||
|
use bitflags::bitflags;
|
||||||
|
use serde::{Deserialize, Serialize};
|
||||||
|
|
||||||
|
use crate::utils;
|
||||||
|
|
||||||
|
#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||||||
|
#[serde(default, deny_unknown_fields, rename_all = "snake_case")]
|
||||||
|
pub struct SetPermissionsOptions {
|
||||||
|
/// Whether or not to exclude symlinks from traversal entirely, meaning that permissions will
|
||||||
|
/// not be set on symlinks (usually resolving the symlink and setting the permission of the
|
||||||
|
/// referenced file or directory) that are explicitly provided or show up during recursion.
|
||||||
|
#[serde(skip_serializing_if = "utils::is_false")]
|
||||||
|
pub exclude_symlinks: bool,
|
||||||
|
|
||||||
|
/// Whether or not to traverse symlinks when recursively setting permissions. Note that this
|
||||||
|
/// does NOT influence setting permissions when encountering a symlink as most platforms will
|
||||||
|
/// resolve the symlink before setting permissions.
|
||||||
|
#[serde(skip_serializing_if = "utils::is_false")]
|
||||||
|
pub follow_symlinks: bool,
|
||||||
|
|
||||||
|
/// Whether or not to set the permissions of the file hierarchies rooted in the paths, instead
|
||||||
|
/// of just the paths themselves.
|
||||||
|
#[serde(skip_serializing_if = "utils::is_false")]
|
||||||
|
pub recursive: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Represents permissions to apply to some path on a remote machine
|
||||||
|
///
|
||||||
|
/// When used to set permissions on a file, directory, or symlink,
|
||||||
|
/// only fields that are set (not `None`) will be applied.
|
||||||
|
///
|
||||||
|
/// On `Unix` platforms, this translates directly into the mode that
|
||||||
|
/// you would find with `chmod`. On all other platforms, this uses the
|
||||||
|
/// write flags to determine whether or not to set the readonly status.
|
||||||
|
#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
|
||||||
|
pub struct Permissions {
|
||||||
|
/// Represents whether or not owner can read from the file
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub owner_read: Option<bool>,
|
||||||
|
|
||||||
|
/// Represents whether or not owner can write to the file
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub owner_write: Option<bool>,
|
||||||
|
|
||||||
|
/// Represents whether or not owner can execute the file
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub owner_exec: Option<bool>,
|
||||||
|
|
||||||
|
/// Represents whether or not associated group can read from the file
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub group_read: Option<bool>,
|
||||||
|
|
||||||
|
/// Represents whether or not associated group can write to the file
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub group_write: Option<bool>,
|
||||||
|
|
||||||
|
/// Represents whether or not associated group can execute the file
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub group_exec: Option<bool>,
|
||||||
|
|
||||||
|
/// Represents whether or not other can read from the file
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub other_read: Option<bool>,
|
||||||
|
|
||||||
|
/// Represents whether or not other can write to the file
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub other_write: Option<bool>,
|
||||||
|
|
||||||
|
/// Represents whether or not other can execute the file
|
||||||
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||||
|
pub other_exec: Option<bool>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Permissions {
|
||||||
|
/// Creates a set of [`Permissions`] that indicate readonly status.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use distant_protocol::Permissions;
|
||||||
|
///
|
||||||
|
/// let permissions = Permissions::readonly();
|
||||||
|
/// assert_eq!(permissions.is_readonly(), Some(true));
|
||||||
|
/// assert_eq!(permissions.is_writable(), Some(false));
|
||||||
|
/// ```
|
||||||
|
pub fn readonly() -> Self {
|
||||||
|
Self {
|
||||||
|
owner_write: Some(false),
|
||||||
|
group_write: Some(false),
|
||||||
|
other_write: Some(false),
|
||||||
|
|
||||||
|
owner_read: Some(true),
|
||||||
|
group_read: Some(true),
|
||||||
|
other_read: Some(true),
|
||||||
|
|
||||||
|
owner_exec: None,
|
||||||
|
group_exec: None,
|
||||||
|
other_exec: None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
/// Creates a set of [`Permissions`] that indicate globally writable status.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use distant_protocol::Permissions;
|
||||||
|
///
|
||||||
|
/// let permissions = Permissions::writable();
|
||||||
|
/// assert_eq!(permissions.is_readonly(), Some(false));
|
||||||
|
/// assert_eq!(permissions.is_writable(), Some(true));
|
||||||
|
/// ```
|
||||||
|
pub fn writable() -> Self {
|
||||||
|
Self {
|
||||||
|
owner_write: Some(true),
|
||||||
|
group_write: Some(true),
|
||||||
|
other_write: Some(true),
|
||||||
|
|
||||||
|
owner_read: Some(true),
|
||||||
|
group_read: Some(true),
|
||||||
|
other_read: Some(true),
|
||||||
|
|
||||||
|
owner_exec: None,
|
||||||
|
group_exec: None,
|
||||||
|
other_exec: None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns true if the permission set has a value specified for each permission (no `None`
|
||||||
|
/// settings).
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use distant_protocol::Permissions;
|
||||||
|
///
|
||||||
|
/// let permissions = Permissions {
|
||||||
|
/// owner_write: Some(true),
|
||||||
|
/// group_write: Some(false),
|
||||||
|
/// other_write: Some(true),
|
||||||
|
/// owner_read: Some(false),
|
||||||
|
/// group_read: Some(true),
|
||||||
|
/// other_read: Some(false),
|
||||||
|
/// owner_exec: Some(true),
|
||||||
|
/// group_exec: Some(false),
|
||||||
|
/// other_exec: Some(true),
|
||||||
|
/// };
|
||||||
|
/// assert!(permissions.is_complete());
|
||||||
|
/// ```
|
||||||
|
pub fn is_complete(&self) -> bool {
|
||||||
|
self.owner_read.is_some()
|
||||||
|
&& self.owner_write.is_some()
|
||||||
|
&& self.owner_exec.is_some()
|
||||||
|
&& self.group_read.is_some()
|
||||||
|
&& self.group_write.is_some()
|
||||||
|
&& self.group_exec.is_some()
|
||||||
|
&& self.other_read.is_some()
|
||||||
|
&& self.other_write.is_some()
|
||||||
|
&& self.other_exec.is_some()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns `true` if permissions represent readonly, `false` if permissions represent
|
||||||
|
/// writable, and `None` if no permissions have been set to indicate either status.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use distant_protocol::Permissions;
|
||||||
|
///
|
||||||
|
/// assert_eq!(
|
||||||
|
/// Permissions { owner_write: Some(true), ..Default::default() }.is_readonly(),
|
||||||
|
/// Some(false)
|
||||||
|
/// );
|
||||||
|
///
|
||||||
|
/// assert_eq!(
|
||||||
|
/// Permissions { owner_write: Some(false), ..Default::default() }.is_readonly(),
|
||||||
|
/// Some(true)
|
||||||
|
/// );
|
||||||
|
///
|
||||||
|
/// assert_eq!(
|
||||||
|
/// Permissions { ..Default::default() }.is_writable(),
|
||||||
|
/// None
|
||||||
|
/// );
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn is_readonly(&self) -> Option<bool> {
|
||||||
|
// Negate the writable status to indicate whether or not readonly
|
||||||
|
self.is_writable().map(|x| !x)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns `true` if permissions represent ability to write, `false` if permissions represent
|
||||||
|
/// inability to write, and `None` if no permissions have been set to indicate either status.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use distant_protocol::Permissions;
|
||||||
|
///
|
||||||
|
/// assert_eq!(
|
||||||
|
/// Permissions { owner_write: Some(true), ..Default::default() }.is_writable(),
|
||||||
|
/// Some(true)
|
||||||
|
/// );
|
||||||
|
///
|
||||||
|
/// assert_eq!(
|
||||||
|
/// Permissions { owner_write: Some(false), ..Default::default() }.is_writable(),
|
||||||
|
/// Some(false)
|
||||||
|
/// );
|
||||||
|
///
|
||||||
|
/// assert_eq!(
|
||||||
|
/// Permissions { ..Default::default() }.is_writable(),
|
||||||
|
/// None
|
||||||
|
/// );
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn is_writable(&self) -> Option<bool> {
|
||||||
|
match (self.owner_write, self.group_write, self.other_write) {
|
||||||
|
(None, None, None) => None,
|
||||||
|
(owner, group, other) => {
|
||||||
|
Some(owner.unwrap_or(false) || group.unwrap_or(false) || other.unwrap_or(false))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Applies `other` settings to `self`, overwriting any of the permissions in `self` with `other`.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use distant_protocol::Permissions;
|
||||||
|
///
|
||||||
|
/// let mut a = Permissions {
|
||||||
|
/// owner_read: Some(true),
|
||||||
|
/// owner_write: Some(false),
|
||||||
|
/// owner_exec: None,
|
||||||
|
/// ..Default::default()
|
||||||
|
/// };
|
||||||
|
///
|
||||||
|
/// let b = Permissions {
|
||||||
|
/// owner_read: Some(false),
|
||||||
|
/// owner_write: None,
|
||||||
|
/// owner_exec: Some(true),
|
||||||
|
/// ..Default::default()
|
||||||
|
/// };
|
||||||
|
///
|
||||||
|
/// a.apply_from(&b);
|
||||||
|
///
|
||||||
|
/// assert_eq!(a, Permissions {
|
||||||
|
/// owner_read: Some(false),
|
||||||
|
/// owner_write: Some(false),
|
||||||
|
/// owner_exec: Some(true),
|
||||||
|
/// ..Default::default()
|
||||||
|
/// });
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn apply_from(&mut self, other: &Self) {
|
||||||
|
macro_rules! apply {
|
||||||
|
($key:ident) => {{
|
||||||
|
if let Some(value) = other.$key {
|
||||||
|
self.$key = Some(value);
|
||||||
|
}
|
||||||
|
}};
|
||||||
|
}
|
||||||
|
|
||||||
|
apply!(owner_read);
|
||||||
|
apply!(owner_write);
|
||||||
|
apply!(owner_exec);
|
||||||
|
apply!(group_read);
|
||||||
|
apply!(group_write);
|
||||||
|
apply!(group_exec);
|
||||||
|
apply!(other_read);
|
||||||
|
apply!(other_write);
|
||||||
|
apply!(other_exec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Applies `self` settings to `other`, overwriting any of the permissions in `other` with
|
||||||
|
/// `self`.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use distant_protocol::Permissions;
|
||||||
|
///
|
||||||
|
/// let a = Permissions {
|
||||||
|
/// owner_read: Some(true),
|
||||||
|
/// owner_write: Some(false),
|
||||||
|
/// owner_exec: None,
|
||||||
|
/// ..Default::default()
|
||||||
|
/// };
|
||||||
|
///
|
||||||
|
/// let mut b = Permissions {
|
||||||
|
/// owner_read: Some(false),
|
||||||
|
/// owner_write: None,
|
||||||
|
/// owner_exec: Some(true),
|
||||||
|
/// ..Default::default()
|
||||||
|
/// };
|
||||||
|
///
|
||||||
|
/// a.apply_to(&mut b);
|
||||||
|
///
|
||||||
|
/// assert_eq!(b, Permissions {
|
||||||
|
/// owner_read: Some(true),
|
||||||
|
/// owner_write: Some(false),
|
||||||
|
/// owner_exec: Some(true),
|
||||||
|
/// ..Default::default()
|
||||||
|
/// });
|
||||||
|
/// ```
|
||||||
|
#[inline]
|
||||||
|
pub fn apply_to(&self, other: &mut Self) {
|
||||||
|
Self::apply_from(other, self)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Converts a Unix `mode` into the permission set.
|
||||||
|
pub fn from_unix_mode(mode: u32) -> Self {
|
||||||
|
let flags = UnixFilePermissionFlags::from_bits_truncate(mode);
|
||||||
|
Self {
|
||||||
|
owner_read: Some(flags.contains(UnixFilePermissionFlags::OWNER_READ)),
|
||||||
|
owner_write: Some(flags.contains(UnixFilePermissionFlags::OWNER_WRITE)),
|
||||||
|
owner_exec: Some(flags.contains(UnixFilePermissionFlags::OWNER_EXEC)),
|
||||||
|
group_read: Some(flags.contains(UnixFilePermissionFlags::GROUP_READ)),
|
||||||
|
group_write: Some(flags.contains(UnixFilePermissionFlags::GROUP_WRITE)),
|
||||||
|
group_exec: Some(flags.contains(UnixFilePermissionFlags::GROUP_EXEC)),
|
||||||
|
other_read: Some(flags.contains(UnixFilePermissionFlags::OTHER_READ)),
|
||||||
|
other_write: Some(flags.contains(UnixFilePermissionFlags::OTHER_WRITE)),
|
||||||
|
other_exec: Some(flags.contains(UnixFilePermissionFlags::OTHER_EXEC)),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Converts to a Unix `mode` from a permission set. For any missing setting, a 0 bit is used.
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use distant_protocol::Permissions;
|
||||||
|
///
|
||||||
|
/// assert_eq!(Permissions {
|
||||||
|
/// owner_read: Some(true),
|
||||||
|
/// owner_write: Some(true),
|
||||||
|
/// owner_exec: Some(true),
|
||||||
|
/// group_read: Some(true),
|
||||||
|
/// group_write: Some(true),
|
||||||
|
/// group_exec: Some(true),
|
||||||
|
/// other_read: Some(true),
|
||||||
|
/// other_write: Some(true),
|
||||||
|
/// other_exec: Some(true),
|
||||||
|
/// }.to_unix_mode(), 0o777);
|
||||||
|
///
|
||||||
|
/// assert_eq!(Permissions {
|
||||||
|
/// owner_read: Some(true),
|
||||||
|
/// owner_write: Some(false),
|
||||||
|
/// owner_exec: Some(false),
|
||||||
|
/// group_read: Some(true),
|
||||||
|
/// group_write: Some(false),
|
||||||
|
/// group_exec: Some(false),
|
||||||
|
/// other_read: Some(true),
|
||||||
|
/// other_write: Some(false),
|
||||||
|
/// other_exec: Some(false),
|
||||||
|
/// }.to_unix_mode(), 0o444);
|
||||||
|
///
|
||||||
|
/// assert_eq!(Permissions {
|
||||||
|
/// owner_exec: Some(true),
|
||||||
|
/// group_exec: Some(true),
|
||||||
|
/// other_exec: Some(true),
|
||||||
|
/// ..Default::default()
|
||||||
|
/// }.to_unix_mode(), 0o111);
|
||||||
|
/// ```
|
||||||
|
pub fn to_unix_mode(&self) -> u32 {
|
||||||
|
let mut flags = UnixFilePermissionFlags::empty();
|
||||||
|
|
||||||
|
macro_rules! is_true {
|
||||||
|
($opt:expr) => {{
|
||||||
|
$opt.is_some() && $opt.unwrap()
|
||||||
|
}};
|
||||||
|
}
|
||||||
|
|
||||||
|
if is_true!(self.owner_read) {
|
||||||
|
flags.insert(UnixFilePermissionFlags::OWNER_READ);
|
||||||
|
}
|
||||||
|
if is_true!(self.owner_write) {
|
||||||
|
flags.insert(UnixFilePermissionFlags::OWNER_WRITE);
|
||||||
|
}
|
||||||
|
if is_true!(self.owner_exec) {
|
||||||
|
flags.insert(UnixFilePermissionFlags::OWNER_EXEC);
|
||||||
|
}
|
||||||
|
|
||||||
|
if is_true!(self.group_read) {
|
||||||
|
flags.insert(UnixFilePermissionFlags::GROUP_READ);
|
||||||
|
}
|
||||||
|
if is_true!(self.group_write) {
|
||||||
|
flags.insert(UnixFilePermissionFlags::GROUP_WRITE);
|
||||||
|
}
|
||||||
|
if is_true!(self.group_exec) {
|
||||||
|
flags.insert(UnixFilePermissionFlags::GROUP_EXEC);
|
||||||
|
}
|
||||||
|
|
||||||
|
if is_true!(self.other_read) {
|
||||||
|
flags.insert(UnixFilePermissionFlags::OTHER_READ);
|
||||||
|
}
|
||||||
|
if is_true!(self.other_write) {
|
||||||
|
flags.insert(UnixFilePermissionFlags::OTHER_WRITE);
|
||||||
|
}
|
||||||
|
if is_true!(self.other_exec) {
|
||||||
|
flags.insert(UnixFilePermissionFlags::OTHER_EXEC);
|
||||||
|
}
|
||||||
|
|
||||||
|
flags.bits()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(unix)]
|
||||||
|
impl From<std::fs::Permissions> for Permissions {
|
||||||
|
/// Converts [`std::fs::Permissions`] into [`Permissions`] using
|
||||||
|
/// [`std::os::unix::fs::PermissionsExt::mode`] to supply the bitset.
|
||||||
|
fn from(permissions: std::fs::Permissions) -> Self {
|
||||||
|
use std::os::unix::prelude::*;
|
||||||
|
Self::from_unix_mode(permissions.mode())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(not(unix))]
|
||||||
|
impl From<std::fs::Permissions> for Permissions {
|
||||||
|
/// Converts [`std::fs::Permissions`] into [`Permissions`] using the `readonly` flag.
|
||||||
|
///
|
||||||
|
/// This will not set executable flags, but will set all read and write flags with write flags
|
||||||
|
/// being `false` if `readonly`, otherwise set to `true`.
|
||||||
|
fn from(permissions: std::fs::Permissions) -> Self {
|
||||||
|
if permissions.readonly() {
|
||||||
|
Self::readonly()
|
||||||
|
} else {
|
||||||
|
Self::writable()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(unix)]
|
||||||
|
impl From<Permissions> for std::fs::Permissions {
|
||||||
|
/// Converts [`Permissions`] into [`std::fs::Permissions`] using
|
||||||
|
/// [`std::os::unix::fs::PermissionsExt::from_mode`].
|
||||||
|
fn from(permissions: Permissions) -> Self {
|
||||||
|
use std::os::unix::prelude::*;
|
||||||
|
std::fs::Permissions::from_mode(permissions.to_unix_mode())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
bitflags! {
|
||||||
|
struct UnixFilePermissionFlags: u32 {
|
||||||
|
const OWNER_READ = 0o400;
|
||||||
|
const OWNER_WRITE = 0o200;
|
||||||
|
const OWNER_EXEC = 0o100;
|
||||||
|
const GROUP_READ = 0o40;
|
||||||
|
const GROUP_WRITE = 0o20;
|
||||||
|
const GROUP_EXEC = 0o10;
|
||||||
|
const OTHER_READ = 0o4;
|
||||||
|
const OTHER_WRITE = 0o2;
|
||||||
|
const OTHER_EXEC = 0o1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_minimal_permissions_to_json() {
|
||||||
|
let permissions = Permissions {
|
||||||
|
owner_read: None,
|
||||||
|
owner_write: None,
|
||||||
|
owner_exec: None,
|
||||||
|
group_read: None,
|
||||||
|
group_write: None,
|
||||||
|
group_exec: None,
|
||||||
|
other_read: None,
|
||||||
|
other_write: None,
|
||||||
|
other_exec: None,
|
||||||
|
};
|
||||||
|
|
||||||
|
let value = serde_json::to_value(permissions).unwrap();
|
||||||
|
assert_eq!(value, serde_json::json!({}));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_full_permissions_to_json() {
|
||||||
|
let permissions = Permissions {
|
||||||
|
owner_read: Some(true),
|
||||||
|
owner_write: Some(false),
|
||||||
|
owner_exec: Some(true),
|
||||||
|
group_read: Some(false),
|
||||||
|
group_write: Some(true),
|
||||||
|
group_exec: Some(false),
|
||||||
|
other_read: Some(true),
|
||||||
|
other_write: Some(false),
|
||||||
|
other_exec: Some(true),
|
||||||
|
};
|
||||||
|
|
||||||
|
let value = serde_json::to_value(permissions).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
value,
|
||||||
|
serde_json::json!({
|
||||||
|
"owner_read": true,
|
||||||
|
"owner_write": false,
|
||||||
|
"owner_exec": true,
|
||||||
|
"group_read": false,
|
||||||
|
"group_write": true,
|
||||||
|
"group_exec": false,
|
||||||
|
"other_read": true,
|
||||||
|
"other_write": false,
|
||||||
|
"other_exec": true,
|
||||||
|
})
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_minimal_permissions_from_json() {
|
||||||
|
let value = serde_json::json!({});
|
||||||
|
|
||||||
|
let permissions: Permissions = serde_json::from_value(value).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
permissions,
|
||||||
|
Permissions {
|
||||||
|
owner_read: None,
|
||||||
|
owner_write: None,
|
||||||
|
owner_exec: None,
|
||||||
|
group_read: None,
|
||||||
|
group_write: None,
|
||||||
|
group_exec: None,
|
||||||
|
other_read: None,
|
||||||
|
other_write: None,
|
||||||
|
other_exec: None,
|
||||||
|
}
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_full_permissions_from_json() {
|
||||||
|
let value = serde_json::json!({
|
||||||
|
"owner_read": true,
|
||||||
|
"owner_write": false,
|
||||||
|
"owner_exec": true,
|
||||||
|
"group_read": false,
|
||||||
|
"group_write": true,
|
||||||
|
"group_exec": false,
|
||||||
|
"other_read": true,
|
||||||
|
"other_write": false,
|
||||||
|
"other_exec": true,
|
||||||
|
});
|
||||||
|
|
||||||
|
let permissions: Permissions = serde_json::from_value(value).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
permissions,
|
||||||
|
Permissions {
|
||||||
|
owner_read: Some(true),
|
||||||
|
owner_write: Some(false),
|
||||||
|
owner_exec: Some(true),
|
||||||
|
group_read: Some(false),
|
||||||
|
group_write: Some(true),
|
||||||
|
group_exec: Some(false),
|
||||||
|
other_read: Some(true),
|
||||||
|
other_write: Some(false),
|
||||||
|
other_exec: Some(true),
|
||||||
|
}
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_minimal_permissions_to_msgpack() {
|
||||||
|
let permissions = Permissions {
|
||||||
|
owner_read: None,
|
||||||
|
owner_write: None,
|
||||||
|
owner_exec: None,
|
||||||
|
group_read: None,
|
||||||
|
group_write: None,
|
||||||
|
group_exec: None,
|
||||||
|
other_read: None,
|
||||||
|
other_write: None,
|
||||||
|
other_exec: None,
|
||||||
|
};
|
||||||
|
|
||||||
|
// NOTE: We don't actually check the output here because it's an implementation detail
|
||||||
|
// and could change as we change how serialization is done. This is merely to verify
|
||||||
|
// that we can serialize since there are times when serde fails to serialize at
|
||||||
|
// runtime.
|
||||||
|
let _ = rmp_serde::encode::to_vec_named(&permissions).unwrap();
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_full_permissions_to_msgpack() {
|
||||||
|
let permissions = Permissions {
|
||||||
|
owner_read: Some(true),
|
||||||
|
owner_write: Some(false),
|
||||||
|
owner_exec: Some(true),
|
||||||
|
group_read: Some(true),
|
||||||
|
group_write: Some(false),
|
||||||
|
group_exec: Some(true),
|
||||||
|
other_read: Some(true),
|
||||||
|
other_write: Some(false),
|
||||||
|
other_exec: Some(true),
|
||||||
|
};
|
||||||
|
|
||||||
|
// NOTE: We don't actually check the output here because it's an implementation detail
|
||||||
|
// and could change as we change how serialization is done. This is merely to verify
|
||||||
|
// that we can serialize since there are times when serde fails to serialize at
|
||||||
|
// runtime.
|
||||||
|
let _ = rmp_serde::encode::to_vec_named(&permissions).unwrap();
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_minimal_permissions_from_msgpack() {
|
||||||
|
// NOTE: It may seem odd that we are serializing just to deserialize, but this is to
|
||||||
|
// verify that we are not corrupting or preventing issues when serializing on a
|
||||||
|
// client/server and then trying to deserialize on the other side. This has happened
|
||||||
|
// enough times with minor changes that we need tests to verify.
|
||||||
|
let buf = rmp_serde::encode::to_vec_named(&Permissions {
|
||||||
|
owner_read: None,
|
||||||
|
owner_write: None,
|
||||||
|
owner_exec: None,
|
||||||
|
group_read: None,
|
||||||
|
group_write: None,
|
||||||
|
group_exec: None,
|
||||||
|
other_read: None,
|
||||||
|
other_write: None,
|
||||||
|
other_exec: None,
|
||||||
|
})
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
let permissions: Permissions = rmp_serde::decode::from_slice(&buf).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
permissions,
|
||||||
|
Permissions {
|
||||||
|
owner_read: None,
|
||||||
|
owner_write: None,
|
||||||
|
owner_exec: None,
|
||||||
|
group_read: None,
|
||||||
|
group_write: None,
|
||||||
|
group_exec: None,
|
||||||
|
other_read: None,
|
||||||
|
other_write: None,
|
||||||
|
other_exec: None,
|
||||||
|
}
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_full_permissions_from_msgpack() {
|
||||||
|
// NOTE: It may seem odd that we are serializing just to deserialize, but this is to
|
||||||
|
// verify that we are not corrupting or preventing issues when serializing on a
|
||||||
|
// client/server and then trying to deserialize on the other side. This has happened
|
||||||
|
// enough times with minor changes that we need tests to verify.
|
||||||
|
let buf = rmp_serde::encode::to_vec_named(&Permissions {
|
||||||
|
owner_read: Some(true),
|
||||||
|
owner_write: Some(false),
|
||||||
|
owner_exec: Some(true),
|
||||||
|
group_read: Some(true),
|
||||||
|
group_write: Some(false),
|
||||||
|
group_exec: Some(true),
|
||||||
|
other_read: Some(true),
|
||||||
|
other_write: Some(false),
|
||||||
|
other_exec: Some(true),
|
||||||
|
})
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
let permissions: Permissions = rmp_serde::decode::from_slice(&buf).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
permissions,
|
||||||
|
Permissions {
|
||||||
|
owner_read: Some(true),
|
||||||
|
owner_write: Some(false),
|
||||||
|
owner_exec: Some(true),
|
||||||
|
group_read: Some(true),
|
||||||
|
group_write: Some(false),
|
||||||
|
group_exec: Some(true),
|
||||||
|
other_read: Some(true),
|
||||||
|
other_write: Some(false),
|
||||||
|
other_exec: Some(true),
|
||||||
|
}
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,241 @@
|
|||||||
|
use std::fmt;
|
||||||
|
use std::num::ParseIntError;
|
||||||
|
use std::str::FromStr;
|
||||||
|
|
||||||
|
use derive_more::{Display, Error};
|
||||||
|
use serde::{Deserialize, Serialize};
|
||||||
|
|
||||||
|
/// Represents the size associated with a remote PTY
|
||||||
|
#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||||
|
pub struct PtySize {
|
||||||
|
/// Number of lines of text
|
||||||
|
pub rows: u16,
|
||||||
|
|
||||||
|
/// Number of columns of text
|
||||||
|
pub cols: u16,
|
||||||
|
|
||||||
|
/// Width of a cell in pixels. Note that some systems never fill this value and ignore it.
|
||||||
|
#[serde(default)]
|
||||||
|
pub pixel_width: u16,
|
||||||
|
|
||||||
|
/// Height of a cell in pixels. Note that some systems never fill this value and ignore it.
|
||||||
|
#[serde(default)]
|
||||||
|
pub pixel_height: u16,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl PtySize {
|
||||||
|
/// Creates new size using just rows and columns
|
||||||
|
pub fn from_rows_and_cols(rows: u16, cols: u16) -> Self {
|
||||||
|
Self {
|
||||||
|
rows,
|
||||||
|
cols,
|
||||||
|
..Default::default()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl fmt::Display for PtySize {
|
||||||
|
/// Prints out `rows,cols[,pixel_width,pixel_height]` where the
|
||||||
|
/// pixel width and pixel height are only included if either
|
||||||
|
/// one of them is not zero
|
||||||
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||||
|
write!(f, "{},{}", self.rows, self.cols)?;
|
||||||
|
if self.pixel_width > 0 || self.pixel_height > 0 {
|
||||||
|
write!(f, ",{},{}", self.pixel_width, self.pixel_height)?;
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Default for PtySize {
|
||||||
|
fn default() -> Self {
|
||||||
|
PtySize {
|
||||||
|
rows: 24,
|
||||||
|
cols: 80,
|
||||||
|
pixel_width: 0,
|
||||||
|
pixel_height: 0,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Debug, PartialEq, Eq, Display, Error)]
|
||||||
|
pub enum PtySizeParseError {
|
||||||
|
MissingRows,
|
||||||
|
MissingColumns,
|
||||||
|
InvalidRows(ParseIntError),
|
||||||
|
InvalidColumns(ParseIntError),
|
||||||
|
InvalidPixelWidth(ParseIntError),
|
||||||
|
InvalidPixelHeight(ParseIntError),
|
||||||
|
}
|
||||||
|
|
||||||
|
impl FromStr for PtySize {
|
||||||
|
type Err = PtySizeParseError;
|
||||||
|
|
||||||
|
/// Attempts to parse a str into PtySize using one of the following formats:
|
||||||
|
///
|
||||||
|
/// * rows,cols (defaults to 0 for pixel_width & pixel_height)
|
||||||
|
/// * rows,cols,pixel_width,pixel_height
|
||||||
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
||||||
|
let mut tokens = s.split(',');
|
||||||
|
|
||||||
|
Ok(Self {
|
||||||
|
rows: tokens
|
||||||
|
.next()
|
||||||
|
.ok_or(PtySizeParseError::MissingRows)?
|
||||||
|
.trim()
|
||||||
|
.parse()
|
||||||
|
.map_err(PtySizeParseError::InvalidRows)?,
|
||||||
|
cols: tokens
|
||||||
|
.next()
|
||||||
|
.ok_or(PtySizeParseError::MissingColumns)?
|
||||||
|
.trim()
|
||||||
|
.parse()
|
||||||
|
.map_err(PtySizeParseError::InvalidColumns)?,
|
||||||
|
pixel_width: tokens
|
||||||
|
.next()
|
||||||
|
.map(|s| s.trim().parse())
|
||||||
|
.transpose()
|
||||||
|
.map_err(PtySizeParseError::InvalidPixelWidth)?
|
||||||
|
.unwrap_or(0),
|
||||||
|
pixel_height: tokens
|
||||||
|
.next()
|
||||||
|
.map(|s| s.trim().parse())
|
||||||
|
.transpose()
|
||||||
|
.map_err(PtySizeParseError::InvalidPixelHeight)?
|
||||||
|
.unwrap_or(0),
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_json() {
|
||||||
|
let size = PtySize {
|
||||||
|
rows: 10,
|
||||||
|
cols: 20,
|
||||||
|
pixel_width: 30,
|
||||||
|
pixel_height: 40,
|
||||||
|
};
|
||||||
|
|
||||||
|
let value = serde_json::to_value(size).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
value,
|
||||||
|
serde_json::json!({
|
||||||
|
"rows": 10,
|
||||||
|
"cols": 20,
|
||||||
|
"pixel_width": 30,
|
||||||
|
"pixel_height": 40,
|
||||||
|
})
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_minimal_size_from_json() {
|
||||||
|
let value = serde_json::json!({
|
||||||
|
"rows": 10,
|
||||||
|
"cols": 20,
|
||||||
|
});
|
||||||
|
|
||||||
|
let size: PtySize = serde_json::from_value(value).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
size,
|
||||||
|
PtySize {
|
||||||
|
rows: 10,
|
||||||
|
cols: 20,
|
||||||
|
pixel_width: 0,
|
||||||
|
pixel_height: 0,
|
||||||
|
}
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_full_size_from_json() {
|
||||||
|
let value = serde_json::json!({
|
||||||
|
"rows": 10,
|
||||||
|
"cols": 20,
|
||||||
|
"pixel_width": 30,
|
||||||
|
"pixel_height": 40,
|
||||||
|
});
|
||||||
|
|
||||||
|
let size: PtySize = serde_json::from_value(value).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
size,
|
||||||
|
PtySize {
|
||||||
|
rows: 10,
|
||||||
|
cols: 20,
|
||||||
|
pixel_width: 30,
|
||||||
|
pixel_height: 40,
|
||||||
|
}
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_msgpack() {
|
||||||
|
let size = PtySize {
|
||||||
|
rows: 10,
|
||||||
|
cols: 20,
|
||||||
|
pixel_width: 30,
|
||||||
|
pixel_height: 40,
|
||||||
|
};
|
||||||
|
|
||||||
|
// NOTE: We don't actually check the output here because it's an implementation detail
|
||||||
|
// and could change as we change how serialization is done. This is merely to verify
|
||||||
|
// that we can serialize since there are times when serde fails to serialize at
|
||||||
|
// runtime.
|
||||||
|
let _ = rmp_serde::encode::to_vec_named(&size).unwrap();
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_minimal_size_from_msgpack() {
|
||||||
|
// NOTE: It may seem odd that we are serializing just to deserialize, but this is to
|
||||||
|
// verify that we are not corrupting or causing issues when serializing on a
|
||||||
|
// client/server and then trying to deserialize on the other side. This has happened
|
||||||
|
// enough times with minor changes that we need tests to verify.
|
||||||
|
#[derive(Serialize)]
|
||||||
|
struct PartialSize {
|
||||||
|
rows: u16,
|
||||||
|
cols: u16,
|
||||||
|
}
|
||||||
|
let buf = rmp_serde::encode::to_vec_named(&PartialSize { rows: 10, cols: 20 }).unwrap();
|
||||||
|
|
||||||
|
let size: PtySize = rmp_serde::decode::from_slice(&buf).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
size,
|
||||||
|
PtySize {
|
||||||
|
rows: 10,
|
||||||
|
cols: 20,
|
||||||
|
pixel_width: 0,
|
||||||
|
pixel_height: 0,
|
||||||
|
}
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_full_size_from_msgpack() {
|
||||||
|
// NOTE: It may seem odd that we are serializing just to deserialize, but this is to
|
||||||
|
// verify that we are not corrupting or causing issues when serializing on a
|
||||||
|
// client/server and then trying to deserialize on the other side. This has happened
|
||||||
|
// enough times with minor changes that we need tests to verify.
|
||||||
|
let buf = rmp_serde::encode::to_vec_named(&PtySize {
|
||||||
|
rows: 10,
|
||||||
|
cols: 20,
|
||||||
|
pixel_width: 30,
|
||||||
|
pixel_height: 40,
|
||||||
|
})
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
let size: PtySize = rmp_serde::decode::from_slice(&buf).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
size,
|
||||||
|
PtySize {
|
||||||
|
rows: 10,
|
||||||
|
cols: 20,
|
||||||
|
pixel_width: 30,
|
||||||
|
pixel_height: 40,
|
||||||
|
}
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,142 @@
|
|||||||
|
use std::path::PathBuf;
|
||||||
|
|
||||||
|
use serde::{Deserialize, Serialize};
|
||||||
|
|
||||||
|
/// Represents information about a system
|
||||||
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||||
|
pub struct SystemInfo {
|
||||||
|
/// Family of the operating system as described in
|
||||||
|
/// https://doc.rust-lang.org/std/env/consts/constant.FAMILY.html
|
||||||
|
pub family: String,
|
||||||
|
|
||||||
|
/// Name of the specific operating system as described in
|
||||||
|
/// https://doc.rust-lang.org/std/env/consts/constant.OS.html
|
||||||
|
pub os: String,
|
||||||
|
|
||||||
|
/// Architecture of the CPI as described in
|
||||||
|
/// https://doc.rust-lang.org/std/env/consts/constant.ARCH.html
|
||||||
|
pub arch: String,
|
||||||
|
|
||||||
|
/// Current working directory of the running server process
|
||||||
|
pub current_dir: PathBuf,
|
||||||
|
|
||||||
|
/// Primary separator for path components for the current platform
|
||||||
|
/// as defined in https://doc.rust-lang.org/std/path/constant.MAIN_SEPARATOR.html
|
||||||
|
pub main_separator: char,
|
||||||
|
|
||||||
|
/// Name of the user running the server process
|
||||||
|
pub username: String,
|
||||||
|
|
||||||
|
/// Default shell tied to user running the server process
|
||||||
|
pub shell: String,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_json() {
|
||||||
|
let info = SystemInfo {
|
||||||
|
family: String::from("family"),
|
||||||
|
os: String::from("os"),
|
||||||
|
arch: String::from("arch"),
|
||||||
|
current_dir: PathBuf::from("current-dir"),
|
||||||
|
main_separator: '/',
|
||||||
|
username: String::from("username"),
|
||||||
|
shell: String::from("shell"),
|
||||||
|
};
|
||||||
|
|
||||||
|
let value = serde_json::to_value(info).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
value,
|
||||||
|
serde_json::json!({
|
||||||
|
"family": "family",
|
||||||
|
"os": "os",
|
||||||
|
"arch": "arch",
|
||||||
|
"current_dir": "current-dir",
|
||||||
|
"main_separator": '/',
|
||||||
|
"username": "username",
|
||||||
|
"shell": "shell",
|
||||||
|
})
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_from_json() {
|
||||||
|
let value = serde_json::json!({
|
||||||
|
"family": "family",
|
||||||
|
"os": "os",
|
||||||
|
"arch": "arch",
|
||||||
|
"current_dir": "current-dir",
|
||||||
|
"main_separator": '/',
|
||||||
|
"username": "username",
|
||||||
|
"shell": "shell",
|
||||||
|
});
|
||||||
|
|
||||||
|
let info: SystemInfo = serde_json::from_value(value).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
info,
|
||||||
|
SystemInfo {
|
||||||
|
family: String::from("family"),
|
||||||
|
os: String::from("os"),
|
||||||
|
arch: String::from("arch"),
|
||||||
|
current_dir: PathBuf::from("current-dir"),
|
||||||
|
main_separator: '/',
|
||||||
|
username: String::from("username"),
|
||||||
|
shell: String::from("shell"),
|
||||||
|
}
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_msgpack() {
|
||||||
|
let info = SystemInfo {
|
||||||
|
family: String::from("family"),
|
||||||
|
os: String::from("os"),
|
||||||
|
arch: String::from("arch"),
|
||||||
|
current_dir: PathBuf::from("current-dir"),
|
||||||
|
main_separator: '/',
|
||||||
|
username: String::from("username"),
|
||||||
|
shell: String::from("shell"),
|
||||||
|
};
|
||||||
|
|
||||||
|
// NOTE: We don't actually check the output here because it's an implementation detail
|
||||||
|
// and could change as we change how serialization is done. This is merely to verify
|
||||||
|
// that we can serialize since there are times when serde fails to serialize at
|
||||||
|
// runtime.
|
||||||
|
let _ = rmp_serde::encode::to_vec_named(&info).unwrap();
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_from_msgpack() {
|
||||||
|
// NOTE: It may seem odd that we are serializing just to deserialize, but this is to
|
||||||
|
// verify that we are not corrupting or causing issues when serializing on a
|
||||||
|
// client/server and then trying to deserialize on the other side. This has happened
|
||||||
|
// enough times with minor changes that we need tests to verify.
|
||||||
|
let buf = rmp_serde::encode::to_vec_named(&SystemInfo {
|
||||||
|
family: String::from("family"),
|
||||||
|
os: String::from("os"),
|
||||||
|
arch: String::from("arch"),
|
||||||
|
current_dir: PathBuf::from("current-dir"),
|
||||||
|
main_separator: '/',
|
||||||
|
username: String::from("username"),
|
||||||
|
shell: String::from("shell"),
|
||||||
|
})
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
let info: SystemInfo = rmp_serde::decode::from_slice(&buf).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
info,
|
||||||
|
SystemInfo {
|
||||||
|
family: String::from("family"),
|
||||||
|
os: String::from("os"),
|
||||||
|
arch: String::from("arch"),
|
||||||
|
current_dir: PathBuf::from("current-dir"),
|
||||||
|
main_separator: '/',
|
||||||
|
username: String::from("username"),
|
||||||
|
shell: String::from("shell"),
|
||||||
|
}
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,130 @@
|
|||||||
|
use serde::{Deserialize, Serialize};
|
||||||
|
|
||||||
|
use crate::common::{Capabilities, SemVer};
|
||||||
|
|
||||||
|
/// Represents version information.
|
||||||
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
||||||
|
pub struct Version {
|
||||||
|
/// General version of server (arbitrary format)
|
||||||
|
pub server_version: String,
|
||||||
|
|
||||||
|
/// Protocol version
|
||||||
|
pub protocol_version: SemVer,
|
||||||
|
|
||||||
|
/// Capabilities of the server
|
||||||
|
pub capabilities: Capabilities,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use super::*;
|
||||||
|
use crate::common::Capability;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_json() {
|
||||||
|
let version = Version {
|
||||||
|
server_version: String::from("some version"),
|
||||||
|
protocol_version: (1, 2, 3),
|
||||||
|
capabilities: [Capability {
|
||||||
|
kind: String::from("some kind"),
|
||||||
|
description: String::from("some description"),
|
||||||
|
}]
|
||||||
|
.into_iter()
|
||||||
|
.collect(),
|
||||||
|
};
|
||||||
|
|
||||||
|
let value = serde_json::to_value(version).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
value,
|
||||||
|
serde_json::json!({
|
||||||
|
"server_version": "some version",
|
||||||
|
"protocol_version": [1, 2, 3],
|
||||||
|
"capabilities": [{
|
||||||
|
"kind": "some kind",
|
||||||
|
"description": "some description",
|
||||||
|
}]
|
||||||
|
})
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_from_json() {
|
||||||
|
let value = serde_json::json!({
|
||||||
|
"server_version": "some version",
|
||||||
|
"protocol_version": [1, 2, 3],
|
||||||
|
"capabilities": [{
|
||||||
|
"kind": "some kind",
|
||||||
|
"description": "some description",
|
||||||
|
}]
|
||||||
|
});
|
||||||
|
|
||||||
|
let version: Version = serde_json::from_value(value).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
version,
|
||||||
|
Version {
|
||||||
|
server_version: String::from("some version"),
|
||||||
|
protocol_version: (1, 2, 3),
|
||||||
|
capabilities: [Capability {
|
||||||
|
kind: String::from("some kind"),
|
||||||
|
description: String::from("some description"),
|
||||||
|
}]
|
||||||
|
.into_iter()
|
||||||
|
.collect(),
|
||||||
|
}
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_msgpack() {
|
||||||
|
let version = Version {
|
||||||
|
server_version: String::from("some version"),
|
||||||
|
protocol_version: (1, 2, 3),
|
||||||
|
capabilities: [Capability {
|
||||||
|
kind: String::from("some kind"),
|
||||||
|
description: String::from("some description"),
|
||||||
|
}]
|
||||||
|
.into_iter()
|
||||||
|
.collect(),
|
||||||
|
};
|
||||||
|
|
||||||
|
// NOTE: We don't actually check the output here because it's an implementation detail
|
||||||
|
// and could change as we change how serialization is done. This is merely to verify
|
||||||
|
// that we can serialize since there are times when serde fails to serialize at
|
||||||
|
// runtime.
|
||||||
|
let _ = rmp_serde::encode::to_vec_named(&version).unwrap();
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_from_msgpack() {
|
||||||
|
// NOTE: It may seem odd that we are serializing just to deserialize, but this is to
|
||||||
|
// verify that we are not corrupting or causing issues when serializing on a
|
||||||
|
// client/server and then trying to deserialize on the other side. This has happened
|
||||||
|
// enough times with minor changes that we need tests to verify.
|
||||||
|
let buf = rmp_serde::encode::to_vec_named(&Version {
|
||||||
|
server_version: String::from("some version"),
|
||||||
|
protocol_version: (1, 2, 3),
|
||||||
|
capabilities: [Capability {
|
||||||
|
kind: String::from("some kind"),
|
||||||
|
description: String::from("some description"),
|
||||||
|
}]
|
||||||
|
.into_iter()
|
||||||
|
.collect(),
|
||||||
|
})
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
let version: Version = rmp_serde::decode::from_slice(&buf).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
version,
|
||||||
|
Version {
|
||||||
|
server_version: String::from("some version"),
|
||||||
|
protocol_version: (1, 2, 3),
|
||||||
|
capabilities: [Capability {
|
||||||
|
kind: String::from("some kind"),
|
||||||
|
description: String::from("some description"),
|
||||||
|
}]
|
||||||
|
.into_iter()
|
||||||
|
.collect(),
|
||||||
|
}
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,17 @@
|
|||||||
|
mod common;
|
||||||
|
mod msg;
|
||||||
|
mod request;
|
||||||
|
mod response;
|
||||||
|
mod utils;
|
||||||
|
|
||||||
|
pub use common::*;
|
||||||
|
pub use msg::*;
|
||||||
|
pub use request::*;
|
||||||
|
pub use response::*;
|
||||||
|
|
||||||
|
/// Protocol version indicated by the tuple of (major, minor, patch).
|
||||||
|
///
|
||||||
|
/// This is different from the crate version, which matches that of the complete suite of distant
|
||||||
|
/// crates. Rather, this verison is used to provide stability indicators when the protocol itself
|
||||||
|
/// changes across crate versions.
|
||||||
|
pub const PROTOCOL_VERSION: SemVer = (0, 1, 0);
|
||||||
@ -0,0 +1,192 @@
|
|||||||
|
use derive_more::From;
|
||||||
|
use serde::{Deserialize, Serialize};
|
||||||
|
|
||||||
|
/// Represents a wrapper around a message, supporting single and batch payloads.
|
||||||
|
#[derive(Clone, Debug, From, PartialEq, Eq, Serialize, Deserialize)]
|
||||||
|
#[serde(untagged)]
|
||||||
|
pub enum Msg<T> {
|
||||||
|
Single(T),
|
||||||
|
Batch(Vec<T>),
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T> Msg<T> {
|
||||||
|
/// Creates a new msg with a singular payload.
|
||||||
|
#[inline]
|
||||||
|
pub fn single(payload: T) -> Self {
|
||||||
|
Self::Single(payload)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Creates a new msg with a batch payload.
|
||||||
|
pub fn batch<I>(payloads: I) -> Self
|
||||||
|
where
|
||||||
|
I: IntoIterator<Item = T>,
|
||||||
|
{
|
||||||
|
Self::Batch(payloads.into_iter().collect())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns true if msg has a single payload.
|
||||||
|
#[inline]
|
||||||
|
pub fn is_single(&self) -> bool {
|
||||||
|
matches!(self, Self::Single(_))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns reference to single value if msg is single variant.
|
||||||
|
#[inline]
|
||||||
|
pub fn as_single(&self) -> Option<&T> {
|
||||||
|
match self {
|
||||||
|
Self::Single(x) => Some(x),
|
||||||
|
_ => None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns mutable reference to single value if msg is single variant.
|
||||||
|
#[inline]
|
||||||
|
pub fn as_mut_single(&mut self) -> Option<&T> {
|
||||||
|
match self {
|
||||||
|
Self::Single(x) => Some(x),
|
||||||
|
_ => None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the single value if msg is single variant.
|
||||||
|
#[inline]
|
||||||
|
pub fn into_single(self) -> Option<T> {
|
||||||
|
match self {
|
||||||
|
Self::Single(x) => Some(x),
|
||||||
|
_ => None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns true if msg has a batch of payloads.
|
||||||
|
#[inline]
|
||||||
|
pub fn is_batch(&self) -> bool {
|
||||||
|
matches!(self, Self::Batch(_))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns reference to batch value if msg is batch variant.
|
||||||
|
#[inline]
|
||||||
|
pub fn as_batch(&self) -> Option<&[T]> {
|
||||||
|
match self {
|
||||||
|
Self::Batch(x) => Some(x),
|
||||||
|
_ => None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns mutable reference to batch value if msg is batch variant.
|
||||||
|
#[inline]
|
||||||
|
pub fn as_mut_batch(&mut self) -> Option<&mut [T]> {
|
||||||
|
match self {
|
||||||
|
Self::Batch(x) => Some(x),
|
||||||
|
_ => None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the batch value if msg is batch variant.
|
||||||
|
#[inline]
|
||||||
|
pub fn into_batch(self) -> Option<Vec<T>> {
|
||||||
|
match self {
|
||||||
|
Self::Batch(x) => Some(x),
|
||||||
|
_ => None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convert into a collection of payload data.
|
||||||
|
#[inline]
|
||||||
|
pub fn into_vec(self) -> Vec<T> {
|
||||||
|
match self {
|
||||||
|
Self::Single(x) => vec![x],
|
||||||
|
Self::Batch(x) => x,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
mod single {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_json() {
|
||||||
|
let msg = Msg::single("hello world");
|
||||||
|
|
||||||
|
let value = serde_json::to_value(msg).unwrap();
|
||||||
|
assert_eq!(value, serde_json::json!("hello world"));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_from_json() {
|
||||||
|
let value = serde_json::json!("hello world");
|
||||||
|
|
||||||
|
let msg: Msg<String> = serde_json::from_value(value).unwrap();
|
||||||
|
assert_eq!(msg, Msg::single(String::from("hello world")));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_msgpack() {
|
||||||
|
let msg = Msg::single("hello world");
|
||||||
|
|
||||||
|
// NOTE: We don't actually check the output here because it's an implementation detail
|
||||||
|
// and could change as we change how serialization is done. This is merely to verify
|
||||||
|
// that we can serialize since there are times when serde fails to serialize at
|
||||||
|
// runtime.
|
||||||
|
let _ = rmp_serde::encode::to_vec_named(&msg).unwrap();
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_from_msgpack() {
|
||||||
|
// NOTE: It may seem odd that we are serializing just to deserialize, but this is to
|
||||||
|
// verify that we are not corrupting or causing issues when serializing on a
|
||||||
|
// client/server and then trying to deserialize on the other side. This has happened
|
||||||
|
// enough times with minor changes that we need tests to verify.
|
||||||
|
let buf = rmp_serde::encode::to_vec_named(&Msg::single("hello world")).unwrap();
|
||||||
|
|
||||||
|
let msg: Msg<String> = rmp_serde::decode::from_slice(&buf).unwrap();
|
||||||
|
assert_eq!(msg, Msg::single(String::from("hello world")));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
mod batch {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_json() {
|
||||||
|
let msg = Msg::batch(["hello world"]);
|
||||||
|
|
||||||
|
let value = serde_json::to_value(msg).unwrap();
|
||||||
|
assert_eq!(value, serde_json::json!(["hello world"]));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_from_json() {
|
||||||
|
let value = serde_json::json!(["hello world"]);
|
||||||
|
|
||||||
|
let msg: Msg<String> = serde_json::from_value(value).unwrap();
|
||||||
|
assert_eq!(msg, Msg::batch([String::from("hello world")]));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_serialize_to_msgpack() {
|
||||||
|
let msg = Msg::batch(["hello world"]);
|
||||||
|
|
||||||
|
// NOTE: We don't actually check the output here because it's an implementation detail
|
||||||
|
// and could change as we change how serialization is done. This is merely to verify
|
||||||
|
// that we can serialize since there are times when serde fails to serialize at
|
||||||
|
// runtime.
|
||||||
|
let _ = rmp_serde::encode::to_vec_named(&msg).unwrap();
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn should_be_able_to_deserialize_from_msgpack() {
|
||||||
|
// NOTE: It may seem odd that we are serializing just to deserialize, but this is to
|
||||||
|
// verify that we are not corrupting or causing issues when serializing on a
|
||||||
|
// client/server and then trying to deserialize on the other side. This has happened
|
||||||
|
// enough times with minor changes that we need tests to verify.
|
||||||
|
let buf = rmp_serde::encode::to_vec_named(&Msg::batch(["hello world"])).unwrap();
|
||||||
|
|
||||||
|
let msg: Msg<String> = rmp_serde::decode::from_slice(&buf).unwrap();
|
||||||
|
assert_eq!(msg, Msg::batch([String::from("hello world")]));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1,68 +0,0 @@
|
|||||||
use indoc::indoc;
|
|
||||||
use rstest::*;
|
|
||||||
|
|
||||||
use crate::cli::fixtures::*;
|
|
||||||
|
|
||||||
const EXPECTED_TABLE: &str = indoc! {"
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| kind | description |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| cancel_search | Supports canceling an active search against the filesystem |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| capabilities | Supports retrieving capabilities |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| copy | Supports copying files, directories, and symlinks |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| dir_create | Supports creating directory |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| dir_read | Supports reading directory |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| exists | Supports checking if a path exists |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| file_append | Supports appending to binary file |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| file_append_text | Supports appending to text file |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| file_read | Supports reading binary file |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| file_read_text | Supports reading text file |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| file_write | Supports writing binary file |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| file_write_text | Supports writing text file |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| metadata | Supports retrieving metadata about a file, directory, or symlink |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| proc_kill | Supports killing a spawned process |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| proc_resize_pty | Supports resizing the pty of a spawned process |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| proc_spawn | Supports spawning a process |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| proc_stdin | Supports sending stdin to a spawned process |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| remove | Supports removing files, directories, and symlinks |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| rename | Supports renaming files, directories, and symlinks |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| search | Supports searching filesystem using queries |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| set_permissions | Supports setting permissions on a file, directory, or symlink |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| system_info | Supports retrieving system information |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| unwatch | Supports unwatching filesystem for changes |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
| watch | Supports watching filesystem for changes |
|
|
||||||
+------------------+------------------------------------------------------------------+
|
|
||||||
"};
|
|
||||||
|
|
||||||
#[rstest]
|
|
||||||
#[test_log::test]
|
|
||||||
fn should_output_capabilities(ctx: DistantManagerCtx) {
|
|
||||||
ctx.cmd("capabilities")
|
|
||||||
.assert()
|
|
||||||
.success()
|
|
||||||
.stdout(EXPECTED_TABLE)
|
|
||||||
.stderr("");
|
|
||||||
}
|
|
||||||
@ -0,0 +1,34 @@
|
|||||||
|
use distant_core::protocol::PROTOCOL_VERSION;
|
||||||
|
use rstest::*;
|
||||||
|
|
||||||
|
use crate::cli::fixtures::*;
|
||||||
|
use crate::cli::utils::TrimmedLinesMatchPredicate;
|
||||||
|
|
||||||
|
#[rstest]
|
||||||
|
#[test_log::test]
|
||||||
|
fn should_output_capabilities(ctx: DistantManagerCtx) {
|
||||||
|
// Because all of our crates have the same version, we can expect it to match
|
||||||
|
let package_name = "distant-core";
|
||||||
|
let package_version = env!("CARGO_PKG_VERSION");
|
||||||
|
let (major, minor, patch) = PROTOCOL_VERSION;
|
||||||
|
|
||||||
|
// Since our client and server are built the same, all capabilities should be listed with +
|
||||||
|
// and using 4 columns since we are not using a tty
|
||||||
|
let expected = indoc::formatdoc! {"
|
||||||
|
Client: distant {package_version} (Protocol {major}.{minor}.{patch})
|
||||||
|
Server: {package_name} {package_version} (Protocol {major}.{minor}.{patch})
|
||||||
|
Capabilities supported (+) or not (-):
|
||||||
|
+cancel_search +copy +dir_create +dir_read
|
||||||
|
+exists +file_append +file_append_text +file_read
|
||||||
|
+file_read_text +file_write +file_write_text +metadata
|
||||||
|
+proc_kill +proc_resize_pty +proc_spawn +proc_stdin
|
||||||
|
+remove +rename +search +set_permissions
|
||||||
|
+system_info +unwatch +version +watch
|
||||||
|
"};
|
||||||
|
|
||||||
|
ctx.cmd("version")
|
||||||
|
.assert()
|
||||||
|
.success()
|
||||||
|
.stdout(TrimmedLinesMatchPredicate::new(expected))
|
||||||
|
.stderr("");
|
||||||
|
}
|
||||||
@ -1,9 +1,12 @@
|
|||||||
use predicates::prelude::*;
|
use ::predicates::prelude::*;
|
||||||
|
|
||||||
|
mod predicates;
|
||||||
mod reader;
|
mod reader;
|
||||||
|
|
||||||
|
pub use self::predicates::TrimmedLinesMatchPredicate;
|
||||||
pub use reader::ThreadedReader;
|
pub use reader::ThreadedReader;
|
||||||
|
|
||||||
/// Produces a regex predicate using the given string
|
/// Produces a regex predicate using the given string
|
||||||
pub fn regex_pred(s: &str) -> predicates::str::RegexPredicate {
|
pub fn regex_pred(s: &str) -> ::predicates::str::RegexPredicate {
|
||||||
predicate::str::is_match(s).unwrap()
|
predicate::str::is_match(s).unwrap()
|
||||||
}
|
}
|
||||||
|
|||||||
@ -0,0 +1,50 @@
|
|||||||
|
use predicates::reflection::PredicateReflection;
|
||||||
|
use predicates::Predicate;
|
||||||
|
use std::fmt;
|
||||||
|
|
||||||
|
/// Checks if lines of text match the provided, trimming each line
|
||||||
|
/// of both before comparing.
|
||||||
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||||
|
pub struct TrimmedLinesMatchPredicate {
|
||||||
|
pattern: String,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl TrimmedLinesMatchPredicate {
|
||||||
|
pub fn new(pattern: impl Into<String>) -> Self {
|
||||||
|
Self {
|
||||||
|
pattern: pattern.into(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl fmt::Display for TrimmedLinesMatchPredicate {
|
||||||
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||||
|
write!(f, "trimmed_lines expects {}", self.pattern)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Predicate<str> for TrimmedLinesMatchPredicate {
|
||||||
|
fn eval(&self, variable: &str) -> bool {
|
||||||
|
let mut expected = self.pattern.lines();
|
||||||
|
let mut actual = variable.lines();
|
||||||
|
|
||||||
|
// Fail if we don't have the same number of lines
|
||||||
|
// or of the trimmed result of lines don't match
|
||||||
|
//
|
||||||
|
// Otherwise if we finish processing all lines,
|
||||||
|
// we are a success
|
||||||
|
loop {
|
||||||
|
match (expected.next(), actual.next()) {
|
||||||
|
(Some(expected), Some(actual)) => {
|
||||||
|
if expected.trim() != actual.trim() {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
(None, None) => return true,
|
||||||
|
_ => return false,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl PredicateReflection for TrimmedLinesMatchPredicate {}
|
||||||
Loading…
Reference in New Issue