Struct ProcessSyncEnv 

pub struct ProcessSyncEnv { /* private fields */ }

Runs folder transfers as operating-system processes.

Implementations

impl ProcessSyncEnv

pub fn new(observations: Sender<SyncObservation>) -> Self

Runs transfers, stating every observation it reads to the given receiver.

pub const fn held( observations: Sender<SyncObservation>, hold: ProcessHold, ) -> Self

Runs transfers that whoever holds this handle can hold still and let go again.

Trait Implementations

impl Debug for ProcessSyncEnv

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl RsyncEndpointAlg for ProcessSyncEnv

where RsyncSyntax: RsyncEndpointAlg,

fn endpoint( &self, user: Option<String>, host: Option<String>, path: impl Into<String>, ) -> Self::Endpoint

Defines one endpoint from the account, the machine, and the path it names.

impl RsyncEndpointViewAlg for ProcessSyncEnv

where RsyncSyntax: RsyncEndpointViewAlg,

fn endpoint_user<'a>(&self, endpoint: &'a Self::Endpoint) -> Option<&'a str>

Observes the account the far end is reached as, when one was stated.

fn endpoint_host<'a>(&self, endpoint: &'a Self::Endpoint) -> Option<&'a str>

Observes the machine the path rests on, and states nothing when the path is here.

fn endpoint_path<'a>(&self, endpoint: &'a Self::Endpoint) -> &'a str

Observes the path itself.

impl RsyncSorts for ProcessSyncEnv

type Endpoint = RsyncEndpoint

Represents one end of a transfer.

type Command = SyncCommand

Represents exactly the command one transfer runs.

type Observation = SyncObservation

Represents one thing a running transfer states.

type Change = PlannedChange

Represents one path a transfer would change.

impl SyncChangeAlg for ProcessSyncEnv

where RsyncSyntax: SyncChangeAlg,

fn sync_change( &self, path: impl Into<String>, kind: ChangeKind, size: Option<u64>, ) -> Self::Change

Defines one change from the path it names, what happens to it, and what it moves.

impl SyncCommandAlg for ProcessSyncEnv

where RsyncSyntax: SyncCommandAlg,

fn sync_command( &self, program: impl Into<String>, arguments: impl IntoIterator<Item = String>, ) -> Self::Command

Defines the command running one program with exactly these arguments, in this order.

impl SyncCommandViewAlg for ProcessSyncEnv

where RsyncSyntax: SyncCommandViewAlg,

fn command_program<'a>(&self, command: &'a Self::Command) -> &'a str

Observes the program the transfer is performed by.

fn command_arguments<'a>( &self, command: &'a Self::Command, ) -> impl Iterator<Item = &'a str>

Observes every argument, in the order the program is given them.

impl SyncObservationAlg for ProcessSyncEnv

where RsyncSyntax: SyncObservationAlg,

fn observed_change(&self, change: Self::Change) -> Self::Observation

Defines the observation of one path the transfer would change, or has changed.

fn observed_progress(&self, transferred: u64, percent: u16) -> Self::Observation

Defines the observation of how far the whole transfer has come.

fn observed_nothing(&self) -> Self::Observation

Defines the observation of a line naming nothing this specification reads.

impl SyncObservationViewAlg for ProcessSyncEnv

where RsyncSyntax: SyncObservationViewAlg,

fn observation_change<'a>( &self, observation: &'a Self::Observation, ) -> Option<&'a Self::Change>

Observes the changed path, exactly when the observation states one.

fn observation_progress( &self, observation: &Self::Observation, ) -> Option<(u64, u16)>

Observes the bytes moved and the share completed, exactly when the observation states them.

impl SyncRunAlg for ProcessSyncEnv

type Error = ProcessSyncError

Denotes failure to run the transfer.

type Run = SyncRun

Carries one running transfer.

fn start_sync(&self, command: &Self::Command) -> Result<Self::Run, Self::Error>

Starts one transfer command.

fn next_sync_line( &self, run: &mut Self::Run, ) -> Result<Option<String>, Self::Error>

Reads the next line the running transfer wrote, and states when it has written its last.

fn finish_sync(&self, run: Self::Run) -> Result<(), Self::Error>

Waits for the transfer to end and states whether it ended well.

impl SyncWatchAlg for ProcessSyncEnv

fn watch_sync(&self, observation: &Self::Observation)

Applies one observation of the running transfer.