shellcanvas-adapter-sdk 0.1.0

Versioned process protocol and concurrent server for ShellCanvas connection adapters
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

// SPDX-License-Identifier: MPL-2.0
// Synthetic, immutable inventory. These identifiers are NOT local filesystem paths.
use shellcanvas_adapter_sdk::{
    async_trait, json, run, Adapter, CallError, RequestContext, ServiceDescriptor, Value,
};

const ROOT: &str = "inventory:?collection=demo#root";
const REVISION: &str = "inventory-v1";
const COUNT: usize = 300;
struct Device;
fn invalid() -> CallError {
    CallError::new("invalid", "Unknown inventory location or cursor")
}
fn item(index: usize) -> String {
    format!("item:?key={index}#note")
}
fn index(path: &str) -> Result<usize, CallError> {
    let n = path
        .strip_prefix("item:?key=")
        .and_then(|s| s.strip_suffix("#note"))
        .and_then(|s| s.parse::<usize>().ok())
        .ok_or_else(invalid)?;
    if n >= COUNT || item(n) != path {
        return Err(invalid());
    }
    Ok(n)
}
fn location(path: &str) -> Result<Value, CallError> {
    if path == ROOT {
        return Ok(json!({"path":ROOT,"name":"Demo inventory","parent":null}));
    }
    let n = index(path)?;
    Ok(json!({"path":path,"name":format!("Note {n}.txt"),"parent":ROOT}))
}
fn contents(n: usize) -> String {
    format!("Synthetic note {n}. Hello, 🌿!\n")
}

#[async_trait]
impl Adapter for Device {
    async fn initialize(
        &self,
        _: Value,
        _: RequestContext,
    ) -> Result<Vec<ServiceDescriptor>, CallError> {
        Ok(vec![ServiceDescriptor {
            id: "files".into(),
            version: 1,
            methods: [
                "files.list",
                "files.locate",
                "files.preview",
                "files.readText",
            ]
            .map(String::from)
            .into(),
        }])
    }
    async fn call(
        &self,
        method: &str,
        params: Value,
        context: RequestContext,
    ) -> Result<Value, CallError> {
        if context.is_canceled() {
            return Err(CallError::new("aborted", "Inventory request canceled"));
        }
        let path = match params.get("path") {
            None | Some(Value::Null) => None,
            Some(Value::String(path)) => Some(path.as_str()),
            _ => return Err(invalid()),
        };
        match method {
            "files.list" => {
                if path.is_some_and(|p| p != ROOT) {
                    return Err(invalid());
                }
                let limit = params["limit"]
                    .as_u64()
                    .filter(|n| (1..=128).contains(n))
                    .ok_or_else(invalid)? as usize;
                // Stateless cursor binds to this immutable inventory revision. A mutable
                // device must reject an old revision rather than mix pages from two lists.
                let start = match params.get("cursor") {
                    None | Some(Value::Null) => 0,
                    Some(Value::String(cursor)) => {
                        let offset = cursor
                            .strip_prefix(&format!("{REVISION}:"))
                            .and_then(|s| s.parse::<usize>().ok())
                            .ok_or_else(invalid)?;
                        if offset == 0
                            || offset >= COUNT
                            || *cursor != format!("{REVISION}:{offset}")
                        {
                            return Err(invalid());
                        }
                        offset
                    }
                    _ => return Err(invalid()),
                };
                let end = (start + limit).min(COUNT);
                let entries: Vec<_> = (start..end)
                    .map(|n| {
                        json!({"path":item(n),"name":format!("Note {n}.txt"),
                    "kind":"file","size":contents(n).len(),"modified":null,"revision":REVISION})
                    })
                    .collect();
                Ok(
                    json!({"directory":{"path":ROOT,"name":"Demo inventory","parent":null,
                    "home":{"path":ROOT,"name":"Inventory"},"roots":[{"path":ROOT,"name":"Inventory"}],"entries":entries},
                    "next":if end < COUNT { Some(format!("{REVISION}:{end}")) } else { None }}),
                )
            }
            "files.locate" => location(path.ok_or_else(invalid)?),
            "files.preview" => Ok(json!(contents(index(path.ok_or_else(invalid)?)?))),
            "files.readText" => {
                let path = path.ok_or_else(invalid)?;
                let n = index(path)?;
                Ok(
                    json!({"path":path,"parent":ROOT,"name":format!("Note {n}.txt"),"text":contents(n),
                    "revision":REVISION,"writable":false}),
                )
            }
            _ => Err(CallError::new(
                "unavailable",
                "Unsupported inventory operation",
            )),
        }
    }
}
fn main() -> std::io::Result<()> {
    run(Device)
}