makepad_hub/
hubmsg.rs

1use serde::{Serialize, Deserialize};
2use std::net::SocketAddr;
3use std::cmp::Ordering;
4use std::collections::HashMap;
5use crate::httpserver::*;
6use crate::hubclient::*;
7
8#[derive(Clone, Debug, Serialize, Deserialize)]
9pub enum HubMsg {
10    ConnectBuilder(String),
11    ConnectClone(String),
12    ConnectUI,
13    
14    DisconnectBuilder(String),
15    DisconnectClone(String),
16    DisconnectUI,
17    DisconnectUnknown,
18    
19    ConnectionError(HubError),
20    
21    BuilderConfig {
22        uid: HubUid,
23        config: HubBuilderConfig
24    },
25    
26    // make client stuff
27    Build {
28        uid: HubUid,
29        workspace: String,
30        package: String,
31        config: String
32    },
33    
34    BuildFailure {
35        uid: HubUid,
36    },
37    
38    BuildSuccess {
39        uid: HubUid,
40    },
41    
42    BuildKill {
43        uid: HubUid
44    },
45    
46    CargoBegin {
47        uid: HubUid,
48    },
49    
50    LogItem {
51        uid: HubUid,
52        item: HubLogItem
53    },
54    
55    CargoArtifact {
56        uid: HubUid,
57        package_id: String,
58        fresh: bool
59    },
60    
61    CargoEnd {
62        uid: HubUid,
63        build_result: BuildResult
64    },
65    
66    ListPackagesRequest {
67        uid: HubUid
68    },
69    
70    ListPackagesResponse {
71        uid: HubUid,
72        packages: Vec<HubPackage>
73    },
74    
75    ProgramKill {
76        uid: HubUid
77    },
78    
79    ProgramRun {
80        uid: HubUid,
81        path: String,
82        args: Vec<String>
83    },
84    
85    ProgramBegin {
86        uid: HubUid
87    },
88    
89    ProgramEnd {
90        uid: HubUid
91    },
92    
93    BuilderFileTreeRequest {
94        uid: HubUid,
95        create_digest: bool
96    },
97    
98    BuilderFileTreeResponse {
99        uid: HubUid,
100        tree: BuilderFileTreeNode
101    },
102    
103    ListBuildersRequest {
104        uid: HubUid,
105    },
106    
107    ListBuildersResponse {
108        uid: HubUid,
109        builders: Vec<String>
110    },
111    
112    FileReadRequest {
113        uid: HubUid,
114        path: String
115    },
116    
117    FileReadResponse {
118        uid: HubUid,
119        path: String,
120        data: Option<Vec<u8>>
121    },
122    
123    FileWriteRequest {
124        uid: HubUid,
125        path: String,
126        data: Vec<u8>
127    },
128    
129    FileWriteResponse {
130        uid: HubUid,
131        path: String,
132        done: bool
133    },
134}
135
136impl HubMsg{
137    pub fn is_blocking(&self)->bool{
138        match self{
139            HubMsg::BuilderConfig{..}=>true,
140            HubMsg::FileWriteRequest{..}=>true,
141            _=>false
142        }
143    }
144}
145
146#[derive(Eq, PartialEq, Debug, Clone, Serialize, Deserialize)]
147pub enum BuilderFileTreeNode {
148    File {name: String, digest:Option<Box<Digest>>},
149    Folder {name: String, digest:Option<Box<Digest>>, folder: Vec<BuilderFileTreeNode>}
150}
151
152impl Ord for BuilderFileTreeNode {
153    fn cmp(&self, other: &BuilderFileTreeNode) -> Ordering {
154        match self {
155            BuilderFileTreeNode::File {name: lhs, ..} => {
156                match other {
157                    BuilderFileTreeNode::File {name: rhs, ..} => {
158                        lhs.cmp(rhs)
159                    },
160                    BuilderFileTreeNode::Folder {name: _rhs, ..} => {
161                        Ordering::Greater
162                    },
163                }
164            },
165            BuilderFileTreeNode::Folder {name: lhs, ..} => {
166                match other {
167                    BuilderFileTreeNode::File {name: _rhs, ..} => {
168                        Ordering::Less
169                    },
170                    BuilderFileTreeNode::Folder {name: rhs, ..} => {
171                        lhs.cmp(rhs)
172                    },
173                }
174            },
175        }
176    }
177}
178
179impl PartialOrd for BuilderFileTreeNode {
180    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
181        Some(self.cmp(other))
182    }
183}
184
185
186#[derive(Debug, Clone, Serialize, Deserialize)]
187pub enum BuildResult {
188    Executable {path: String},
189    Wasm {path: String},
190    Library {path: String},
191    NoOutput,
192    Error,
193}
194
195#[derive(Debug, Clone, Serialize, Deserialize)]
196pub struct HubPackage {
197    pub project: String,
198    pub package_name: String,
199    pub configs: Vec<String>,
200}
201
202impl HubPackage {
203    pub fn new(project: &str, package_name: &str, targets: &[&str]) -> HubPackage {
204        HubPackage {
205            project: project.to_string(),
206            package_name: package_name.to_string(),
207            configs: targets.iter().map( | v | v.to_string()).collect()
208        }
209    }
210}
211
212
213#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
214pub struct HubBuilderConfig {
215    pub http_server: HttpServerConfig,
216    pub workspaces: HashMap<String, String>,
217}
218
219
220#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
221pub struct LocMessage {
222    pub path: String,
223    pub row: usize,
224    pub col: usize,
225    pub body: String,
226    pub range: Option<(usize, usize)>,
227    pub rendered: Option<String>,
228    pub explanation: Option<String>,
229}
230
231#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
232pub enum HubLogItem {
233    LocPanic(LocMessage),
234    LocError(LocMessage),
235    LocWarning(LocMessage),
236    LocMessage(LocMessage),
237    Error(String),
238    Warning(String),
239    Message(String)
240}
241
242impl HubLogItem {
243    pub fn get_loc_message(&self) -> Option<&LocMessage> {
244        match self {
245            HubLogItem::LocPanic(msg) => Some(msg),
246            HubLogItem::LocError(msg) => Some(msg),
247            HubLogItem::LocWarning(msg) => Some(msg),
248            HubLogItem::LocMessage(msg) => Some(msg),
249            HubLogItem::Error(_) => None,
250            HubLogItem::Warning(_) => None,
251            HubLogItem::Message(_) => None
252        }
253    }
254    pub fn get_body(&self) -> &String {
255        match self {
256            HubLogItem::LocPanic(msg) => &msg.body,
257            HubLogItem::LocError(msg) => &msg.body,
258            HubLogItem::LocWarning(msg) => &msg.body,
259            HubLogItem::LocMessage(msg) => &msg.body,
260            HubLogItem::Error(body) => body,
261            HubLogItem::Warning(body) => body,
262            HubLogItem::Message(body) => body
263        }
264    }
265}
266
267#[derive(Debug, Clone, Serialize, Deserialize)]
268pub struct HubCargoArtifact {
269    pub package_id: String,
270    pub fresh: bool,
271}
272
273#[derive(Debug, Clone, Serialize, Deserialize)]
274pub struct HubCargoCheck {
275    pub target: String,
276    pub args: String,
277}
278
279#[derive(PartialEq, Copy, Debug, Clone, Serialize, Deserialize)]
280pub enum HubAddr {
281    None,
282    Local {uid: u64},
283    V4 {octets: [u8; 4], port: u16},
284    V6 {octets: [u8; 16], port: u16},
285}
286
287impl HubAddr {
288    pub fn port(&self) -> u16 {
289        match self {
290            HubAddr::V4 {port, ..} => *port,
291            HubAddr::V6 {port, ..} => *port,
292            HubAddr::Local{..}=> 0,
293            HubAddr::None{..}=> 0,
294        }
295    }
296}
297
298impl HubAddr {
299    //pub fn zero() -> HubAddr {
300    //    HubAddr::V4 {octets: [0, 0, 0, 0], port: 0}
301   // }
302    
303    pub fn from_socket_addr(addr: SocketAddr) -> HubAddr {
304        match addr {
305            SocketAddr::V4(v4) => HubAddr::V4 {octets: v4.ip().octets(), port: v4.port()},
306            SocketAddr::V6(v6) => HubAddr::V6 {octets: v6.ip().octets(), port: v6.port()},
307        }
308    }
309}
310
311#[derive(Debug, Clone, Serialize, Deserialize)]
312pub enum HubMsgTo {
313    Client(HubAddr),
314    Builder(String),
315    UI,
316    All,
317    Hub
318}
319
320#[derive(PartialEq, Copy, Debug, Clone, Serialize, Deserialize)]
321pub struct HubUid {
322    pub addr: HubAddr,
323    pub id: u64
324}
325
326impl HubUid {
327    pub fn zero() -> HubUid {
328        HubUid {addr: HubAddr::None, id: 0}
329    }
330}
331
332#[derive(Debug, Clone, Serialize, Deserialize)]
333pub struct ToHubMsg {
334    pub to: HubMsgTo,
335    pub msg: HubMsg
336}
337
338#[derive(Clone, Debug, Serialize, Deserialize)]
339pub struct FromHubMsg {
340    pub from: HubAddr,
341    pub msg: HubMsg
342}
343
344#[derive(Clone, Debug, Serialize, Deserialize)]
345pub struct HubError {
346    pub msg: String
347}
348
349impl HubError {
350    pub fn new(msg: &str) -> HubError {HubError {msg: msg.to_string()}}
351}
352
353#[derive(Clone)]
354pub enum HubLog {
355    All,
356    None
357}
358
359impl HubLog {
360    pub fn msg<T>(&self, prefix: &str, htc_msg: &T)
361    where T: std::fmt::Debug
362    {
363        match self {
364            HubLog::All => {
365                let mut msg = format!("{:?}", htc_msg);
366                if msg.len()>200 {
367                    msg.truncate(200);
368                    msg.push_str("...")
369                }
370                println!("{} {}", prefix, msg);
371            },
372            _ => ()
373        }
374    }
375    pub fn log(&self, msg: &str)
376    {
377        match self {
378            HubLog::All => {
379                println!("{}", msg);
380            },
381            _ => ()
382        }
383    }
384}
makepad_hub/hubmsg.rs

makepad_hub/
hubmsg.rs
