kbolt-types 0.1.7

Shared request and response types for kbolt
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

use std::path::PathBuf;

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum WatchBackend {
    Launchd,
    SystemdUser,
    Unsupported,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum WatchMode {
    Native,
    Polling,
    Foreground,
    Disabled,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum WatchHealth {
    Ok,
    Warning,
    Error,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum WatchRuntimeState {
    Starting,
    Idle,
    RefreshingKeyword,
    RefreshingSemantic,
    Checking,
    BackingOff,
    Stopping,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum WatchSemanticState {
    None,
    Pending {
        pending_chunks: usize,
    },
    Unavailable {
        pending_chunks: usize,
        reason: String,
    },
    Blocked {
        space: String,
        reason: String,
        fix: String,
    },
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct WatchServiceStatus {
    pub enabled: bool,
    pub running: bool,
    pub backend: WatchBackend,
    pub pid: Option<u32>,
    pub issue: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct WatchStatusResponse {
    pub service: WatchServiceStatus,
    pub runtime: Option<WatchRuntimeStatus>,
    pub log_file: PathBuf,
    pub state_file: PathBuf,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct WatchRuntimeStatus {
    pub mode: WatchMode,
    pub health: WatchHealth,
    pub state: WatchRuntimeState,
    pub pid: u32,
    pub started_at: String,
    pub updated_at: String,
    pub watched_collections: usize,
    pub dirty_collections: usize,
    pub semantic_pending_collections: usize,
    pub semantic_unavailable_collections: usize,
    pub semantic_blocked_spaces: Vec<WatchSpaceBlock>,
    pub collections: Vec<WatchCollectionStatus>,
    pub last_keyword_refresh: Option<WatchRefreshSummary>,
    pub last_semantic_refresh: Option<WatchRefreshSummary>,
    pub last_safety_scan: Option<String>,
    pub last_catalog_refresh: Option<String>,
    pub last_error: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct WatchCollectionStatus {
    pub space: String,
    pub collection: String,
    pub path: PathBuf,
    pub dirty: bool,
    pub semantic: WatchSemanticState,
    pub last_event_at: Option<String>,
    pub last_keyword_refresh: Option<String>,
    pub last_semantic_refresh: Option<String>,
    pub last_error: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct WatchSpaceBlock {
    pub space: String,
    pub reason: String,
    pub fix: String,
    pub set_at: String,
    pub backoff_until: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct WatchRefreshSummary {
    pub space: String,
    pub collection: String,
    pub started_at: String,
    pub finished_at: String,
    pub elapsed_ms: u64,
    pub scanned_docs: usize,
    pub changed_docs: usize,
    pub embedded_chunks: usize,
}