nimbuspulse-client 0.4.0

NimbusPulse API client
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use serde::{Deserialize, Serialize};
use uuid::Uuid;

use super::billing::BillingType;
use super::dcs_runtime::DcsRuntime;
use super::dcs_settings::DcsSettings;
use super::region::Region;

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum GameType {
    Dcs,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct Instance {
    pub id: Uuid,
    pub node_id: Uuid,
    pub user_id: Uuid,
    pub product_id: Uuid,
    pub log_session_id: Option<Uuid>,
    pub game_type: GameType,
    pub billing_type: BillingType,
    pub port: i32,
    pub webgui_port: i32,
    pub ftp_port: i32,
    pub ftp_username: String,
    pub ftp_password: String,
    pub pid: Option<i32>,
    pub status: InstanceStatus,
    pub want_delete: bool,
    pub rented_at: i64,
    pub rented_until: Option<i64>,
    pub active_mods: Vec<String>,
    pub subscription_cancel_at_period_end: bool,
    pub subscription_overdue: bool,
    pub subscription_next_payment_attempt: Option<i64>,
    pub subscription_next_payment_url: Option<String>,
    pub created_at: String,
    pub dcs_settings: Option<DcsSettings>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct InstanceNodeResource {
    pub region: Region,
    pub ip: String,
    pub domain: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct InstanceResource {
    #[serde(flatten)]
    pub instance: Instance,
    #[serde(flatten)]
    pub node: InstanceNodeResource,
    pub runtime: Option<GameRuntime>,
    pub permissions: Option<InstancePermissions>,
}

pub type InstancesResponse = Vec<InstanceResource>;

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
#[serde(untagged)]
pub enum GameRuntime {
    Dcs(DcsRuntime),
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub struct InstancePermissions {
    pub owner_user: UserResource,
    pub permissions: Vec<Permission>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub struct UserResource {
    pub id: Uuid,
    pub name: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub enum Permission {
    #[serde(rename = "instance:view")]
    InstanceView,
    #[serde(rename = "instance:actions")]
    InstanceActions,
    #[serde(rename = "instance:chat")]
    InstanceChat,
    #[serde(rename = "instance:players:manage")]
    InstancePlayersManage,
    #[serde(rename = "instance:missions")]
    InstanceMissions,
    #[serde(rename = "instance:settings")]
    InstanceSettings,
    #[serde(rename = "instance:infrastructure")]
    InstanceInfrastructure,
    #[serde(rename = "instance:mods")]
    InstanceMods,
    #[serde(rename = "instance:scheduled_tasks")]
    InstanceScheduledTasks,
    #[serde(rename = "instance:file:read")]
    InstanceFileRead,
    #[serde(rename = "instance:file:write")]
    InstanceFileWrite,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub enum InstanceStatus {
    AwaitingContainer,
    InstallingBaseGame {
        progress: Option<u8>,
    },
    InstallingMods {
        is_post_creation: bool,
    },
    UninstallingMods,
    InstallingPost {
        is_post_creation: bool,
    },
    ServerStarted,
    ServerStopped {
        was_error: bool,
        reason: InstanceStoppedReason,
    },
    ServerExpired,
    ServerDeleted,
    WantServerStarted {
        current_try: u32,
    },
    WantServerStopped {
        error_passthrough: Option<(bool, InstanceStoppedReason)>,
    },
    WantUpdateServer {
        was_stopped: bool,
    },
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub enum InstanceStoppedReason {
    StoppedNormally,
    StoppedUnexpectedly,
    MaxTriesReached,
    ServerUpdating,
    RebootRequestedThroughFile,
    DcsSessionExpired,
    DcsAuthFailed,
    StoppedForRestart { scheduled: bool },
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct ApiError {
    pub message: String,
    pub code: String,
}