ssh_host/ssh_host.rs
1use std::path::PathBuf;
2
3/// this structure is used for storing the hostdata for easier storrage of the related information
4///
5/// The `name` field is the name of the remote.
6///
7/// The `address` field store the address of the remote hosts.
8///
9/// The `port` is for the remote port that ssh must use to connect.
10///
11/// The `private_key` is the path to the private_key to use.
12pub struct SshHost {
13 name: String,
14 address: String,
15 user: String,
16 port: i64,
17 private_key: Option<PathBuf>,
18 reachable: bool,
19}
20
21impl SshHost {
22 /// return a new struct `SshHost`
23 ///
24 /// # Examples
25 ///
26 /// ```
27 /// # use ssh_host::SshHost;
28 /// use std::path::PathBuf;
29 ///
30 /// let val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), Some(String::from("user")), None, Some(PathBuf::from("private_key")));
31 /// assert_eq!(val.get_name(), String::from("hello"));
32 /// assert_eq!(val.get_address(), String::from("127.0.0.1"));
33 /// assert_eq!(val.get_user(), String::from("user"));
34 /// assert_eq!(val.get_port(), 22);
35 /// assert_eq!(val.get_private_key().unwrap(), PathBuf::from("private_key"));
36 /// assert_eq!(val.is_reachable(), true);
37 /// assert_eq!(val.get_url().unwrap(), String::from("127.0.0.1:22"));
38 /// ```
39 pub fn new(name: String, address: String, user: Option<String>, port: Option<i64>, private_key: Option<PathBuf>) -> SshHost {
40 let user = match user {
41 Some(s) => s,
42 None => whoami::username(),
43 };
44 let port = match port {
45 Some(s) => s,
46 None => 22,
47 };
48 SshHost {
49 name: name.clone(),
50 address: address.clone(),
51 user: user,
52 port: port,
53 private_key: private_key.clone(),
54 reachable: true,
55 }
56 }
57
58 /// return the name of the remote
59 ///
60 /// # Examples
61 ///
62 /// ```
63 /// # use ssh_host::SshHost;
64 ///
65 /// let val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), None, None, None);
66 /// assert_eq!(val.get_name(), String::from("hello"));
67 /// ```
68 pub fn get_name(&self) -> String {
69 self.name.clone()
70 }
71
72 /// set the name of the remote
73 ///
74 /// # Examples
75 ///
76 /// ```
77 /// # use ssh_host::SshHost;
78 ///
79 /// let mut val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), None, None, None);
80 /// assert_eq!(val.get_name(), String::from("hello"));
81 /// val.set_name(String::from("foobar"));
82 /// assert_eq!(val.get_name(), String::from("foobar"));
83 /// ```
84 pub fn set_name(&mut self, new_name: String) {
85 self.name = new_name
86 }
87
88 /// return the address of the remote
89 ///
90 /// # Examples
91 ///
92 /// ```
93 /// # use ssh_host::SshHost;
94 ///
95 /// let val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), None, None, None);
96 /// assert_eq!(val.get_address(), String::from("127.0.0.1"));
97 /// ```
98 pub fn get_address(&self) -> String {
99 self.address.clone()
100 }
101
102 /// set the address of the remote
103 ///
104 /// # Examples
105 ///
106 /// ```
107 /// # use ssh_host::SshHost;
108 ///
109 /// let mut val = SshHost::new(String::from("hello"), String::from("127.0.0.2"), None, None, None);
110 /// assert_eq!(val.get_address(), String::from("127.0.0.2"));
111 /// val.set_address(String::from("127.0.0.1"));
112 /// assert_eq!(val.get_address(), String::from("127.0.0.1"));
113 /// ```
114 pub fn set_address(&mut self, new_address: String) {
115 self.address = new_address;
116 }
117
118 /// return the user of the remote
119 ///
120 /// # Examples
121 ///
122 /// ```
123 /// # use ssh_host::SshHost;
124 ///
125 /// let val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), Some(String::from("user")), None, None);
126 /// assert_eq!(val.get_user(), String::from("user"));
127 /// ```
128 pub fn get_user(&self) -> String {
129 self.user.clone()
130 }
131
132 /// set the address of the remote
133 ///
134 /// # Examples
135 ///
136 /// ```
137 /// # use ssh_host::SshHost;
138 ///
139 /// let mut val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), Some(String::from("user")), None, None);
140 /// assert_eq!(val.get_user(), String::from("user"));
141 /// val.set_user(String::from("root"));
142 /// assert_eq!(val.get_user(), String::from("root"));
143 /// ```
144 pub fn set_user(&mut self, new_user: String) {
145 self.user = new_user;
146 }
147
148 /// return the port of the remote
149 ///
150 /// # Examples
151 ///
152 /// ```
153 /// # use ssh_host::SshHost;
154 ///
155 /// let val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), None, Some(2222), None);
156 /// assert_eq!(val.get_port(), 2222);
157 /// ```
158 pub fn get_port(&self) -> i64 {
159 self.port.clone()
160 }
161
162 /// set the port of the remote
163 ///
164 /// # Examples
165 ///
166 /// ```
167 /// # use ssh_host::SshHost;
168 ///
169 /// let mut val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), None, None, None);
170 /// assert_eq!(val.get_port(), 22);
171 /// val.set_port(2222);
172 /// assert_eq!(val.get_port(), 2222);
173 /// ```
174 pub fn set_port(&mut self, new_port: i64) {
175 self.port = new_port;
176 }
177
178 /// return the private key file of the remote
179 ///
180 /// # Examples
181 ///
182 /// ```
183 /// # use ssh_host::SshHost;
184 /// use std::path::PathBuf;
185 ///
186 /// let val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), None, None, Some(PathBuf::from("private_key")));
187 /// assert_eq!(val.get_private_key().unwrap(), PathBuf::from("private_key"));
188 /// ```
189 pub fn get_private_key(&self) -> Option<PathBuf> {
190 self.private_key.clone()
191 }
192
193 /// set the the private_key of the remote
194 ///
195 /// # Examples
196 ///
197 /// ```
198 /// # use ssh_host::SshHost;
199 /// use std::path::PathBuf;
200 ///
201 /// let mut val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), None, None, Some(PathBuf::from("private_key")));
202 /// assert_eq!(val.get_private_key().unwrap(), PathBuf::from("private_key"));
203 /// val.set_private_key(Some(PathBuf::from("private_key_2")));
204 /// assert_eq!(val.get_private_key().unwrap(), PathBuf::from("private_key_2"));
205 /// ```
206 pub fn set_private_key(&mut self, new_key: Option<PathBuf>) {
207 self.private_key = new_key;
208 }
209
210 /// return if the remote hosts is available or not
211 ///
212 /// # Examples
213 ///
214 /// ```
215 /// # use ssh_host::SshHost;
216 /// use std::path::PathBuf;
217 ///
218 /// let val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), None, None, None);
219 /// assert_eq!(val.is_reachable(), true);
220 /// ```
221 pub fn is_reachable(&self) -> bool {
222 self.reachable.clone()
223 }
224
225 /// set the remote value
226 ///
227 /// # Examples
228 ///
229 /// ```
230 /// # use ssh_host::SshHost;
231 /// use std::path::PathBuf;
232 ///
233 /// let mut val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), None, None, None);
234 /// assert_eq!(val.is_reachable(), true);
235 /// val.set_reachable(false);
236 /// assert_eq!(val.is_reachable(), false);
237 /// ```
238 pub fn set_reachable(&mut self, new_val: bool) {
239 self.reachable = new_val;
240 }
241
242 /// return the url of the hosts
243 ///
244 /// It will be in the form of `address:port` like `127.0.0.1:22`
245 ///
246 /// # Examples
247 ///
248 /// ```
249 /// # use ssh_host::SshHost;
250 /// use std::path::PathBuf;
251 ///
252 /// let val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), None, Some(2222), None);
253 /// assert_eq!(val.get_url().unwrap(), String::from("127.0.0.1:2222"));
254 /// ```
255 pub fn get_url(&self) -> Result<String, &str> {
256 let mut val = String::from(&self.address);
257 val.push_str(":");
258 val.push_str(&self.port.to_string());
259 if val.is_empty() == false {
260 Ok(val)
261 } else {
262 Err("Error with the url assembly")
263 }
264 }
265}
266
267#[cfg(test)]
268mod tests {
269 use super::*;
270
271 #[test]
272 fn test_method_new() {
273 let val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), Some(String::from("user")), Some(2222), Some(PathBuf::from("private_key")));
274 assert_eq!(val.get_name(), String::from("hello"));
275 assert_eq!(val.get_address(), String::from("127.0.0.1"));
276 assert_eq!(val.get_user(), String::from("user"));
277 assert_eq!(val.get_port(), 2222);
278 assert_eq!(val.get_private_key().unwrap(), PathBuf::from("private_key"));
279 assert_eq!(val.is_reachable(), true);
280 assert_eq!(val.get_url().unwrap(), String::from("127.0.0.1:2222"));
281 }
282 #[test]
283 fn test_method_new_none_port() {
284 let val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), Some(String::from("user")), None, Some(PathBuf::from("private_key")));
285 assert_eq!(val.get_name(), String::from("hello"));
286 assert_eq!(val.get_address(), String::from("127.0.0.1"));
287 assert_eq!(val.get_user(), String::from("user"));
288 assert_eq!(val.get_port(), 22);
289 assert_eq!(val.get_private_key().unwrap(), PathBuf::from("private_key"));
290 assert_eq!(val.is_reachable(), true);
291 assert_eq!(val.get_url().unwrap(), String::from("127.0.0.1:22"));
292 }
293 #[test]
294 fn test_method_new_none_private_key() {
295 let val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), Some(String::from("user")), Some(2222), None);
296 assert_eq!(val.get_name(), String::from("hello"));
297 assert_eq!(val.get_address(), String::from("127.0.0.1"));
298 assert_eq!(val.get_user(), String::from("user"));
299 assert_eq!(val.get_port(), 2222);
300 assert_eq!(val.get_private_key(), None);
301 assert_eq!(val.is_reachable(), true);
302 assert_eq!(val.get_url().unwrap(), String::from("127.0.0.1:2222"));
303 }
304 #[test]
305 fn test_get_name() {
306 let val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), None, None, None);
307 assert_eq!(val.get_name(), String::from("hello"));
308 }
309 #[test]
310 fn test_set_name() {
311 let mut val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), None, None, None);
312 assert_eq!(val.get_name(), String::from("hello"));
313 val.set_name(String::from("foobar"));
314 assert_eq!(val.get_name(), String::from("foobar"));
315 }
316 #[test]
317 fn test_get_address() {
318 let val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), None, None, None);
319 assert_eq!(val.get_address(), String::from("127.0.0.1"));
320 }
321 #[test]
322 fn test_set_address() {
323 let mut val = SshHost::new(String::from("hello"), String::from("127.0.0.2"), None, None, None);
324 assert_eq!(val.get_address(), String::from("127.0.0.2"));
325 val.set_address(String::from("127.0.0.1"));
326 assert_eq!(val.get_address(), String::from("127.0.0.1"));
327 }
328 #[test]
329 fn test_get_user() {
330 let val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), Some(String::from("user")), None, None);
331 assert_eq!(val.get_user(), String::from("user"));
332 }
333 #[test]
334 fn test_set_user() {
335 let mut val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), Some(String::from("user")), None, None);
336 assert_eq!(val.get_user(), String::from("user"));
337 val.set_user(String::from("root"));
338 assert_eq!(val.get_user(), String::from("root"));
339 }
340 #[test]
341 fn test_get_port() {
342 let val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), None, Some(22), None);
343 assert_eq!(val.get_port(), 22);
344 }
345 #[test]
346 fn test_set_port() {
347 let mut val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), None, Some(22), None);
348 assert_eq!(val.get_port(), 22);
349 val.set_port(2222);
350 assert_eq!(val.get_port(), 2222);
351 }
352 #[test]
353 fn test_get_private_key() {
354 let val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), None, None, Some(PathBuf::from("private_key")));
355 assert_eq!(val.get_private_key().unwrap(), PathBuf::from("private_key"));
356 }
357 #[test]
358 fn test_set_private_key() {
359 let mut val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), None, None, Some(PathBuf::from("private_key")));
360 assert_eq!(val.get_private_key().unwrap(), PathBuf::from("private_key"));
361 val.set_private_key(Some(PathBuf::from("private_key_2")));
362 assert_eq!(val.get_private_key().unwrap(), PathBuf::from("private_key_2"));
363 }
364 #[test]
365 fn test_is_reachable() {
366 let val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), None, None, None);
367 assert_eq!(val.is_reachable(), true);
368 }
369 #[test]
370 fn test_set_reachable() {
371 let mut val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), None, None, None);
372 assert_eq!(val.is_reachable(), true);
373 val.set_reachable(false);
374 assert_eq!(val.is_reachable(), false);
375 }
376 #[test]
377 fn test_get_url() {
378 let val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), None, Some(22), None);
379 assert_eq!(val.get_url().unwrap(), String::from("127.0.0.1:22"));
380 }
381 #[test]
382 fn test_get_url_port_none() {
383 let val = SshHost::new(String::from("hello"), String::from("127.0.0.1"), None, None, None);
384 assert_eq!(val.get_url().unwrap(), String::from("127.0.0.1:22"));
385 }
386}