Struct FilesystemCore 

pub struct FilesystemCore { /* private fields */ }

The main filesystem core. Owns the block store, crypto, codec, allocator, and transaction manager. Provides high-level filesystem operations.

All path-accepting methods use /-separated paths. An empty string or "/" refers to the root directory. Parent directories must already exist; only create_file and create_directory create the leaf entry.

Implementations

impl FilesystemCore

pub fn new(store: Arc<dyn BlockStore>, crypto: Arc<dyn CryptoEngine>) -> Self

Create a new FilesystemCore backed by the given store and crypto engine.

Examples found in repository

examples/create_image.rs (line 33)

fn main() {
    let path = std::env::current_dir()
        .unwrap()
        .join("sample.dcfs")
        .to_string_lossy()
        .to_string();

    // Remove leftover from a previous run, if any.
    let _ = std::fs::remove_file(&path);

    // 64 blocks × 64 KiB = 4 MiB image.
    let total_blocks: u64 = 64;
    let store = Arc::new(
        DiskBlockStore::create(&path, DEFAULT_BLOCK_SIZE, total_blocks)
            .expect("failed to create image file"),
    );

    let crypto = Arc::new(ChaChaEngine::generate().expect("failed to init crypto"));
    let mut fs = FilesystemCore::new(store, crypto);

    fs.init_filesystem().expect("init_filesystem failed");

    // Create a text file.
    fs.create_file("hello.txt").expect("create_file failed");
    fs.write_file("hello.txt", 0, b"Hello, hex editor!")
        .expect("write_file failed");

    // Create a directory.
    fs.create_directory("notes")
        .expect("create_directory failed");

    // Create a larger binary file so there's more to look at.
    let pattern: Vec<u8> = (0..=255).cycle().take(200_000).collect();
    fs.create_file("pattern.bin").expect("create_file failed");
    fs.write_file("pattern.bin", 0, &pattern)
        .expect("write_file failed");

    fs.sync().expect("sync failed");

    println!("Filesystem image written to:\n  {path}");
    println!(
        "  {} blocks × {} bytes = {} bytes total",
        total_blocks,
        DEFAULT_BLOCK_SIZE,
        total_blocks as usize * DEFAULT_BLOCK_SIZE
    );
}

examples/network_mount.rs (line 84)

fn main() {
    let args: Vec<String> = std::env::args().collect();

    let mut addr = "127.0.0.1:9100";
    let mut server_name = "localhost";
    let mut ca = "certs/ca.pem";
    let mut master_key_hex = "";
    let mut init = false;

    let mut i = 1;
    while i < args.len() {
        match args[i].as_str() {
            "--addr" => {
                addr = &args[i + 1];
                i += 2;
            }
            "--server-name" => {
                server_name = &args[i + 1];
                i += 2;
            }
            "--ca" => {
                ca = &args[i + 1];
                i += 2;
            }
            "--master-key" => {
                master_key_hex = &args[i + 1];
                i += 2;
            }
            "--init" => {
                init = true;
                i += 1;
            }
            other => {
                eprintln!("unknown argument: {other}");
                std::process::exit(1);
            }
        }
    }

    if master_key_hex.is_empty() || master_key_hex.len() != 64 {
        eprintln!("--master-key must be a 64-character hex string (32 bytes)");
        std::process::exit(1);
    }

    let master_key: Vec<u8> = (0..32)
        .map(|i| u8::from_str_radix(&master_key_hex[i * 2..i * 2 + 2], 16).unwrap())
        .collect();

    // ── Connect ─────────────────────────────────────────────
    println!("Connecting to {addr} (SNI: {server_name})...");
    let net = NetworkBlockStore::connect(addr, server_name, Path::new(ca), &master_key)
        .expect("failed to connect to server");

    println!(
        "Connected: {} blocks × {} bytes ({} MiB)",
        net.total_blocks(),
        net.block_size(),
        net.total_blocks() as usize * net.block_size() / (1024 * 1024)
    );

    // ── Wrap with cache ─────────────────────────────────────
    let store = Arc::new(CachedBlockStore::new(net, 1024));
    let crypto = Arc::new(ChaChaEngine::new(&master_key).expect("invalid master key"));
    let mut fs = FilesystemCore::new(store.clone(), crypto);

    // ── Mount or init ───────────────────────────────────────
    if init {
        println!("Initializing new filesystem...");
        fs.init_filesystem().expect("init_filesystem failed");
    } else {
        println!("Mounting existing filesystem...");
        fs.open().expect("open failed");
    }

    // ── Demo operations ─────────────────────────────────────
    println!("\nCreating file 'hello.txt'...");
    match fs.create_file("hello.txt") {
        Ok(()) => {}
        Err(e) => println!("  (skipped: {e})"),
    }

    fs.write_file("hello.txt", 0, b"Hello from the network!")
        .expect("write failed");

    let data = fs.read_file("hello.txt", 0, 4096).expect("read failed");
    println!("Read back: {:?}", String::from_utf8_lossy(&data));

    println!("\nListing root directory:");
    for entry in fs.list_directory("").expect("list failed") {
        println!(
            "  {:?}  {:>10} bytes  {}",
            entry.kind, entry.size, entry.name
        );
    }

    // ── Sync ────────────────────────────────────────────────
    fs.sync().expect("sync failed");
    println!("\nAll data synced to server.");
}

pub fn init_filesystem(&mut self) -> FsResult<()>

Initialize a brand-new filesystem on the block store. Writes the storage header, creates the root directory, and commits.

Examples found in repository

examples/create_image.rs (line 35)

fn main() {
    let path = std::env::current_dir()
        .unwrap()
        .join("sample.dcfs")
        .to_string_lossy()
        .to_string();

    // Remove leftover from a previous run, if any.
    let _ = std::fs::remove_file(&path);

    // 64 blocks × 64 KiB = 4 MiB image.
    let total_blocks: u64 = 64;
    let store = Arc::new(
        DiskBlockStore::create(&path, DEFAULT_BLOCK_SIZE, total_blocks)
            .expect("failed to create image file"),
    );

    let crypto = Arc::new(ChaChaEngine::generate().expect("failed to init crypto"));
    let mut fs = FilesystemCore::new(store, crypto);

    fs.init_filesystem().expect("init_filesystem failed");

    // Create a text file.
    fs.create_file("hello.txt").expect("create_file failed");
    fs.write_file("hello.txt", 0, b"Hello, hex editor!")
        .expect("write_file failed");

    // Create a directory.
    fs.create_directory("notes")
        .expect("create_directory failed");

    // Create a larger binary file so there's more to look at.
    let pattern: Vec<u8> = (0..=255).cycle().take(200_000).collect();
    fs.create_file("pattern.bin").expect("create_file failed");
    fs.write_file("pattern.bin", 0, &pattern)
        .expect("write_file failed");

    fs.sync().expect("sync failed");

    println!("Filesystem image written to:\n  {path}");
    println!(
        "  {} blocks × {} bytes = {} bytes total",
        total_blocks,
        DEFAULT_BLOCK_SIZE,
        total_blocks as usize * DEFAULT_BLOCK_SIZE
    );
}

examples/network_mount.rs (line 89)

fn main() {
    let args: Vec<String> = std::env::args().collect();

    let mut addr = "127.0.0.1:9100";
    let mut server_name = "localhost";
    let mut ca = "certs/ca.pem";
    let mut master_key_hex = "";
    let mut init = false;

    let mut i = 1;
    while i < args.len() {
        match args[i].as_str() {
            "--addr" => {
                addr = &args[i + 1];
                i += 2;
            }
            "--server-name" => {
                server_name = &args[i + 1];
                i += 2;
            }
            "--ca" => {
                ca = &args[i + 1];
                i += 2;
            }
            "--master-key" => {
                master_key_hex = &args[i + 1];
                i += 2;
            }
            "--init" => {
                init = true;
                i += 1;
            }
            other => {
                eprintln!("unknown argument: {other}");
                std::process::exit(1);
            }
        }
    }

    if master_key_hex.is_empty() || master_key_hex.len() != 64 {
        eprintln!("--master-key must be a 64-character hex string (32 bytes)");
        std::process::exit(1);
    }

    let master_key: Vec<u8> = (0..32)
        .map(|i| u8::from_str_radix(&master_key_hex[i * 2..i * 2 + 2], 16).unwrap())
        .collect();

    // ── Connect ─────────────────────────────────────────────
    println!("Connecting to {addr} (SNI: {server_name})...");
    let net = NetworkBlockStore::connect(addr, server_name, Path::new(ca), &master_key)
        .expect("failed to connect to server");

    println!(
        "Connected: {} blocks × {} bytes ({} MiB)",
        net.total_blocks(),
        net.block_size(),
        net.total_blocks() as usize * net.block_size() / (1024 * 1024)
    );

    // ── Wrap with cache ─────────────────────────────────────
    let store = Arc::new(CachedBlockStore::new(net, 1024));
    let crypto = Arc::new(ChaChaEngine::new(&master_key).expect("invalid master key"));
    let mut fs = FilesystemCore::new(store.clone(), crypto);

    // ── Mount or init ───────────────────────────────────────
    if init {
        println!("Initializing new filesystem...");
        fs.init_filesystem().expect("init_filesystem failed");
    } else {
        println!("Mounting existing filesystem...");
        fs.open().expect("open failed");
    }

    // ── Demo operations ─────────────────────────────────────
    println!("\nCreating file 'hello.txt'...");
    match fs.create_file("hello.txt") {
        Ok(()) => {}
        Err(e) => println!("  (skipped: {e})"),
    }

    fs.write_file("hello.txt", 0, b"Hello from the network!")
        .expect("write failed");

    let data = fs.read_file("hello.txt", 0, 4096).expect("read failed");
    println!("Read back: {:?}", String::from_utf8_lossy(&data));

    println!("\nListing root directory:");
    for entry in fs.list_directory("").expect("list failed") {
        println!(
            "  {:?}  {:>10} bytes  {}",
            entry.kind, entry.size, entry.name
        );
    }

    // ── Sync ────────────────────────────────────────────────
    fs.sync().expect("sync failed");
    println!("\nAll data synced to server.");
}

pub fn open(&mut self) -> FsResult<()>

Open / mount an existing filesystem by recovering the latest root pointer.

Examples found in repository

examples/network_mount.rs (line 92)

fn main() {
    let args: Vec<String> = std::env::args().collect();

    let mut addr = "127.0.0.1:9100";
    let mut server_name = "localhost";
    let mut ca = "certs/ca.pem";
    let mut master_key_hex = "";
    let mut init = false;

    let mut i = 1;
    while i < args.len() {
        match args[i].as_str() {
            "--addr" => {
                addr = &args[i + 1];
                i += 2;
            }
            "--server-name" => {
                server_name = &args[i + 1];
                i += 2;
            }
            "--ca" => {
                ca = &args[i + 1];
                i += 2;
            }
            "--master-key" => {
                master_key_hex = &args[i + 1];
                i += 2;
            }
            "--init" => {
                init = true;
                i += 1;
            }
            other => {
                eprintln!("unknown argument: {other}");
                std::process::exit(1);
            }
        }
    }

    if master_key_hex.is_empty() || master_key_hex.len() != 64 {
        eprintln!("--master-key must be a 64-character hex string (32 bytes)");
        std::process::exit(1);
    }

    let master_key: Vec<u8> = (0..32)
        .map(|i| u8::from_str_radix(&master_key_hex[i * 2..i * 2 + 2], 16).unwrap())
        .collect();

    // ── Connect ─────────────────────────────────────────────
    println!("Connecting to {addr} (SNI: {server_name})...");
    let net = NetworkBlockStore::connect(addr, server_name, Path::new(ca), &master_key)
        .expect("failed to connect to server");

    println!(
        "Connected: {} blocks × {} bytes ({} MiB)",
        net.total_blocks(),
        net.block_size(),
        net.total_blocks() as usize * net.block_size() / (1024 * 1024)
    );

    // ── Wrap with cache ─────────────────────────────────────
    let store = Arc::new(CachedBlockStore::new(net, 1024));
    let crypto = Arc::new(ChaChaEngine::new(&master_key).expect("invalid master key"));
    let mut fs = FilesystemCore::new(store.clone(), crypto);

    // ── Mount or init ───────────────────────────────────────
    if init {
        println!("Initializing new filesystem...");
        fs.init_filesystem().expect("init_filesystem failed");
    } else {
        println!("Mounting existing filesystem...");
        fs.open().expect("open failed");
    }

    // ── Demo operations ─────────────────────────────────────
    println!("\nCreating file 'hello.txt'...");
    match fs.create_file("hello.txt") {
        Ok(()) => {}
        Err(e) => println!("  (skipped: {e})"),
    }

    fs.write_file("hello.txt", 0, b"Hello from the network!")
        .expect("write failed");

    let data = fs.read_file("hello.txt", 0, 4096).expect("read failed");
    println!("Read back: {:?}", String::from_utf8_lossy(&data));

    println!("\nListing root directory:");
    for entry in fs.list_directory("").expect("list failed") {
        println!(
            "  {:?}  {:>10} bytes  {}",
            entry.kind, entry.size, entry.name
        );
    }

    // ── Sync ────────────────────────────────────────────────
    fs.sync().expect("sync failed");
    println!("\nAll data synced to server.");
}

pub fn create_file(&mut self, path: &str) -> FsResult<()>

Create a new empty file at the given path.

Parent directories must already exist. The leaf name is created in the innermost directory.

Examples found in repository

examples/create_image.rs (line 38)

fn main() {
    let path = std::env::current_dir()
        .unwrap()
        .join("sample.dcfs")
        .to_string_lossy()
        .to_string();

    // Remove leftover from a previous run, if any.
    let _ = std::fs::remove_file(&path);

    // 64 blocks × 64 KiB = 4 MiB image.
    let total_blocks: u64 = 64;
    let store = Arc::new(
        DiskBlockStore::create(&path, DEFAULT_BLOCK_SIZE, total_blocks)
            .expect("failed to create image file"),
    );

    let crypto = Arc::new(ChaChaEngine::generate().expect("failed to init crypto"));
    let mut fs = FilesystemCore::new(store, crypto);

    fs.init_filesystem().expect("init_filesystem failed");

    // Create a text file.
    fs.create_file("hello.txt").expect("create_file failed");
    fs.write_file("hello.txt", 0, b"Hello, hex editor!")
        .expect("write_file failed");

    // Create a directory.
    fs.create_directory("notes")
        .expect("create_directory failed");

    // Create a larger binary file so there's more to look at.
    let pattern: Vec<u8> = (0..=255).cycle().take(200_000).collect();
    fs.create_file("pattern.bin").expect("create_file failed");
    fs.write_file("pattern.bin", 0, &pattern)
        .expect("write_file failed");

    fs.sync().expect("sync failed");

    println!("Filesystem image written to:\n  {path}");
    println!(
        "  {} blocks × {} bytes = {} bytes total",
        total_blocks,
        DEFAULT_BLOCK_SIZE,
        total_blocks as usize * DEFAULT_BLOCK_SIZE
    );
}

examples/network_mount.rs (line 97)

fn main() {
    let args: Vec<String> = std::env::args().collect();

    let mut addr = "127.0.0.1:9100";
    let mut server_name = "localhost";
    let mut ca = "certs/ca.pem";
    let mut master_key_hex = "";
    let mut init = false;

    let mut i = 1;
    while i < args.len() {
        match args[i].as_str() {
            "--addr" => {
                addr = &args[i + 1];
                i += 2;
            }
            "--server-name" => {
                server_name = &args[i + 1];
                i += 2;
            }
            "--ca" => {
                ca = &args[i + 1];
                i += 2;
            }
            "--master-key" => {
                master_key_hex = &args[i + 1];
                i += 2;
            }
            "--init" => {
                init = true;
                i += 1;
            }
            other => {
                eprintln!("unknown argument: {other}");
                std::process::exit(1);
            }
        }
    }

    if master_key_hex.is_empty() || master_key_hex.len() != 64 {
        eprintln!("--master-key must be a 64-character hex string (32 bytes)");
        std::process::exit(1);
    }

    let master_key: Vec<u8> = (0..32)
        .map(|i| u8::from_str_radix(&master_key_hex[i * 2..i * 2 + 2], 16).unwrap())
        .collect();

    // ── Connect ─────────────────────────────────────────────
    println!("Connecting to {addr} (SNI: {server_name})...");
    let net = NetworkBlockStore::connect(addr, server_name, Path::new(ca), &master_key)
        .expect("failed to connect to server");

    println!(
        "Connected: {} blocks × {} bytes ({} MiB)",
        net.total_blocks(),
        net.block_size(),
        net.total_blocks() as usize * net.block_size() / (1024 * 1024)
    );

    // ── Wrap with cache ─────────────────────────────────────
    let store = Arc::new(CachedBlockStore::new(net, 1024));
    let crypto = Arc::new(ChaChaEngine::new(&master_key).expect("invalid master key"));
    let mut fs = FilesystemCore::new(store.clone(), crypto);

    // ── Mount or init ───────────────────────────────────────
    if init {
        println!("Initializing new filesystem...");
        fs.init_filesystem().expect("init_filesystem failed");
    } else {
        println!("Mounting existing filesystem...");
        fs.open().expect("open failed");
    }

    // ── Demo operations ─────────────────────────────────────
    println!("\nCreating file 'hello.txt'...");
    match fs.create_file("hello.txt") {
        Ok(()) => {}
        Err(e) => println!("  (skipped: {e})"),
    }

    fs.write_file("hello.txt", 0, b"Hello from the network!")
        .expect("write failed");

    let data = fs.read_file("hello.txt", 0, 4096).expect("read failed");
    println!("Read back: {:?}", String::from_utf8_lossy(&data));

    println!("\nListing root directory:");
    for entry in fs.list_directory("").expect("list failed") {
        println!(
            "  {:?}  {:>10} bytes  {}",
            entry.kind, entry.size, entry.name
        );
    }

    // ── Sync ────────────────────────────────────────────────
    fs.sync().expect("sync failed");
    println!("\nAll data synced to server.");
}

pub fn write_file( &mut self, path: &str, offset: u64, data: &[u8], ) -> FsResult<()>

Write data to a file at the given path.

Only the chunks that overlap with [offset, offset+data.len()) are read and rewritten. For sequential appends this means O(new_data) work instead of O(file_size).

Examples found in repository

examples/create_image.rs (line 39)

fn main() {
    let path = std::env::current_dir()
        .unwrap()
        .join("sample.dcfs")
        .to_string_lossy()
        .to_string();

    // Remove leftover from a previous run, if any.
    let _ = std::fs::remove_file(&path);

    // 64 blocks × 64 KiB = 4 MiB image.
    let total_blocks: u64 = 64;
    let store = Arc::new(
        DiskBlockStore::create(&path, DEFAULT_BLOCK_SIZE, total_blocks)
            .expect("failed to create image file"),
    );

    let crypto = Arc::new(ChaChaEngine::generate().expect("failed to init crypto"));
    let mut fs = FilesystemCore::new(store, crypto);

    fs.init_filesystem().expect("init_filesystem failed");

    // Create a text file.
    fs.create_file("hello.txt").expect("create_file failed");
    fs.write_file("hello.txt", 0, b"Hello, hex editor!")
        .expect("write_file failed");

    // Create a directory.
    fs.create_directory("notes")
        .expect("create_directory failed");

    // Create a larger binary file so there's more to look at.
    let pattern: Vec<u8> = (0..=255).cycle().take(200_000).collect();
    fs.create_file("pattern.bin").expect("create_file failed");
    fs.write_file("pattern.bin", 0, &pattern)
        .expect("write_file failed");

    fs.sync().expect("sync failed");

    println!("Filesystem image written to:\n  {path}");
    println!(
        "  {} blocks × {} bytes = {} bytes total",
        total_blocks,
        DEFAULT_BLOCK_SIZE,
        total_blocks as usize * DEFAULT_BLOCK_SIZE
    );
}

examples/network_mount.rs (line 102)

fn main() {
    let args: Vec<String> = std::env::args().collect();

    let mut addr = "127.0.0.1:9100";
    let mut server_name = "localhost";
    let mut ca = "certs/ca.pem";
    let mut master_key_hex = "";
    let mut init = false;

    let mut i = 1;
    while i < args.len() {
        match args[i].as_str() {
            "--addr" => {
                addr = &args[i + 1];
                i += 2;
            }
            "--server-name" => {
                server_name = &args[i + 1];
                i += 2;
            }
            "--ca" => {
                ca = &args[i + 1];
                i += 2;
            }
            "--master-key" => {
                master_key_hex = &args[i + 1];
                i += 2;
            }
            "--init" => {
                init = true;
                i += 1;
            }
            other => {
                eprintln!("unknown argument: {other}");
                std::process::exit(1);
            }
        }
    }

    if master_key_hex.is_empty() || master_key_hex.len() != 64 {
        eprintln!("--master-key must be a 64-character hex string (32 bytes)");
        std::process::exit(1);
    }

    let master_key: Vec<u8> = (0..32)
        .map(|i| u8::from_str_radix(&master_key_hex[i * 2..i * 2 + 2], 16).unwrap())
        .collect();

    // ── Connect ─────────────────────────────────────────────
    println!("Connecting to {addr} (SNI: {server_name})...");
    let net = NetworkBlockStore::connect(addr, server_name, Path::new(ca), &master_key)
        .expect("failed to connect to server");

    println!(
        "Connected: {} blocks × {} bytes ({} MiB)",
        net.total_blocks(),
        net.block_size(),
        net.total_blocks() as usize * net.block_size() / (1024 * 1024)
    );

    // ── Wrap with cache ─────────────────────────────────────
    let store = Arc::new(CachedBlockStore::new(net, 1024));
    let crypto = Arc::new(ChaChaEngine::new(&master_key).expect("invalid master key"));
    let mut fs = FilesystemCore::new(store.clone(), crypto);

    // ── Mount or init ───────────────────────────────────────
    if init {
        println!("Initializing new filesystem...");
        fs.init_filesystem().expect("init_filesystem failed");
    } else {
        println!("Mounting existing filesystem...");
        fs.open().expect("open failed");
    }

    // ── Demo operations ─────────────────────────────────────
    println!("\nCreating file 'hello.txt'...");
    match fs.create_file("hello.txt") {
        Ok(()) => {}
        Err(e) => println!("  (skipped: {e})"),
    }

    fs.write_file("hello.txt", 0, b"Hello from the network!")
        .expect("write failed");

    let data = fs.read_file("hello.txt", 0, 4096).expect("read failed");
    println!("Read back: {:?}", String::from_utf8_lossy(&data));

    println!("\nListing root directory:");
    for entry in fs.list_directory("").expect("list failed") {
        println!(
            "  {:?}  {:>10} bytes  {}",
            entry.kind, entry.size, entry.name
        );
    }

    // ── Sync ────────────────────────────────────────────────
    fs.sync().expect("sync failed");
    println!("\nAll data synced to server.");
}

pub fn read_file( &self, path: &str, offset: u64, len: usize, ) -> FsResult<Vec<u8>>

Read file data at the given path. Returns the requested slice.

Examples found in repository

examples/network_mount.rs (line 105)

fn main() {
    let args: Vec<String> = std::env::args().collect();

    let mut addr = "127.0.0.1:9100";
    let mut server_name = "localhost";
    let mut ca = "certs/ca.pem";
    let mut master_key_hex = "";
    let mut init = false;

    let mut i = 1;
    while i < args.len() {
        match args[i].as_str() {
            "--addr" => {
                addr = &args[i + 1];
                i += 2;
            }
            "--server-name" => {
                server_name = &args[i + 1];
                i += 2;
            }
            "--ca" => {
                ca = &args[i + 1];
                i += 2;
            }
            "--master-key" => {
                master_key_hex = &args[i + 1];
                i += 2;
            }
            "--init" => {
                init = true;
                i += 1;
            }
            other => {
                eprintln!("unknown argument: {other}");
                std::process::exit(1);
            }
        }
    }

    if master_key_hex.is_empty() || master_key_hex.len() != 64 {
        eprintln!("--master-key must be a 64-character hex string (32 bytes)");
        std::process::exit(1);
    }

    let master_key: Vec<u8> = (0..32)
        .map(|i| u8::from_str_radix(&master_key_hex[i * 2..i * 2 + 2], 16).unwrap())
        .collect();

    // ── Connect ─────────────────────────────────────────────
    println!("Connecting to {addr} (SNI: {server_name})...");
    let net = NetworkBlockStore::connect(addr, server_name, Path::new(ca), &master_key)
        .expect("failed to connect to server");

    println!(
        "Connected: {} blocks × {} bytes ({} MiB)",
        net.total_blocks(),
        net.block_size(),
        net.total_blocks() as usize * net.block_size() / (1024 * 1024)
    );

    // ── Wrap with cache ─────────────────────────────────────
    let store = Arc::new(CachedBlockStore::new(net, 1024));
    let crypto = Arc::new(ChaChaEngine::new(&master_key).expect("invalid master key"));
    let mut fs = FilesystemCore::new(store.clone(), crypto);

    // ── Mount or init ───────────────────────────────────────
    if init {
        println!("Initializing new filesystem...");
        fs.init_filesystem().expect("init_filesystem failed");
    } else {
        println!("Mounting existing filesystem...");
        fs.open().expect("open failed");
    }

    // ── Demo operations ─────────────────────────────────────
    println!("\nCreating file 'hello.txt'...");
    match fs.create_file("hello.txt") {
        Ok(()) => {}
        Err(e) => println!("  (skipped: {e})"),
    }

    fs.write_file("hello.txt", 0, b"Hello from the network!")
        .expect("write failed");

    let data = fs.read_file("hello.txt", 0, 4096).expect("read failed");
    println!("Read back: {:?}", String::from_utf8_lossy(&data));

    println!("\nListing root directory:");
    for entry in fs.list_directory("").expect("list failed") {
        println!(
            "  {:?}  {:>10} bytes  {}",
            entry.kind, entry.size, entry.name
        );
    }

    // ── Sync ────────────────────────────────────────────────
    fs.sync().expect("sync failed");
    println!("\nAll data synced to server.");
}

pub fn list_directory(&self, path: &str) -> FsResult<Vec<DirListEntry>>

List entries in a directory at the given path.

Pass "" or "/" to list the root directory.

Examples found in repository

examples/network_mount.rs (line 109)

fn main() {
    let args: Vec<String> = std::env::args().collect();

    let mut addr = "127.0.0.1:9100";
    let mut server_name = "localhost";
    let mut ca = "certs/ca.pem";
    let mut master_key_hex = "";
    let mut init = false;

    let mut i = 1;
    while i < args.len() {
        match args[i].as_str() {
            "--addr" => {
                addr = &args[i + 1];
                i += 2;
            }
            "--server-name" => {
                server_name = &args[i + 1];
                i += 2;
            }
            "--ca" => {
                ca = &args[i + 1];
                i += 2;
            }
            "--master-key" => {
                master_key_hex = &args[i + 1];
                i += 2;
            }
            "--init" => {
                init = true;
                i += 1;
            }
            other => {
                eprintln!("unknown argument: {other}");
                std::process::exit(1);
            }
        }
    }

    if master_key_hex.is_empty() || master_key_hex.len() != 64 {
        eprintln!("--master-key must be a 64-character hex string (32 bytes)");
        std::process::exit(1);
    }

    let master_key: Vec<u8> = (0..32)
        .map(|i| u8::from_str_radix(&master_key_hex[i * 2..i * 2 + 2], 16).unwrap())
        .collect();

    // ── Connect ─────────────────────────────────────────────
    println!("Connecting to {addr} (SNI: {server_name})...");
    let net = NetworkBlockStore::connect(addr, server_name, Path::new(ca), &master_key)
        .expect("failed to connect to server");

    println!(
        "Connected: {} blocks × {} bytes ({} MiB)",
        net.total_blocks(),
        net.block_size(),
        net.total_blocks() as usize * net.block_size() / (1024 * 1024)
    );

    // ── Wrap with cache ─────────────────────────────────────
    let store = Arc::new(CachedBlockStore::new(net, 1024));
    let crypto = Arc::new(ChaChaEngine::new(&master_key).expect("invalid master key"));
    let mut fs = FilesystemCore::new(store.clone(), crypto);

    // ── Mount or init ───────────────────────────────────────
    if init {
        println!("Initializing new filesystem...");
        fs.init_filesystem().expect("init_filesystem failed");
    } else {
        println!("Mounting existing filesystem...");
        fs.open().expect("open failed");
    }

    // ── Demo operations ─────────────────────────────────────
    println!("\nCreating file 'hello.txt'...");
    match fs.create_file("hello.txt") {
        Ok(()) => {}
        Err(e) => println!("  (skipped: {e})"),
    }

    fs.write_file("hello.txt", 0, b"Hello from the network!")
        .expect("write failed");

    let data = fs.read_file("hello.txt", 0, 4096).expect("read failed");
    println!("Read back: {:?}", String::from_utf8_lossy(&data));

    println!("\nListing root directory:");
    for entry in fs.list_directory("").expect("list failed") {
        println!(
            "  {:?}  {:>10} bytes  {}",
            entry.kind, entry.size, entry.name
        );
    }

    // ── Sync ────────────────────────────────────────────────
    fs.sync().expect("sync failed");
    println!("\nAll data synced to server.");
}

pub fn create_directory(&mut self, path: &str) -> FsResult<()>

Create a subdirectory at the given path.

Parent directories must already exist; only the leaf is created.

Examples found in repository

examples/create_image.rs (line 43)

fn main() {
    let path = std::env::current_dir()
        .unwrap()
        .join("sample.dcfs")
        .to_string_lossy()
        .to_string();

    // Remove leftover from a previous run, if any.
    let _ = std::fs::remove_file(&path);

    // 64 blocks × 64 KiB = 4 MiB image.
    let total_blocks: u64 = 64;
    let store = Arc::new(
        DiskBlockStore::create(&path, DEFAULT_BLOCK_SIZE, total_blocks)
            .expect("failed to create image file"),
    );

    let crypto = Arc::new(ChaChaEngine::generate().expect("failed to init crypto"));
    let mut fs = FilesystemCore::new(store, crypto);

    fs.init_filesystem().expect("init_filesystem failed");

    // Create a text file.
    fs.create_file("hello.txt").expect("create_file failed");
    fs.write_file("hello.txt", 0, b"Hello, hex editor!")
        .expect("write_file failed");

    // Create a directory.
    fs.create_directory("notes")
        .expect("create_directory failed");

    // Create a larger binary file so there's more to look at.
    let pattern: Vec<u8> = (0..=255).cycle().take(200_000).collect();
    fs.create_file("pattern.bin").expect("create_file failed");
    fs.write_file("pattern.bin", 0, &pattern)
        .expect("write_file failed");

    fs.sync().expect("sync failed");

    println!("Filesystem image written to:\n  {path}");
    println!(
        "  {} blocks × {} bytes = {} bytes total",
        total_blocks,
        DEFAULT_BLOCK_SIZE,
        total_blocks as usize * DEFAULT_BLOCK_SIZE
    );
}

pub fn remove_file(&mut self, path: &str) -> FsResult<()>

Remove a file or empty directory at the given path.

pub fn rename(&mut self, old_path: &str, new_path: &str) -> FsResult<()>

Rename a file or directory. Both old_path and new_path must share the same parent directory (move across directories is not supported yet).

pub fn sync(&self) -> FsResult<()>

Sync / flush. Calls through to the block store sync.

Examples found in repository

examples/create_image.rs (line 52)

fn main() {
    let path = std::env::current_dir()
        .unwrap()
        .join("sample.dcfs")
        .to_string_lossy()
        .to_string();

    // Remove leftover from a previous run, if any.
    let _ = std::fs::remove_file(&path);

    // 64 blocks × 64 KiB = 4 MiB image.
    let total_blocks: u64 = 64;
    let store = Arc::new(
        DiskBlockStore::create(&path, DEFAULT_BLOCK_SIZE, total_blocks)
            .expect("failed to create image file"),
    );

    let crypto = Arc::new(ChaChaEngine::generate().expect("failed to init crypto"));
    let mut fs = FilesystemCore::new(store, crypto);

    fs.init_filesystem().expect("init_filesystem failed");

    // Create a text file.
    fs.create_file("hello.txt").expect("create_file failed");
    fs.write_file("hello.txt", 0, b"Hello, hex editor!")
        .expect("write_file failed");

    // Create a directory.
    fs.create_directory("notes")
        .expect("create_directory failed");

    // Create a larger binary file so there's more to look at.
    let pattern: Vec<u8> = (0..=255).cycle().take(200_000).collect();
    fs.create_file("pattern.bin").expect("create_file failed");
    fs.write_file("pattern.bin", 0, &pattern)
        .expect("write_file failed");

    fs.sync().expect("sync failed");

    println!("Filesystem image written to:\n  {path}");
    println!(
        "  {} blocks × {} bytes = {} bytes total",
        total_blocks,
        DEFAULT_BLOCK_SIZE,
        total_blocks as usize * DEFAULT_BLOCK_SIZE
    );
}

examples/network_mount.rs (line 117)

fn main() {
    let args: Vec<String> = std::env::args().collect();

    let mut addr = "127.0.0.1:9100";
    let mut server_name = "localhost";
    let mut ca = "certs/ca.pem";
    let mut master_key_hex = "";
    let mut init = false;

    let mut i = 1;
    while i < args.len() {
        match args[i].as_str() {
            "--addr" => {
                addr = &args[i + 1];
                i += 2;
            }
            "--server-name" => {
                server_name = &args[i + 1];
                i += 2;
            }
            "--ca" => {
                ca = &args[i + 1];
                i += 2;
            }
            "--master-key" => {
                master_key_hex = &args[i + 1];
                i += 2;
            }
            "--init" => {
                init = true;
                i += 1;
            }
            other => {
                eprintln!("unknown argument: {other}");
                std::process::exit(1);
            }
        }
    }

    if master_key_hex.is_empty() || master_key_hex.len() != 64 {
        eprintln!("--master-key must be a 64-character hex string (32 bytes)");
        std::process::exit(1);
    }

    let master_key: Vec<u8> = (0..32)
        .map(|i| u8::from_str_radix(&master_key_hex[i * 2..i * 2 + 2], 16).unwrap())
        .collect();

    // ── Connect ─────────────────────────────────────────────
    println!("Connecting to {addr} (SNI: {server_name})...");
    let net = NetworkBlockStore::connect(addr, server_name, Path::new(ca), &master_key)
        .expect("failed to connect to server");

    println!(
        "Connected: {} blocks × {} bytes ({} MiB)",
        net.total_blocks(),
        net.block_size(),
        net.total_blocks() as usize * net.block_size() / (1024 * 1024)
    );

    // ── Wrap with cache ─────────────────────────────────────
    let store = Arc::new(CachedBlockStore::new(net, 1024));
    let crypto = Arc::new(ChaChaEngine::new(&master_key).expect("invalid master key"));
    let mut fs = FilesystemCore::new(store.clone(), crypto);

    // ── Mount or init ───────────────────────────────────────
    if init {
        println!("Initializing new filesystem...");
        fs.init_filesystem().expect("init_filesystem failed");
    } else {
        println!("Mounting existing filesystem...");
        fs.open().expect("open failed");
    }

    // ── Demo operations ─────────────────────────────────────
    println!("\nCreating file 'hello.txt'...");
    match fs.create_file("hello.txt") {
        Ok(()) => {}
        Err(e) => println!("  (skipped: {e})"),
    }

    fs.write_file("hello.txt", 0, b"Hello from the network!")
        .expect("write failed");

    let data = fs.read_file("hello.txt", 0, 4096).expect("read failed");
    println!("Read back: {:?}", String::from_utf8_lossy(&data));

    println!("\nListing root directory:");
    for entry in fs.list_directory("").expect("list failed") {
        println!(
            "  {:?}  {:>10} bytes  {}",
            entry.kind, entry.size, entry.name
        );
    }

    // ── Sync ────────────────────────────────────────────────
    fs.sync().expect("sync failed");
    println!("\nAll data synced to server.");
}