homebrew 0.2.6

A rust wrapper around the homebrew package
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

use serde::{Serialize, Deserialize};
use std::str::FromStr;
use std::fmt;

// 定义状态枚举
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
#[serde(rename_all = "lowercase")] // 使得枚举可以接受小写字符串
pub enum ServiceStatus {
    None,
    Started,
    Error,
}

// 实现从字符串转换为枚举
impl FromStr for ServiceStatus {
    type Err = ();

    fn from_str(input: &str) -> Result<Self, Self::Err> {
        match input {
            "none" => Ok(ServiceStatus::None),
            "started" => Ok(ServiceStatus::Started),
            "error" => Ok(ServiceStatus::Error),
            _ => Err(()),
        }
    }
}

// 实现 Display trait 以便打印
impl fmt::Display for ServiceStatus {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ServiceStatus::None => write!(f, "none"),
            ServiceStatus::Started => write!(f, "started"),
            ServiceStatus::Error => write!(f, "error"),
        }
    }
}

/// `Service` 的结构体
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Service {
    pub name: String,
    pub status: ServiceStatus,
    pub user: Option<String>,
    pub file: String,
    pub exit_code: Option<i8>,
}

impl Service {
    /// 通过 `json` 字符串来新建结构体
    ///
    /// Examples
    ///
    /// ```
    /// use homebrew;
    ///
    /// let json_str = r#"
    /// {
    ///     "name": "mongodb-community@7.0",
    ///     "status": "none",
    ///     "user": "wxnacy",
    ///     "file": "/Users/wxnacy/Library/LaunchAgents/homebrew.mxcl.mongodb-community@7.0.plist",
    ///     "exit_code": null
    /// }
    /// "#;
    ///
    /// let s = homebrew::Service::from(&json_str).unwrap();
    ///
    /// assert_eq!(s.name, "mongodb-community@7.0");
    /// ```
    pub fn from(json_str: &str) -> anyhow::Result<Self> {
        let pkg: Self = serde_json::from_str(json_str)?;
        Ok(pkg)
    }
}

/// 具体服务详情结构体
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct ServiceInfo {
    pub name: String,
    pub service_name: String,
    pub running: bool,
    pub loaded: bool,
    pub schedulable: bool,
    pub pid: Option<u32>,
    pub exit_code: Option<i32>,
    pub user: Option<String>,
    pub status: ServiceStatus, // 使用枚举代替字符串
    pub file: String,
    pub command: String,
    pub working_dir: Option<String>,
    pub root_dir: Option<String>,
    pub log_path: Option<String>,
    pub error_log_path: Option<String>,
    pub interval: Option<String>,
    pub cron: Option<String>,
}

impl ServiceInfo {
    /// 通过 `json` 字符串来新建结构体
    ///
    /// Examples
    ///
    /// ```
    /// use homebrew;
    /// use homebrew::ServiceStatus;
    ///
    /// let json_str = r#"
    /// {
    ///     "name": "redis",
    ///     "service_name": "homebrew.mxcl.redis",
    ///     "running": false,
    ///     "loaded": false,
    ///     "schedulable": false,
    ///     "pid": null,
    ///     "exit_code": null,
    ///     "user": null,
    ///     "status": "none",
    ///     "file": "/opt/homebrew/opt/redis/homebrew.mxcl.redis.plist",
    ///     "command": "/opt/homebrew/opt/redis/bin/redis-server /opt/homebrew/etc/redis.conf",
    ///     "working_dir": "/opt/homebrew/var",
    ///     "root_dir": null,
    ///     "log_path": "/opt/homebrew/var/log/redis.log",
    ///     "error_log_path": "/opt/homebrew/var/log/redis.log",
    ///     "interval": null,
    ///     "cron": null
    /// }
    /// "#;
    ///
    /// let s = homebrew::ServiceInfo::from(&json_str).unwrap();
    ///
    /// assert_eq!(s.name, "redis");
    /// assert_eq!(s.status, ServiceStatus::None);
    /// ```
    pub fn from(json_str: &str) -> anyhow::Result<Self> {
        let pkg: Self = serde_json::from_str(json_str)?;
        Ok(pkg)
    }
}