network_manager/
manager.rs

1use std::rc::Rc;
2
3use errors::*;
4use dbus_nm::DBusNetworkManager;
5
6use connection::{get_active_connections, get_connections, Connection};
7use device::{get_device_by_interface, get_devices, Device};
8use service::{get_service_state, start_service, stop_service, ServiceState};
9
10pub struct NetworkManager {
11    dbus_manager: Rc<DBusNetworkManager>,
12}
13
14impl NetworkManager {
15    pub fn new() -> Self {
16        NetworkManager {
17            dbus_manager: Rc::new(DBusNetworkManager::new(None)),
18        }
19    }
20
21    pub fn with_method_timeout(timeout: u64) -> Self {
22        NetworkManager {
23            dbus_manager: Rc::new(DBusNetworkManager::new(Some(timeout))),
24        }
25    }
26
27    /// Starts the Network Manager service.
28    ///
29    /// # Examples
30    ///
31    /// ```
32    /// use network_manager::NetworkManager;
33    /// let state = NetworkManager::start_service(10).unwrap();
34    /// println!("{:?}", state);
35    /// ```
36    pub fn start_service(timeout: u64) -> Result<ServiceState> {
37        start_service(timeout)
38    }
39
40    /// Stops the Network Manager service.
41    ///
42    /// # Examples
43    ///
44    /// ```
45    /// use network_manager::NetworkManager;
46    /// let state = NetworkManager::stop_service(10).unwrap();
47    /// println!("{:?}", state);
48    /// ```
49    pub fn stop_service(timeout: u64) -> Result<ServiceState> {
50        stop_service(timeout)
51    }
52
53    /// Gets the state of the Network Manager service.
54    ///
55    /// # Examples
56    ///
57    /// ```
58    /// use network_manager::NetworkManager;
59    /// let state = NetworkManager::get_service_state().unwrap();
60    /// println!("{:?}", state);
61    /// ```
62    pub fn get_service_state() -> Result<ServiceState> {
63        get_service_state()
64    }
65
66    /// Get a list of Network Manager connections sorted by path.
67    ///
68    /// # Examples
69    ///
70    /// ```
71    /// use network_manager::NetworkManager;
72    /// let manager = NetworkManager::new();
73    /// let connections = manager.get_connections().unwrap();
74    /// println!("{:?}", connections);
75    /// ```
76    pub fn get_connections(&self) -> Result<Vec<Connection>> {
77        get_connections(&self.dbus_manager)
78    }
79
80    pub fn get_active_connections(&self) -> Result<Vec<Connection>> {
81        get_active_connections(&self.dbus_manager)
82    }
83
84    /// Get a list of Network Manager devices.
85    ///
86    /// # Examples
87    ///
88    /// ```
89    /// use network_manager::NetworkManager;
90    /// let manager = NetworkManager::new();
91    /// let devices = manager.get_devices().unwrap();
92    /// println!("{:?}", devices);
93    /// ```
94    pub fn get_devices(&self) -> Result<Vec<Device>> {
95        get_devices(&self.dbus_manager)
96    }
97
98    pub fn get_device_by_interface(&self, interface: &str) -> Result<Device> {
99        get_device_by_interface(&self.dbus_manager, interface)
100    }
101
102    pub fn get_state(&self) -> Result<NetworkManagerState> {
103        self.dbus_manager.get_state()
104    }
105
106    pub fn get_connectivity(&self) -> Result<Connectivity> {
107        self.dbus_manager.check_connectivity()
108    }
109
110    pub fn is_networking_enabled(&self) -> Result<bool> {
111        self.dbus_manager.is_networking_enabled()
112    }
113
114    pub fn is_wireless_enabled(&self) -> Result<bool> {
115        self.dbus_manager.is_wireless_enabled()
116    }
117}
118
119impl Default for NetworkManager {
120    fn default() -> Self {
121        Self::new()
122    }
123}
124
125#[derive(Clone, Debug, PartialEq)]
126pub enum NetworkManagerState {
127    Unknown,
128    Asleep,
129    Disconnected,
130    Disconnecting,
131    Connecting,
132    ConnectedLocal,
133    ConnectedSite,
134    ConnectedGlobal,
135}
136
137impl From<u32> for NetworkManagerState {
138    fn from(state: u32) -> Self {
139        match state {
140            0 => NetworkManagerState::Unknown,
141            10 => NetworkManagerState::Asleep,
142            20 => NetworkManagerState::Disconnected,
143            30 => NetworkManagerState::Disconnecting,
144            40 => NetworkManagerState::Connecting,
145            50 => NetworkManagerState::ConnectedLocal,
146            60 => NetworkManagerState::ConnectedSite,
147            70 => NetworkManagerState::ConnectedGlobal,
148            _ => {
149                warn!("Undefined Network Manager state: {}", state);
150                NetworkManagerState::Unknown
151            },
152        }
153    }
154}
155
156#[derive(Clone, Debug, PartialEq)]
157pub enum Connectivity {
158    Unknown,
159    None,
160    Portal,
161    Limited,
162    Full,
163}
164
165impl From<u32> for Connectivity {
166    fn from(state: u32) -> Self {
167        match state {
168            0 => Connectivity::Unknown,
169            1 => Connectivity::None,
170            2 => Connectivity::Portal,
171            3 => Connectivity::Limited,
172            4 => Connectivity::Full,
173            _ => {
174                warn!("Undefined connectivity state: {}", state);
175                Connectivity::Unknown
176            },
177        }
178    }
179}
180
181#[cfg(test)]
182mod tests {
183    use super::*;
184
185    #[test]
186    fn test_get_connections() {
187        let manager = NetworkManager::new();
188        let connections = manager.get_connections().unwrap();
189        assert!(connections.len() > 0);
190    }
191
192    #[test]
193    fn test_get_devices() {
194        let manager = NetworkManager::new();
195        let devices = manager.get_devices().unwrap();
196        assert!(devices.len() > 0);
197    }
198
199    #[test]
200    fn test_get_connectivity() {
201        let manager = NetworkManager::new();
202        let connectivity = manager.get_connectivity().unwrap();
203        assert_eq!(connectivity, Connectivity::Full);
204    }
205
206    #[test]
207    fn test_start_stop_service() {
208        let s = NetworkManager::get_service_state().unwrap();
209
210        assert!(s == ServiceState::Active || s == ServiceState::Inactive);
211
212        match s {
213            ServiceState::Active => {
214                NetworkManager::stop_service(10).unwrap();
215                assert_eq!(
216                    ServiceState::Inactive,
217                    NetworkManager::get_service_state().unwrap()
218                );
219
220                NetworkManager::start_service(10).unwrap();
221                assert_eq!(
222                    ServiceState::Active,
223                    NetworkManager::get_service_state().unwrap()
224                );
225            },
226            ServiceState::Inactive => {
227                NetworkManager::start_service(10).unwrap();
228                assert_eq!(
229                    ServiceState::Active,
230                    NetworkManager::get_service_state().unwrap()
231                );
232
233                NetworkManager::stop_service(10).unwrap();
234                assert_eq!(
235                    ServiceState::Inactive,
236                    NetworkManager::get_service_state().unwrap()
237                );
238            },
239            _ => (),
240        }
241    }
242}
network_manager/manager.rs

network_manager/
manager.rs
