sysd_manager_comcontroler/
proxy_switcher.rs

1use std::sync::{LazyLock, RwLock};
2
3pub const KEY_PREF_USE_PROXY_START: &str = "pref-use-proxy-start";
4pub const KEY_PREF_USE_PROXY_STOP: &str = "pref-use-proxy-stop";
5pub const KEY_PREF_USE_PROXY_RESTART: &str = "pref-use-proxy-restart";
6pub const KEY_PREF_USE_PROXY_RELAOD_UNIT: &str = "pref-use-proxy-reload-unit";
7pub const KEY_PREF_USE_PROXY_CLEAN: &str = "pref-use-proxy-clean";
8pub const KEY_PREF_USE_PROXY_FREEZE: &str = "pref-use-proxy-freeze";
9pub const KEY_PREF_USE_PROXY_THAW: &str = "pref-use-proxy-thaw";
10pub const KEY_PREF_USE_PROXY_ENABLE_UNIT_FILE: &str = "pref-use-proxy-enable-unit-file";
11pub const KEY_PREF_USE_PROXY_DISABLE_UNIT_FILE: &str = "pref-use-proxy-disable-unit-file";
12pub const KEY_PREF_USE_PROXY_RELOAD_DAEMON: &str = "pref-use-proxy-reload-daemon";
13pub const KEY_PREF_USE_PROXY_CREATE_DROP_IN: &str = "pref-use-proxy-create-drop-in";
14pub const KEY_PREF_USE_PROXY_SAVE_FILE: &str = "pref-use-proxy-save-file";
15pub const KEY_PREF_USE_PROXY_REVERT_UNIT_FILE: &str = "pref-use-proxy-revert-unit-file";
16pub const KEY_PREF_PROXY_START_AT_STARTUP: &str = "pref-proxy-start-at-startup";
17pub const KEY_PREF_PROXY_STOP_AT_CLOSE: &str = "pref-proxy-stop-at-close";
18
19pub static PROXY_SWITCHER: LazyLock<ProxySwitcher> = LazyLock::new(|| {
20    let ps = ProxySwitcher::default();
21    #[cfg(not(any(feature = "flatpak", feature = "appimage")))]
22    {
23        use base::consts::APP_ID;
24        use gio::prelude::SettingsExt;
25
26        let settings = gio::Settings::new(APP_ID);
27        let val = settings.boolean(KEY_PREF_USE_PROXY_START);
28        ps.set_start(val);
29        let val = settings.boolean(KEY_PREF_USE_PROXY_STOP);
30        ps.set_stop(val);
31        let val = settings.boolean(KEY_PREF_USE_PROXY_RESTART);
32        ps.set_restart(val);
33        let val = settings.boolean(KEY_PREF_USE_PROXY_RELAOD_UNIT);
34        ps.set_reload_unit(val);
35        let val = settings.boolean(KEY_PREF_USE_PROXY_CLEAN);
36        ps.set_clean(val);
37        let val = settings.boolean(KEY_PREF_USE_PROXY_FREEZE);
38        ps.set_freeze(val);
39        let val = settings.boolean(KEY_PREF_USE_PROXY_THAW);
40        ps.set_thaw(val);
41        let val = settings.boolean(KEY_PREF_USE_PROXY_ENABLE_UNIT_FILE);
42        ps.set_enable_unit_file(val);
43        let val = settings.boolean(KEY_PREF_USE_PROXY_DISABLE_UNIT_FILE);
44        ps.set_disable_unit_file(val);
45        let val = settings.boolean(KEY_PREF_USE_PROXY_RELOAD_DAEMON);
46        ps.set_reload(val);
47        let val = settings.boolean(KEY_PREF_USE_PROXY_CREATE_DROP_IN);
48        ps.set_create_dropin(val);
49        let val = settings.boolean(KEY_PREF_USE_PROXY_SAVE_FILE);
50        ps.set_save_file(val);
51        let val = settings.boolean(KEY_PREF_USE_PROXY_REVERT_UNIT_FILE);
52        ps.set_revert_unit_file(val);
53        let val = settings.boolean(KEY_PREF_PROXY_START_AT_STARTUP);
54        ps.set_start_at_startup(val);
55        let val = settings.boolean(KEY_PREF_PROXY_STOP_AT_CLOSE);
56        ps.set_stop_at_close(val);
57    }
58    ps
59});
60
61#[derive(Default)]
62pub struct ProxySwitcher {
63    start: RwLock<bool>,
64    stop: RwLock<bool>,
65    restart: RwLock<bool>,
66    reload_unit: RwLock<bool>,
67    clean: RwLock<bool>,
68    freeze: RwLock<bool>,
69    thaw: RwLock<bool>,
70    enable_unit_file: RwLock<bool>,
71    disable_unit_file: RwLock<bool>,
72    reload: RwLock<bool>,
73    create_dropin: RwLock<bool>,
74    save_file: RwLock<bool>,
75    revert_unit_file: RwLock<bool>,
76    start_at_start_up: RwLock<bool>,
77    stop_at_close: RwLock<bool>,
78}
79
80impl ProxySwitcher {
81    pub fn start(&self) -> bool {
82        *self.start.read().unwrap()
83    }
84
85    pub fn set_start(&self, value: bool) {
86        *self.start.write().unwrap() = value;
87    }
88
89    pub fn stop(&self) -> bool {
90        *self.stop.read().unwrap()
91    }
92
93    pub fn set_stop(&self, value: bool) {
94        *self.stop.write().unwrap() = value;
95    }
96
97    pub fn restart(&self) -> bool {
98        *self.restart.write().unwrap()
99    }
100
101    pub fn set_restart(&self, value: bool) {
102        *self.restart.write().unwrap() = value;
103    }
104
105    pub fn reload_unit(&self) -> bool {
106        *self.reload_unit.write().unwrap()
107    }
108
109    pub fn set_reload_unit(&self, value: bool) {
110        *self.reload_unit.write().unwrap() = value;
111    }
112
113    pub fn clean(&self) -> bool {
114        *self.clean.read().unwrap()
115    }
116
117    pub fn set_clean(&self, value: bool) {
118        *self.clean.write().unwrap() = value;
119    }
120
121    pub fn freeze(&self) -> bool {
122        *self.freeze.read().unwrap()
123    }
124
125    pub fn set_freeze(&self, value: bool) {
126        *self.freeze.write().unwrap() = value;
127    }
128
129    pub fn thaw(&self) -> bool {
130        *self.thaw.read().unwrap()
131    }
132
133    pub fn set_thaw(&self, value: bool) {
134        *self.thaw.write().unwrap() = value;
135    }
136
137    pub fn enable_unit_file(&self) -> bool {
138        *self.enable_unit_file.read().unwrap()
139    }
140
141    pub fn set_enable_unit_file(&self, value: bool) {
142        *self.enable_unit_file.write().unwrap() = value;
143    }
144
145    pub fn disable_unit_file(&self) -> bool {
146        *self.disable_unit_file.read().unwrap()
147    }
148
149    pub fn set_disable_unit_file(&self, value: bool) {
150        *self.disable_unit_file.write().unwrap() = value;
151    }
152
153    pub fn save_file(&self) -> bool {
154        *self.save_file.read().unwrap()
155    }
156
157    pub fn set_save_file(&self, value: bool) {
158        *self.save_file.write().unwrap() = value;
159    }
160
161    pub fn create_dropin(&self) -> bool {
162        *self.create_dropin.read().unwrap()
163    }
164
165    pub fn set_create_dropin(&self, value: bool) {
166        *self.create_dropin.write().unwrap() = value;
167    }
168
169    pub fn start_at_start_up(&self) -> bool {
170        *self.start_at_start_up.read().unwrap()
171    }
172
173    pub fn set_start_at_startup(&self, value: bool) {
174        *self.start_at_start_up.write().unwrap() = value;
175    }
176
177    pub fn stop_at_close(&self) -> bool {
178        *self.stop_at_close.read().unwrap()
179    }
180
181    pub fn set_stop_at_close(&self, value: bool) {
182        *self.stop_at_close.write().unwrap() = value;
183    }
184
185    pub fn revert_unit_file(&self) -> bool {
186        *self.revert_unit_file.read().unwrap()
187    }
188
189    pub fn set_revert_unit_file(&self, value: bool) {
190        *self.revert_unit_file.write().unwrap() = value;
191    }
192
193    pub fn reload(&self) -> bool {
194        *self.reload.read().unwrap()
195    }
196
197    pub fn set_reload(&self, value: bool) {
198        *self.reload.write().unwrap() = value;
199    }
200
201    pub fn uses_any_proxy(&self) -> bool {
202        self.start()
203            || self.stop()
204            || self.restart()
205            || self.reload_unit()
206            || self.clean()
207            || self.freeze()
208            || self.thaw()
209            || self.create_dropin()
210            || self.disable_unit_file()
211            || self.reload()
212            || self.save_file()
213            || self.enable_unit_file()
214            || self.revert_unit_file()
215    }
216}
sysd_manager_comcontroler/proxy_switcher.rs

sysd_manager_comcontroler/
proxy_switcher.rs
