rship-sdk 0.1.18

rship sdk in rust!
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

use crate::{
    client::SdkClient,
    target::{TargetArgs, TargetProxy},
    EventTrackArgs, EventTrackProxy,
};
use rship_entities::{
    instance::{Instance, InstanceStatus},
    machine::Machine,
    target_status::Status,
};
use std::collections::HashSet;

#[derive(Clone)]
pub struct InstanceArgs {
    pub name: String,
    pub short_id: String,
    pub code: String,
    pub service_id: String,
    pub cluster_id: Option<String>,
    pub color: String,
    pub machine_id: String,
    pub message: Option<String>,
    pub status: InstanceStatus,
}

#[derive(Clone)]
pub struct InstanceProxy {
    pub(crate) args: InstanceArgs,
    pub(crate) client: SdkClient,
}

impl InstanceProxy {
    pub async fn add_target(&self, args: TargetArgs) -> TargetProxy {
        let p = TargetProxy {
            emitters: HashSet::new(),
            actions: HashSet::new(),
            instance: self.clone(),
            args,
            client: self.client.clone(),
        };

        p.save(Status::Online).await;

        p
    }

    pub async fn add_event_track(&self, args: EventTrackArgs) -> EventTrackProxy {
        let p = EventTrackProxy {
            instance: self.clone(),
            args,
            client: self.client.clone(),
        };

        p.save().await;

        p
    }

    pub async fn save(&self) {
        // let client_id = self.client.client.get_client_id().await;
        // if client_id.is_none() {
        //     log::warn!("Could not get client id");
        //     return;
        // }
        let instance = Instance {
            name: self.args.name.clone(),
            id: self.args.short_id.clone(),
            service_type_code: self.args.code.clone(),
            service_id: self.args.service_id.clone(),
            // client_id: None,
            cluster_id: self.args.cluster_id.clone(),
            color: self.args.color.clone(),
            hash: uuid::Uuid::new_v4().to_string(),
            machine_id: self.args.machine_id.clone(),

            message: self.args.message.clone(),
            status: self.args.status.clone(),
        };

        let machine = Machine {
            hash: uuid::Uuid::new_v4().to_string(),
            name: None,
            addresses: vec![],
            dns_name: None,
            exec_name: Some(self.args.machine_id.clone()),
            id: self.args.machine_id.clone(),
        };

        if let Err(err) = self.client.save_item(&machine).await {
            log::error!("Could not save machine, {}", err);
        }
        if let Err(err) = self.client.save_item(&instance).await {
            log::error!("Could not save instance, {}", err);
        }
    }
}