acyclic-fs 0.1.5

Rust SDK for versioned workspaces and embedded native mounts
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

//! Graphcoder-shaped embedded consumption with independently configured volumes.

use acyclic_fs::model::{
    AccessMode, CheckoutMode, ConsistencyMode, GenerationSelector, Lifecycle, MutationMode,
    VolumeConfig,
};
use acyclic_fs::path::PortablePath;
use acyclic_fs::{CancellationToken, Fs, LocalOptions, MountedView, WorkBudget};

#[tokio::main(flavor = "current_thread")]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let root = tempfile::tempdir()?;
    let fs = Fs::local(LocalOptions::new(root.path())).await?;
    let cancellation = CancellationToken::default();

    let workspace = fs
        .create_volume(
            VolumeConfig::portable(Lifecycle::Durable),
            WorkBudget::UNBOUNDED,
            &cancellation,
        )
        .await?
        .value;
    let scratch = fs
        .create_volume(
            VolumeConfig::portable(Lifecycle::Ephemeral),
            WorkBudget::UNBOUNDED,
            &cancellation,
        )
        .await?
        .value;
    let writable = CheckoutMode {
        access: AccessMode::ReadWrite,
        consistency: ConsistencyMode::TrackingSafe,
        mutations: MutationMode::PrivateOverlay,
    };
    let workspace_checkout = workspace
        .checkout(
            GenerationSelector::Head,
            writable,
            WorkBudget::UNBOUNDED,
            &cancellation,
        )
        .await?
        .value;
    let scratch_checkout = scratch
        .checkout(
            GenerationSelector::Head,
            writable,
            WorkBudget::UNBOUNDED,
            &cancellation,
        )
        .await?
        .value;

    let mut view = MountedView::builder()
        .mount("/", workspace_checkout)?
        .mount("/.scratch", scratch_checkout)?
        .build()?;
    let tool_path = PortablePath::parse(
        "/.scratch/tool-output.txt",
        acyclic_fs::model::VolumeLimits::default(),
    )?;
    let routed = view.route_mut(&tool_path)?;
    routed
        .checkout
        .create_file(
            routed.path,
            bytes::Bytes::from_static(b"tool output"),
            WorkBudget::UNBOUNDED,
            &cancellation,
        )
        .await?;

    let snapshot = view.snapshot();
    assert_eq!(snapshot.bindings.len(), 2);
    Ok(())
}