Struct File 

pub struct File { /* private fields */ }

An open file. All I/O is positioned (pread/pwrite); there is no shared cursor, so an Arc<File> is safe to use from many tasks at once.

A handle from crate::FailoverClient is failover-aware: each op is bounded by a timeout and, on a transport failure or a hang against a dead/frozen leader, the handle re-opens the path on the re-probed leader and retries. A handle from a plain crate::Client is bound to its one connection.

Implementations

impl File

pub async fn read_at(&self, offset: u64, len: u32) -> Result<Bytes, ZeroFsError>

Read up to len bytes at offset; a shorter result means EOF. Returns bytes::Bytes: a read served by one round trip comes back with no copy.

pub async fn write_at( &self, offset: u64, data: &[u8], ) -> Result<(), ZeroFsError>

Write all of data at offset (any size, chunked internally); errors on a short write.

pub async fn metadata(&self) -> Result<Metadata, ZeroFsError>

Current metadata of this open file (fstat).

pub async fn set_len(&self, size: u64) -> Result<(), ZeroFsError>

Truncate or extend to size bytes.

pub async fn set_attr(&self, attrs: SetAttrs) -> Result<Metadata, ZeroFsError>

Apply metadata changes through this handle.

pub async fn sync_all(&self) -> Result<(), ZeroFsError>

Flush data and metadata to durable (S3-backed) storage.

Against a .zerofs4 server this is a verified fsync: success means every write acked on this handle before it is durable and survives any failover. If the durability lineage broke (a failover the surviving node could not prove it inherited), it returns ZeroFsError::Stale rather than report success: treat the prior writes as lost, redo them, and call sync_all again. A pre-.zerofs4 server gives a plain, unverified flush.

pub async fn sync_data(&self) -> Result<(), ZeroFsError>

Flush file data only. Like Self::sync_all this is verified against a .zerofs4 server: it returns ZeroFsError::Stale if the prior writes’ lineage broke, rather than report success.

pub async fn close(&self)

Mark the handle closed (later calls return Closed). The fid is clunked and its number recycled when the handle is dropped (for scope-bound use, right after this call). Always succeeds; idempotent; never blocks.

pub fn cursor(self: &Arc<File>) -> FileCursor

An independent AsyncRead + AsyncWrite + AsyncSeek cursor over this file, starting at offset 0. Multiple cursors over one File are safe: each carries its own position and the underlying I/O is positioned. Rust-only sugar (tokio-io feature); never crosses FFI.

Trait Implementations

impl Debug for File

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

Formats the value using the given formatter.