Enum FilesystemOperation 

pub enum FilesystemOperation {
    CreateDirectory {
        path: AbsolutePath,
        parents: bool,
    },
    PutFile {
        path: AbsolutePath,
        content_ref: ContentRef,
        behavior: DestinationBehavior,
        expected_revision_no: Option<RevisionNo>,
    },
    DeletePath {
        path: AbsolutePath,
        behavior: DeleteDirectoryBehavior,
        expected_inode_id: Option<InodeId>,
    },
    MovePath {
        from_path: AbsolutePath,
        to_path: AbsolutePath,
        behavior: DestinationBehavior,
    },
    CopyPath {
        from_path: AbsolutePath,
        to_path: AbsolutePath,
        behavior: DestinationBehavior,
    },
    Undelete {
        inode_id: InodeId,
        deletion_seq: ChangeSeq,
        path: Option<AbsolutePath>,
    },
    RestoreRevision {
        path: AbsolutePath,
        source_revision_no: RevisionNo,
    },
    UpdateAttributes {
        path: AbsolutePath,
        set: BTreeMap<AttributeKey, AttributeValue>,
        remove: Vec<AttributeKey>,
        expected_inode_id: Option<InodeId>,
        expected_attributes_revision_no: Option<AttributeRevisionNo>,
    },
}

One path-oriented filesystem operation.

Unknown fields are rejected because concurrency guards are optional. A misspelled guard must fail decoding instead of silently becoming None and allowing an unguarded write. Any future fieldless variant must use empty braces so serde also rejects unexpected fields for that variant.

Variants

CreateDirectory

Create one directory.

Fields

path: AbsolutePath

Absolute destination path, rejected when invalid or already bound.

parents: bool

Also create missing ancestor directories (the same auto-create put_file performs). The final component must still be new.

PutFile

Create or replace one file with an already-durable content ref.

Fields

path: AbsolutePath

Absolute destination path; missing ancestors are created automatically.

content_ref: ContentRef

Immutable bytes that must be covered by a valid preparation proof.

behavior: DestinationBehavior

Whether an existing file may receive a new revision instead of causing a conflict.

expected_revision_no: Option<RevisionNo>

When set (with replace behavior), the put applies only while the file’s current revision is still this one; a raced write fails the request instead of silently stacking on it, and a missing file answers path_not_found.

DeletePath

Delete one path.

Fields

path: AbsolutePath

Absolute path that must resolve to a visible inode.

behavior: DeleteDirectoryBehavior

Whether a non-empty directory may be tombstoned recursively.

expected_inode_id: Option<InodeId>

When set, the delete applies only if the path still resolves to this inode; a raced rebinding fails the request instead of deleting (and reporting a recovery handle for) the wrong inode.

MovePath

Move one path to another path.

Fields

from_path: AbsolutePath

Absolute source path that must resolve to a visible inode.

to_path: AbsolutePath

Absolute destination whose parent must be visible and writable.

behavior: DestinationBehavior

Whether an existing destination file may be replaced.

CopyPath

Copy one file path to another path.

Fields

from_path: AbsolutePath

Absolute source path that must resolve to a visible file.

to_path: AbsolutePath

Absolute destination whose parent must be visible and writable.

behavior: DestinationBehavior

Whether an existing destination file may receive a copied revision.

Undelete

Restore a deleted file or subtree.

inode_id and deletion_seq identify one exact deletion. A stale sequence returns not_deleted and cannot undo a later deletion.

Fields

inode_id: InodeId

Deleted inode to make reachable again.

deletion_seq: ChangeSeq

Observed deletion sequence, which prevents cancelling a newer tombstone generation.

path: Option<AbsolutePath>

Optional destination for the restored inode.

When absent, the inode is rebound to the parent and name recorded by the deletion. Parent identity, rather than an old path string, keeps this correct after ancestor renames. An explicit path is required when the deletion recorded no binding.

RestoreRevision

Restore an older revision as the current revision for a path.

Fields

path: AbsolutePath

Absolute path that must resolve to a visible file.

source_revision_no: RevisionNo

Existing historical revision whose content will be copied into a new current revision.

UpdateAttributes

Write and remove attributes on the inode one path resolves to.

Fields

path: AbsolutePath

Absolute path that must resolve to a visible file or directory.

set: BTreeMap<AttributeKey, AttributeValue>

Attributes to write. Each key replaces whatever the inode currently holds under it; keys the inode holds and this map does not name are left alone.

remove: Vec<AttributeKey>

Attribute keys to remove.

A list preserves duplicate entries so validation can report them instead of silently deduplicating the request.

expected_inode_id: Option<InodeId>

When set, the update applies only if the path still resolves to this inode; a raced rebinding fails the request instead of writing attributes onto the wrong inode.

expected_attributes_revision_no: Option<AttributeRevisionNo>

When set, the update applies only while the inode’s attribute revision is still this one. Absent means the update is applied over whatever revision is current; either way the write carries its own revision guard, so a concurrent update never merges silently.

Trait Implementations

impl Clone for FilesystemOperation

fn clone(&self) -> FilesystemOperation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FilesystemOperation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FilesystemOperation

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for FilesystemOperation

impl PartialEq for FilesystemOperation

fn eq(&self, other: &FilesystemOperation) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for FilesystemOperation

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for FilesystemOperation