Enum FilesystemOperation 

pub enum FilesystemOperation {
    CreateDirectory {
        path: AbsolutePath,
        parents: bool,
    },
    CreateDirectoryByInode {
        parent_inode_id: InodeId,
        display_name: DisplayName,
    },
    PutFile {
        path: AbsolutePath,
        content_ref: ContentRef,
        behavior: DestinationBehavior,
        expected_revision_no: Option<RevisionNo>,
    },
    PutFileByInode {
        parent_inode_id: InodeId,
        display_name: DisplayName,
        content_ref: ContentRef,
    },
    PutFileRevisionByInode {
        inode_id: InodeId,
        content_ref: ContentRef,
        expected_revision_no: RevisionNo,
    },
    DeletePath {
        path: AbsolutePath,
        behavior: DeleteDirectoryBehavior,
        expected_inode_id: Option<InodeId>,
    },
    DeleteByInode {
        inode_id: InodeId,
        expected_binding_generation: String,
        behavior: DeleteDirectoryBehavior,
    },
    MovePath {
        from_path: AbsolutePath,
        to_path: AbsolutePath,
        behavior: DestinationBehavior,
    },
    MoveByInode {
        inode_id: InodeId,
        expected_binding_generation: String,
        to_parent_inode_id: InodeId,
        to_display_name: DisplayName,
        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 filesystem operation.

Unknown fields are rejected so a misspelled concurrency guard cannot be ignored. Fieldless variants must use empty braces so serde rejects unexpected fields.

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.

CreateDirectoryByInode

Create a directory under an existing parent inode.

Fields

parent_inode_id: InodeId

Parent directory.

display_name: DisplayName

New directory name.

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.

PutFileByInode

Create a file under an existing parent inode. The name must be unused.

Fields

parent_inode_id: InodeId

Parent directory.

display_name: DisplayName

New file name.

content_ref: ContentRef

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

PutFileRevisionByInode

Append a revision to a file inode if its current revision matches.

Fields

inode_id: InodeId

File to update.

content_ref: ContentRef

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

expected_revision_no: RevisionNo

Current revision required for the write.

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.

DeleteByInode

Delete an inode if its current binding matches.

Fields

inode_id: InodeId

Inode to delete.

expected_binding_generation: String

Binding generation required for the delete.

behavior: DeleteDirectoryBehavior

Whether a non-empty directory may be tombstoned recursively.

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.

MoveByInode

Move an inode if its current binding matches.

Fields

inode_id: InodeId

Inode to move.

expected_binding_generation: String

Binding generation required for the move.

to_parent_inode_id: InodeId

Destination directory.

to_display_name: DisplayName

New name.

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.

Implementations

impl FilesystemOperation

pub const fn content_ref(&self) -> Option<&ContentRef>

Returns the content written by this operation, if any.

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