Struct Client 

pub struct Client { /* private fields */ }

Client for one mount. Cheap to clone, clones share the pool, the listeners and the event dispatcher. The last clone to drop closes everything. close does it at once for all clones.

Implementations

impl Client

pub fn stat_batch(&self, paths: &[String]) -> Result<Vec<StatResult>>

Returns attributes for many paths. The result has one entry per path in input order. Large inputs are split into several requests that run in parallel on the pool.

pub fn read_file(&self, path: &str) -> Result<Vec<u8>>

Reads a whole file. A file that fits in one payload takes one request. A larger file is opened and read in chunks until end of file.

pub fn write_file(&self, path: &str, data: &[u8], truncate: bool) -> Result<()>

Writes a whole file, creating it when missing. With truncate the old content is dropped first. Data larger than one payload is written through an opened file in chunks.

impl Client

pub fn connect(path: impl AsRef<Path>) -> Result<Client>

Connects with default options (4 connections).

pub fn connect_with(path: impl AsRef<Path>, opts: Options) -> Result<Client>

Connects with the given options. The first connection and handshake happen now, so a bad socket or version mismatch fails here.

pub fn close(&self)

Ends all connections, watches and background threads. Later calls fail with an I/O error of kind ConnectionAborted. Dropping the last clone does the same.

pub fn open(&self, path: &str, flags: u32, mode: u32) -> Result<File>

Opens a file. flags combine open_flag values. The file stays bound to the connection that opened it.

pub fn utimens( &self, path: &str, atime_ns: Option<i64>, mtime_ns: Option<i64>, ) -> Result<()>

Sets times in nanoseconds since the epoch. None leaves that time unchanged.

pub fn opendir(&self, path: &str) -> Result<Dir>

Opens a directory for paged listing. The directory stays bound to the connection that opened it.

pub fn ls( &self, path: &str, max_entries: u32, cursor: &str, ) -> Result<(Vec<DirEntry>, String)>

Lists up to max_entries entries with their attributes. Pass an empty cursor to start, then the returned cursor to continue. An empty returned cursor means the listing is complete.

impl Client

pub fn add_listener( &self, f: impl Fn(&Event) + Send + Sync + 'static, ) -> ListenerId

Adds a listener. Every listener gets every event, in order, on the dispatcher thread of this client. The call must return quickly. A slow listener makes the queue (1024 events) drop its oldest events, and every listener then gets one local Overflow event. A panic in a listener is caught and logged. With no listener, events go to the logger. A listener that holds a Client clone keeps the client open until close is called.

pub fn remove_listener(&self, id: ListenerId)

Removes a listener. An unknown id does nothing.

pub fn wait_warm(&self, id: u64, timeout: Duration) -> Result<()>

Waits until warm request id is done. A failed warm returns its failure as Error::Server. Waiting longer than timeout returns an I/O error of kind TimedOut. The client keeps the last 1024 finished warms, so a warm that ended before this call is not missed. The server is not polled.

impl Client

pub fn ping(&self) -> Result<()>

Checks that the server answers.

pub fn stat(&self, path: &str) -> Result<FileInfo>

Returns attributes for path.

pub fn lstat(&self, path: &str) -> Result<FileInfo>

Returns attributes for path without following a final symlink.

pub fn mkdir(&self, path: &str, mode: u32) -> Result<()>

Creates a directory.

pub fn rmdir(&self, path: &str) -> Result<()>

Removes an empty directory.

pub fn unlink(&self, path: &str) -> Result<()>

Removes a file.

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

Moves from to to.

pub fn symlink(&self, target: &str, link_path: &str) -> Result<()>

Creates link_path pointing at target.

pub fn readlink(&self, path: &str) -> Result<String>

Returns the target of the symlink at path.

pub fn link(&self, existing: &str, new_path: &str) -> Result<()>

Creates new_path as a hard link to existing.

pub fn chmod(&self, path: &str, mode: u32) -> Result<()>

Sets the mode of path.

pub fn truncate(&self, path: &str, size: i64) -> Result<()>

Sets the size of the file at path.

pub fn statfs(&self, path: &str) -> Result<StatfsInfo>

Returns capacity figures for the filesystem holding path.

pub fn access(&self, path: &str, mode: u32) -> Result<()>

Checks permissions for path. mode is a bit mask of 4 (read), 2 (write), 1 (execute), or 0 (exists).

pub fn remove_all(&self, path: &str) -> Result<u64>

Removes path and everything below it. Returns the removed entry count.

pub fn warm_open(&self, path: &str) -> Result<u64>

Starts warming the file in the background and returns a warm id at once. A missing file is reported later as a warm_failed notice on the same connection. Fails at once when the mount has no local cache.

pub fn warm_read(&self, path: &str, offset: i64, length: i64) -> Result<u64>

Starts reading a file in the background to warm the cache and returns a warm id at once. Offset 0 and length 0, the defaults, warm the whole file. A length of 0 with an offset warms to the end of the file.

impl Client

pub fn read_dir_all(&self, path: &str) -> Result<Vec<DirEntry>>

Lists one directory completely by following the ls cursor. Fails with Error::TooManyEntries when the directory has more than DEFAULT_MAX_DIR_ENTRIES entries.

pub fn read_dir_all_max( &self, path: &str, max_entries: usize, ) -> Result<Vec<DirEntry>>

Like read_dir_all with a caller-chosen entry limit.

pub fn walk( &self, path: &str, f: impl FnMut(&str, &DirEntry) -> Result<()>, ) -> Result<()>

Visits every entry below path, depth first. f gets the directory path and the entry, which carries its attributes. The entries of a directory arrive in listing order and each subdirectory is visited after the directory that holds it. Symlinks are reported and not followed. The walk stops at the first error from ls or from f and returns it. No entry is skipped silently. The walk holds one page plus the queued directories, at most DEFAULT_MAX_WALK_PENDING, and fails with Error::TooManyEntries beyond that.

pub fn walk_max( &self, path: &str, max_pending: usize, f: impl FnMut(&str, &DirEntry) -> Result<()>, ) -> Result<()>

Like walk with a caller-chosen limit on queued directories.

impl Client

pub fn watch(&self, path: &str, recursive: bool, since: u64) -> Result<Watch>

Starts a watch on path. since asks for events after that sequence. The server keeps no history, so an older value yields one Overflow event. Pass 0 for new events only.

Trait Implementations

impl Clone for Client

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.