web-arena-indigo 0.2.0

Unofficial async client for the WebARENA Indigo VPS API (NTTPC): instances, SSH keys, firewalls, snapshots, DNS
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

//! Snapshot APIs.

use crate::http::HttpClient;
use crate::serde_util::{u32_lenient, u64_lenient};
use crate::{WebArenaIndigoApi, WebArenaIndigoApiError};
use serde::{Deserialize, Serialize};
use serde_json::json;

pub struct SnapshotApi<'a> {
    indigo: &'a WebArenaIndigoApi,
}

impl<'a> SnapshotApi<'a> {
    pub(crate) fn new(api: &'a WebArenaIndigoApi) -> Self {
        SnapshotApi { indigo: api }
    }

    /// `POST /webarenaIndigo/v1/disk/takesnapshot`
    pub async fn take_snapshot(
        &self,
        name: &str,
        instance_id: u32,
        slot_num: u32,
    ) -> Result<SnapshotStatusResponse, WebArenaIndigoApiError> {
        HttpClient::post(
            self.indigo.throttle(),
            self.indigo.access_token(),
            &self.indigo.endpoint("/webarenaIndigo/v1/disk/takesnapshot"),
            &json!({
                "name": name,
                "instanceid": instance_id,
                "slotnum": slot_num.to_string(),
            }),
        )
        .await
    }

    /// `GET /webarenaIndigo/v1/disk/snapshotlist/{instance_id}`
    pub async fn snapshot_list(
        &self,
        instance_id: u32,
    ) -> Result<Vec<Snapshot>, WebArenaIndigoApiError> {
        HttpClient::get(
            self.indigo.throttle(),
            self.indigo.access_token(),
            &self.indigo.endpoint(&format!(
                "/webarenaIndigo/v1/disk/snapshotlist/{}",
                instance_id
            )),
        )
        .await
    }

    /// `POST /webarenaIndigo/v1/disk/retakesnapshot`
    pub async fn retake_snapshot(
        &self,
        instance_id: u32,
        snapshot_id: u32,
    ) -> Result<SnapshotStatusResponse, WebArenaIndigoApiError> {
        HttpClient::post(
            self.indigo.throttle(),
            self.indigo.access_token(),
            &self
                .indigo
                .endpoint("/webarenaIndigo/v1/disk/retakesnapshot"),
            &json!({
                "instanceid": instance_id,
                "snapshotid": snapshot_id.to_string(),
            }),
        )
        .await
    }

    /// `POST /webarenaIndigo/v1/disk/restoresnapshot`
    pub async fn restore_snapshot(
        &self,
        instance_id: u32,
        snapshot_id: u32,
    ) -> Result<SnapshotStatusResponse, WebArenaIndigoApiError> {
        HttpClient::post(
            self.indigo.throttle(),
            self.indigo.access_token(),
            &self
                .indigo
                .endpoint("/webarenaIndigo/v1/disk/restoresnapshot"),
            &json!({
                "instanceid": instance_id.to_string(),
                "snapshotid": snapshot_id.to_string(),
            }),
        )
        .await
    }

    /// `DELETE /webarenaIndigo/v1/disk/deletesnapshot/{id}`
    pub async fn destroy_snapshot(
        &self,
        snapshot_id: u32,
    ) -> Result<SnapshotStatusResponse, WebArenaIndigoApiError> {
        HttpClient::delete(
            self.indigo.throttle(),
            self.indigo.access_token(),
            &self.indigo.endpoint(&format!(
                "/webarenaIndigo/v1/disk/deletesnapshot/{}",
                snapshot_id
            )),
        )
        .await
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SnapshotStatusResponse {
    #[serde(rename = "STATUS")]
    pub status: i64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Snapshot {
    pub id: u32,
    pub name: String,
    pub service_id: String,
    /// The API returns this as either a number or a string.
    #[serde(deserialize_with = "u32_lenient")]
    pub user_id: u32,
    pub disk_id: u32,
    pub volume: u32,
    pub slot_number: u32,
    pub status: String,
    /// The API returns this as either a number or a string.
    #[serde(deserialize_with = "u64_lenient")]
    pub size: u64,
    pub deleted: u32,
    pub completed_timestamp: String,
    pub deleted_timestamp: String,
}