buntrail-services 0.1.0

Filesystem, Git, terminal, search and connection services.
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

use buntrail_core::contracts::async_types::{EventStream, ServiceFuture};
use buntrail_core::contracts::*;
use std::sync::Arc;

pub trait EnvironmentService: Send + Sync {
    fn connect(
        &self,
        locator: EnvironmentLocator,
        expected: Option<TargetIdentity>,
    ) -> ServiceFuture<'_, Result<ConnectedEnvironment, CoreError>>;
}
pub trait FileService: Send + Sync {
    fn resolve(
        &self,
        root: FileRef,
        purpose: FileResolvePurpose,
    ) -> ServiceFuture<'_, Result<FileResolution, CoreError>>;
    fn list(&self, directory: FileRef) -> ServiceFuture<'_, Result<Vec<FileEntry>, CoreError>>;
    fn read(&self, file: FileRef) -> ServiceFuture<'_, Result<FileSnapshot, CoreError>>;
    fn watch(&self, root: FileRef) -> ServiceFuture<'_, Result<EventStream<FileEvent>, CoreError>>;
    fn save(&self, request: SaveRequest) -> ServiceFuture<'_, OperationReceipt>;
    fn mutate(&self, request: FileMutationRequest) -> ServiceFuture<'_, OperationReceipt>;
}
pub trait SearchService: Send + Sync {
    fn search(
        &self,
        request: SearchRequest,
    ) -> ServiceFuture<'_, Result<EventStream<SearchEvent>, CoreError>>;
}
pub trait GitService: Send + Sync {
    fn read_query(
        &self,
        _worktree: WorktreeIdentity,
        _query: GitRead,
    ) -> ServiceFuture<'_, Result<GitReadOutput, CoreError>> {
        Box::pin(async {
            Err(CoreError::new(
                ErrorCode::Unavailable,
                "Git read capability unavailable",
            ))
        })
    }

    /// Read-only original-request lookup, before filesystem or expected-state validation.
    fn existing_receipt(
        &self,
        request: GitMutationRequest,
    ) -> ServiceFuture<'_, Result<Option<OperationReceipt>, CoreError>>;
    fn discover(
        &self,
        root: FileRef,
    ) -> ServiceFuture<'_, Result<Option<WorktreeIdentity>, CoreError>>;
    fn status(
        &self,
        worktree: WorktreeIdentity,
    ) -> ServiceFuture<'_, Result<GitSnapshot, CoreError>>;
    fn diff(&self, request: DiffRequest) -> ServiceFuture<'_, Result<DiffSnapshot, CoreError>>;
    fn history(&self, query: HistoryQuery) -> ServiceFuture<'_, Result<GraphPage, CoreError>>;
    fn mutate(&self, request: GitMutationRequest) -> ServiceFuture<'_, OperationReceipt>;
}
pub trait TerminalService: Send + Sync {
    fn open(&self, request: TerminalOpenRequest) -> ServiceFuture<'_, OperationReceipt>;
    fn attach(
        &self,
        request: TerminalAttachRequest,
    ) -> ServiceFuture<'_, Result<EventStream<TerminalEvent>, CoreError>>;
    fn input(
        &self,
        session: TerminalSessionID,
        bytes: Vec<u8>,
    ) -> ServiceFuture<'_, Result<(), CoreError>>;
    fn resize(
        &self,
        session: TerminalSessionID,
        size: TerminalSize,
    ) -> ServiceFuture<'_, Result<(), CoreError>>;
    fn end(
        &self,
        session: TerminalSessionID,
        intent: TerminalEndIntent,
    ) -> ServiceFuture<'_, Result<(), CoreError>>;
}
pub trait OperationService: Send + Sync {
    fn inspect(
        &self,
        id: OperationID,
        target: TargetIdentity,
    ) -> ServiceFuture<'_, Result<OperationReceipt, CoreError>>;
}
pub trait WorkspaceLeaseService: Send + Sync {
    fn register(&self, lease: WorkspaceLease) -> ServiceFuture<'_, Result<(), CoreError>>;
    fn release(
        &self,
        id: WorkspaceLeaseID,
        intent: LeaseReleaseIntent,
    ) -> ServiceFuture<'_, Result<(), CoreError>>;
}

pub enum ServiceAvailability<T: ?Sized> {
    Available(Arc<T>),
    Unavailable(CoreError),
}
pub struct ConnectedEnvironment {
    pub identity: TargetIdentity,
    pub runtime: RuntimeGeneration,
    pub capabilities: Capabilities,
    pub owner: Arc<dyn ConnectionOwner>,
    pub leases: ServiceAvailability<dyn WorkspaceLeaseService>,
    pub files: ServiceAvailability<dyn FileService>,
    pub search: ServiceAvailability<dyn SearchService>,
    pub git: ServiceAvailability<dyn GitService>,
    pub terminal: ServiceAvailability<dyn TerminalService>,
    pub operations: ServiceAvailability<dyn OperationService>,
}
pub trait ConnectionOwner: Send + Sync {
    fn states(&self) -> EventStream<ConnectionState>;
    fn close(&self, reason: ConnectionCloseReason) -> ServiceFuture<'_, Result<(), CoreError>>;
}