Skip to main content

talos_sync_types/
schema.rs

1use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine};
2use serde::{Deserialize, Serialize};
3
4use crate::{SyncError, SyncErrorCode, SyncResult};
5
6pub const SCHEMA_VERSION: u32 = 1;
7pub const PROTOCOL_VERSION: u32 = 1;
8
9#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
10#[serde(rename_all = "camelCase", deny_unknown_fields)]
11pub struct SyncScope {
12    pub hub_id: String,
13    pub account_id: String,
14}
15
16#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
17#[serde(rename_all = "camelCase", deny_unknown_fields)]
18pub struct ComputerAlias {
19    pub source_node_id: String,
20    pub computer_id: String,
21}
22
23#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
24#[serde(rename_all = "camelCase", deny_unknown_fields)]
25pub struct SyncBinding {
26    pub scope: SyncScope,
27    pub peer_id: String,
28    pub source_user_id: String,
29    pub computers: Vec<ComputerAlias>,
30}
31
32#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
33#[serde(rename_all = "camelCase")]
34pub enum ResourceKind {
35    Computer,
36    Project,
37    Session,
38    File,
39}
40
41impl ResourceKind {
42    pub fn as_str(self) -> &'static str {
43        match self {
44            Self::Computer => "computer",
45            Self::Project => "project",
46            Self::Session => "session",
47            Self::File => "file",
48        }
49    }
50}
51
52#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
53#[serde(
54    tag = "kind",
55    rename_all = "camelCase",
56    rename_all_fields = "camelCase",
57    deny_unknown_fields
58)]
59pub enum SyncResourceKey {
60    Computer { computer_id: String },
61    Project { project_id: String },
62    Session { session_id: String },
63    File { file_id: String },
64}
65
66impl SyncResourceKey {
67    pub fn kind(&self) -> ResourceKind {
68        match self {
69            Self::Computer { .. } => ResourceKind::Computer,
70            Self::Project { .. } => ResourceKind::Project,
71            Self::Session { .. } => ResourceKind::Session,
72            Self::File { .. } => ResourceKind::File,
73        }
74    }
75
76    pub fn id(&self) -> &str {
77        match self {
78            Self::Computer { computer_id } => computer_id,
79            Self::Project { project_id } => project_id,
80            Self::Session { session_id } => session_id,
81            Self::File { file_id } => file_id,
82        }
83    }
84
85    pub fn validate(&self) -> SyncResult<()> {
86        if self.id().is_empty() || self.id().len() > 128 {
87            return Err(SyncError::new(SyncErrorCode::InvalidRequest));
88        }
89        Ok(())
90    }
91}
92
93#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
94#[serde(rename_all = "camelCase", deny_unknown_fields)]
95pub struct SyncVersion {
96    pub version_vector: Vec<u8>,
97    pub history_generation: u64,
98}
99
100/// Room names are derived from verified account scope; they never grant access.
101pub fn room_id(scope: &SyncScope, resource: &SyncResourceKey) -> SyncResult<String> {
102    resource.validate()?;
103    let digest = sha2::Sha256::digest(serde_json::to_vec(&(scope, resource))?);
104    use sha2::Digest;
105    Ok(format!("v1.{}", URL_SAFE_NO_PAD.encode(digest)))
106}
107
108#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
109#[serde(rename_all = "camelCase", deny_unknown_fields)]
110pub struct DocumentJoin {
111    pub resource: SyncResourceKey,
112    pub history_generation: u64,
113}
114
115#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
116#[serde(rename_all = "camelCase", deny_unknown_fields)]
117pub struct DocumentJoinAccepted {
118    pub history_generation: u64,
119}
120
121#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
122#[serde(rename_all = "camelCase", deny_unknown_fields)]
123pub struct SyncResourceSummary {
124    pub resource: SyncResourceKey,
125    pub computer_id: Option<String>,
126    pub version: SyncVersion,
127    pub deleted: bool,
128}
129
130#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
131#[serde(rename_all = "camelCase", deny_unknown_fields)]
132pub struct SyncListParams {
133    pub kind: Option<ResourceKind>,
134    pub computer_id: Option<String>,
135    pub cursor: Option<String>,
136    pub limit: Option<u32>,
137}
138
139#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
140#[serde(rename_all = "camelCase", deny_unknown_fields)]
141pub struct SyncPage {
142    pub resources: Vec<SyncResourceSummary>,
143    pub next_cursor: Option<String>,
144    pub feed_cursor: String,
145}
146
147#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
148#[serde(rename_all = "camelCase", deny_unknown_fields)]
149pub struct SyncFeedEntry {
150    pub resource: SyncResourceKey,
151    pub version: SyncVersion,
152    pub deleted: bool,
153    pub reset: bool,
154}