digitalocean_api/api/
volume.rs1use super::region::Region;
2use super::snapshot::Snapshot;
3use super::{ApiLinks, ApiMeta};
4use super::{HasPagination, HasResponse, HasValue};
5use crate::method::{Create, Delete, Get, List};
6use crate::request::Request;
7use crate::request::{SnapshotRequest, VolumeRequest};
8use crate::{ROOT_URL, STATIC_URL_ERROR};
9use chrono::{DateTime, Utc};
10use getset::{Getters, Setters};
11use serde::Deserialize;
12use serde::Serialize;
13use std::fmt::Display;
14use url::Url;
15
16const VOLUME_SEGMENT: &str = "volumes";
17const SNAPSHOTS_SEGMENT: &str = "snapshots";
18
19#[derive(Deserialize, Serialize, Debug, Clone, Getters, Setters)]
27#[get = "pub"]
28pub struct Volume {
29 id: String,
31
32 region: Region,
37
38 droplet_ids: Vec<usize>,
42
43 name: String,
47
48 description: String,
50
51 size_gigabytes: f32,
53
54 created_at: DateTime<Utc>,
57}
58
59impl Volume {
60 pub fn list() -> VolumeRequest<List, Vec<Volume>> {
62 let mut url = ROOT_URL.clone();
63 url.path_segments_mut()
64 .expect(STATIC_URL_ERROR)
65 .push(VOLUME_SEGMENT);
66
67 Request::new(url)
68 }
69
70 pub fn create<S>(name: S, size_gigabytes: usize) -> VolumeRequest<Create, Volume>
72 where
73 S: AsRef<str> + Serialize + Display,
74 {
75 let mut url = ROOT_URL.clone();
76 url.path_segments_mut()
77 .expect(STATIC_URL_ERROR)
78 .push(VOLUME_SEGMENT);
79
80 let mut req = Request::new(url);
81 req.set_body(json!({
82 "name": name,
83 "size_gigabytes": size_gigabytes,
84 }));
85 req
86 }
87 pub fn get<S: AsRef<str> + Serialize + Display>(id: S) -> VolumeRequest<Get, Volume> {
89 let mut url = ROOT_URL.clone();
90 url.path_segments_mut()
91 .expect(STATIC_URL_ERROR)
92 .push(VOLUME_SEGMENT)
93 .push(id.as_ref());
94
95 Request::new(url)
96 }
97 pub fn get_by_name<S>(name: S, region: S) -> VolumeRequest<Get, Volume>
99 where
100 S: AsRef<str> + Serialize + Display,
101 {
102 let mut url = ROOT_URL.clone();
103 url.path_segments_mut()
104 .expect(STATIC_URL_ERROR)
105 .push(VOLUME_SEGMENT);
106
107 url.query_pairs_mut()
108 .append_pair("name", name.as_ref())
109 .append_pair("region", region.as_ref());
110
111 Request::new(url)
112 }
113 pub fn delete<S: AsRef<str> + Serialize + Display>(id: S) -> VolumeRequest<Delete, ()> {
115 let mut url = ROOT_URL.clone();
116 url.path_segments_mut()
117 .expect(STATIC_URL_ERROR)
118 .push(VOLUME_SEGMENT)
119 .push(id.as_ref());
120
121 Request::new(url)
122 }
123 pub fn delete_by_name<S>(name: S, region: S) -> VolumeRequest<Delete, ()>
125 where
126 S: AsRef<str> + Serialize + Display,
127 {
128 let mut url = ROOT_URL.clone();
129 url.path_segments_mut()
130 .expect(STATIC_URL_ERROR)
131 .push(VOLUME_SEGMENT);
132
133 url.query_pairs_mut()
134 .append_pair("name", name.as_ref())
135 .append_pair("region", region.as_ref());
136
137 Request::new(url)
138 }
139}
140
141impl VolumeRequest<List, Vec<Volume>> {
142 pub fn region<S: AsRef<str> + Serialize + Display>(mut self, region: S) -> Self {
144 self.url_mut()
145 .query_pairs_mut()
146 .append_pair("region", region.as_ref());
147
148 self
149 }
150}
151
152impl VolumeRequest<Get, Volume> {
153 pub fn snapshots(mut self) -> SnapshotRequest<List, Vec<Snapshot>> {
155 self.url_mut()
156 .path_segments_mut()
157 .expect(STATIC_URL_ERROR)
158 .push(SNAPSHOTS_SEGMENT);
159
160 self.transmute()
161 }
162
163 pub fn snapshot<S>(mut self, name: S) -> SnapshotRequest<Create, Snapshot>
165 where
166 S: AsRef<str> + Serialize + Display,
167 {
168 self.url_mut()
169 .path_segments_mut()
170 .expect(STATIC_URL_ERROR)
171 .push(SNAPSHOTS_SEGMENT);
172
173 self.set_body(json!({ "name": name }));
174
175 self.transmute()
176 }
177}
178
179impl VolumeRequest<Create, Volume> {
180 pub fn description<S: AsRef<str> + Serialize + Display>(mut self, val: S) -> Self {
184 self.body_mut()["description"] = json!(val);
185 self
186 }
187
188 pub fn region<S: AsRef<str> + Serialize + Display>(mut self, val: S) -> Self {
197 self.body_mut()["region"] = json!(val);
198 self
199 }
200
201 pub fn snapshot_id<S: AsRef<str> + Serialize + Display>(mut self, val: S) -> Self {
208 self.body_mut()["snapshot_id"] = json!(val);
209 self
210 }
211}
212
213#[derive(Deserialize, Serialize, Debug, Clone)]
215pub struct VolumeListResponse {
216 volumes: Vec<Volume>,
217 links: ApiLinks,
218 meta: ApiMeta,
219}
220
221impl HasResponse for Vec<Volume> {
222 type Response = VolumeListResponse;
223}
224
225impl HasPagination for VolumeListResponse {
226 fn next_page(&self) -> Option<Url> {
227 self.links.next()
228 }
229}
230
231impl HasValue for VolumeListResponse {
232 type Value = Vec<Volume>;
233
234 fn value(self) -> Vec<Volume> {
235 self.volumes
236 }
237}
238
239#[derive(Deserialize, Serialize, Debug, Clone)]
241pub struct VolumeResponse {
242 volume: Volume,
243}
244
245impl HasResponse for Volume {
246 type Response = VolumeResponse;
247}
248
249impl HasValue for VolumeResponse {
250 type Value = Volume;
251
252 fn value(self) -> Volume {
253 self.volume
254 }
255}