swh 0.2.1

A CLI for Switch Hosts
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

use crate::core::host_entry::HostEntry;
use crate::core::kdl::config::Config;
use crate::util;
use miette::{miette, IntoDiagnostic, Result};
use std::fs::OpenOptions;
use std::io::Write;

pub const HOST_FILE_PATH: &str = "/etc/hosts";

#[derive(Debug)]
pub struct HostFile {
    pub entries: Option<Vec<HostEntry>>,
}

pub const SWH_CONTENT_START: &str = "SWH_CONTENT_START";
pub const SWH_CONTENT_END: &str = "SWH_CONTENT_END";

impl HostFile {
    pub fn load() -> Result<Self> {
        match util::read_lines(HOST_FILE_PATH) {
            Ok(lines) => {
                let entries: Option<Vec<HostEntry>> = lines
                    .map(
                        |line| match line.unwrap_or_else(|_e| "".to_string()).parse() {
                            Ok(host_entry) => Some(host_entry),
                            _ => None,
                        },
                    )
                    .collect();
                Ok(Self { entries })
            }
            Err(e) => Err(e).map_err(|e| miette!(e)),
        }
    }

    pub fn sync(&mut self, config: Config) -> Result<()> {
        let mut entries: Vec<HostEntry> = config.into();
        self.purge()?;
        self.merge(&mut entries)?;
        self.write()?;
        Ok(())
    }

    fn write(&self) -> Result<()> {
        let host_file = OpenOptions::new()
            .write(true)
            .truncate(true)
            .open(HOST_FILE_PATH);

        match host_file {
            Ok(mut file) => {
                for entry in self.entries.as_ref().unwrap() {
                    writeln!(file, "{}", entry).into_diagnostic()?;
                }
                Ok(())
            }
            Err(e) => Err(e).map_err(|e| miette!(e)),
        }
    }

    fn purge(&mut self) -> Result<()> {
        if let Some(entries) = self.entries.as_ref() {
            let start_opt = entries
                .iter()
                .position(|e| e.comment == Some(SWH_CONTENT_START.to_string()));
            let end_opt = entries
                .iter()
                .position(|e| e.comment == Some(SWH_CONTENT_END.to_string()));
            return match (start_opt, end_opt) {
                (Some(start), Some(end)) => {
                    let entry_slice = entries.as_slice();
                    let content = [&entry_slice[0..start], &entry_slice[end + 1..]].concat();
                    self.entries = Some(content);
                    Ok(())
                }
                _ => Ok(()),
            };
        }
        Ok(())
    }

    fn merge(&mut self, entries: &mut Vec<HostEntry>) -> Result<()> {
        let mut origin = self.entries.as_ref().unwrap().to_vec();
        origin.append(entries);
        self.entries = Some(origin);
        Ok(())
    }
}