Struct Remote 

pub struct Remote { /* private fields */ }

Another machine, reached through a transport (see the module docs). Its paths are that machine’s: absolute, or under ~, its user’s home; a relative path is relative to that home, where the transport starts. Paths are folded without asking the machine (canonical), so links there are not followed.

Implementations

impl Remote

pub fn new( name: impl Into<String>, transport: impl IntoIterator<Item = impl Into<OsString>>, launcher: Launcher, ) -> Result<Self>

The machine name, such as bench, reached through transport, such as ["ssh", "dev@box"], which file operations start under launcher’s policy (its wrapper and variables; not its directory).

Errors

An InvalidInput error when name is empty or holds a :, / or space, or transport is empty.

pub fn name(&self) -> &str

Its name.

Trait Implementations

impl Clone for Remote

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Remote

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

Formats the value using the given formatter.

impl Workspace for Remote

fn host(&self) -> Option<&str>

Its name.

fn excerpt(&self, path: &Path, first: usize, count: usize) -> Result<Excerpt>

One script that sends the file’s size, its line count, its hash and only the lines asked, or the whole file when it is at most MAX_BYTES, all of a copy made aside first, so they agree when the file changes meanwhile. A machine with neither sha256sum nor shasum sends a larger file whole in a second call, to hash it here.

fn read_files(&self, paths: &[PathBuf], limit: u64) -> Vec<Option<Vec<u8>>>

The files in scripts of 100 each, every file copied aside before it is sent, so one that changes meanwhile is sent whole as it was.

fn write(&self, path: &Path, bytes: &[u8]) -> Result<()>

replaces it, sending back nothing of what it held.

fn replace( &self, path: &Path, bytes: &[u8], limit: u64, ) -> Result<Result<Contents>>

Writes a temporary file beside it and moves it over the file, so a lost connection never leaves it half written, keeping an existing file’s permissions; the copy the temporary file starts as is what is sent back, in the same call.

fn write_if( &self, path: &Path, bytes: &[u8], held: &ContentHash, ) -> Result<Option<Contents>>

One script: a copy of the file is made beside it and hashed there, then filled with bytes and moved over the file when the hash is held, or sent back when it is not. A machine with neither sha256sum nor shasum always sends it back.

fn canonical(&self, path: &Path) -> PathBuf

Folds . and .. without asking the machine, a relative path under ~; a .. above ~ stays, as the remote sh reads it.

fn files( &self, root: &Path, glob: Option<&str>, listing: Listing, ) -> Result<Vec<PathBuf>>

As git lists them there in a git work tree (unless listing is All), else as find does, then filtered by Listing::keeps and glob.

fn spawn( &self, launcher: &Launcher, dir: Option<&Path>, program: &OsStr, args: &[OsString], how: Spawn, ) -> Result<Process>

Runs program there in dir (None: the remote home) with sh -l, so the remote user’s login environment holds, and the launcher’s variables, from a local transport started under the launcher’s wrapper (the launcher’s directory is this machine’s, so it is not used). The process is marked through this host: stopping it stops the local transport (SIGTERM, then SIGKILL), and whether that stops the command there is the transport’s to say.

fn stat(&self, path: &Path) -> Result<Stat>

What path is, its links followed: a file (its size, whether it is read-only, when it was last changed), a directory, something else, or nothing.

fn read(&self, path: &Path, limit: u64) -> Result<Contents>

Up to limit bytes of the regular file path, and its whole size. Anything but a regular file is refused without being opened: opening a FIFO or a device can block forever.

fn remove(&self, path: &Path) -> Result<()>

Removes the file path; a directory is refused.

fn rename(&self, from: &Path, to: &Path) -> Result<()>

Moves the file from to to, creating to’s directory and replacing a file there.

fn join(&self, base: &Path, path: &Path) -> PathBuf

path relative to base, as resolve joins them: base.join(path), so an absolute path stays as it is. A workspace whose paths can name another machine, such as Hosts, keeps such a path whole too.

fn watch( self: Arc<Self>, root: &Path, recursive: bool, listing: Listing, ) -> Result<Watch>

Watches root, a file or a directory (with recursive, every directory under it too), from now on: a batch of the paths created, changed or removed each time something changed, of the files files would list with listing. Dropping the Watch stops it. To miss nothing, list the files once after the watch has started.