format

12 files changed, 484 insertions, 140 deletions

diff --git a/src/client.rs b/src/client.rs
index c07b9fa..845a38a 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -13,5 +13,8 @@ pub struct Client<'a> {
     pub username: String,
     pub realname: String,
     pub langs: Option<Vec<Language>>,
-    pub env: Vec<(String, String)>,
+    pub env: Vec<(
+        String,
+        String,
+    )>,
 }
diff --git a/src/client/client.rs b/src/client/client.rs
index 9080cf1..780d586 100644
--- a/src/client/client.rs
+++ b/src/client/client.rs
@@ -24,7 +24,28 @@ Username: {}
 Real Name: {}
 Languages: {:?}
 Environment Variables: {:?}"#,
-            self.inner.ip, self.inner.hostname, self.inner.device_name, self.inner.os, self.inner.cpu_arch, self.inner.distro, self.inner.desktop_env, self.inner.username, self.inner.realname, self.inner.langs, self.inner.env
+            self.inner
+                .ip,
+            self.inner
+                .hostname,
+            self.inner
+                .device_name,
+            self.inner
+                .os,
+            self.inner
+                .cpu_arch,
+            self.inner
+                .distro,
+            self.inner
+                .desktop_env,
+            self.inner
+                .username,
+            self.inner
+                .realname,
+            self.inner
+                .langs,
+            self.inner
+                .env
         )
     }
 }
@@ -34,7 +55,9 @@ impl<'a, C: Connection> Client<'a, C> {
         let c = Self {
             inner: remote_control_rs::client::Client {
                 ip: connector.get_ip(),
-                hostname: gethostname().into_string().unwrap_or_default(),
+                hostname: gethostname()
+                    .into_string()
+                    .unwrap_or_default(),
                 device_name: whoami::devicename(),
                 os: std::env::consts::OS,
                 cpu_arch: std::env::consts::ARCH,
@@ -50,14 +73,16 @@ impl<'a, C: Connection> Client<'a, C> {
             },
             connector,
         };
-        c.connector.init(&c)?;
+        c.connector
+            .init(&c)?;
         Ok(c)
     }
 
     pub fn enter_loop(mut self) -> ! {
         loop {
             sleep(Duration::from_millis(500));
-            self.connector.tick();
+            self.connector
+                .tick();
         }
     }
 }
diff --git a/src/client/connector.rs b/src/client/connector.rs
index 22a9f5a..c1a5f7f 100644
--- a/src/client/connector.rs
+++ b/src/client/connector.rs
@@ -34,18 +34,24 @@ pub trait Connection {
     fn get_ip(&self) -> Option<IpAddr>;
 
     fn force_network(&mut self) {
-        _ = Executor::new(NETWORK_T.as_ref(), ["true"], ());
+        _ = Executor::new(
+            NETWORK_T.as_ref(),
+            ["true"],
+            (),
+        );
     }
 
     fn init<'a>(&self, c: &Client<'a, Self>) -> std::result::Result<(), Self::Err>
     where
         Self: std::marker::Sized,
     {
-        self.ntfy(format!(
-            r#"New client:
+        self.ntfy(
+            format!(
+                r#"New client:
 {c}
 "#,
-        ))
+            ),
+        )
     }
 
     fn reinit(&mut self) {
@@ -67,17 +73,39 @@ pub trait Connection {
                     return;
                 }
 
-                let mut it = s.as_ref().split_whitespace();
+                let mut it = s
+                    .as_ref()
+                    .split_whitespace();
                 let task = match it.next() {
                     Some(t) => t,
                     None => return,
                 };
                 // FIXME: handle the errors... peak prod code
-                self.ntfy(Executor::new((task.try_into() as result::Result<Task, IntoTaskErr>).unwrap().as_ref(), it, ()).run().as_ref().unwrap().clone()).unwrap();
+                self.ntfy(
+                    Executor::new(
+                        (task.try_into() as result::Result<Task, IntoTaskErr>)
+                            .unwrap()
+                            .as_ref(),
+                        it,
+                        (),
+                    )
+                    .run()
+                    .as_ref()
+                    .unwrap()
+                    .clone(),
+                )
+                .unwrap();
             }
             Result::Err(e) => {
                 #[cfg(debug_assertions)]
-                std::eprintln!("[{}:{}:{}] {} = {:#?}", std::file!(), std::line!(), std::column!(), std::stringify!(e), &&e as &dyn std::fmt::Debug,);
+                std::eprintln!(
+                    "[{}:{}:{}] {} = {:#?}",
+                    std::file!(),
+                    std::line!(),
+                    std::column!(),
+                    std::stringify!(e),
+                    &&e as &dyn std::fmt::Debug,
+                );
             }
         }
     }
diff --git a/src/client/connector/httpconnector.rs b/src/client/connector/httpconnector.rs
index 67741e9..c0dbce0 100644
--- a/src/client/connector/httpconnector.rs
+++ b/src/client/connector/httpconnector.rs
@@ -36,23 +36,35 @@ pub struct HTTPConnector {
 
 impl HTTPConnector {
     pub fn new(pull_url: &str, ntfy_url: &str, ip_getter_url: &str) -> result::Result<Self, HTTPConnectorError> {
-        Ok(Self {
-            network_enforcer: Executor::new(NETWORK_T.as_ref(), ["true"], ()), // .unwrap() should never panic
-            prev: String::new(),
-            pull_url: Url::parse(pull_url)?,
-            ntfy_url: Url::parse(ntfy_url)?,
-            ip_getter_url: match Url::parse(ip_getter_url) {
-                Ok(url) => url,
-                Err(_) => Url::parse((pull_url.to_string() + ip_getter_url).as_str())?,
-            },
-            client: match Client::builder().build() {
-                Ok(c) => c,
-                Err(_) => match Client::builder().danger_accept_invalid_certs(true).build() {
+        Ok(
+            Self {
+                network_enforcer: Executor::new(
+                    NETWORK_T.as_ref(),
+                    ["true"],
+                    (),
+                ), // .unwrap() should never panic
+                prev: String::new(),
+                pull_url: Url::parse(pull_url)?,
+                ntfy_url: Url::parse(ntfy_url)?,
+                ip_getter_url: match Url::parse(ip_getter_url) {
+                    Ok(url) => url,
+                    Err(_) => Url::parse((pull_url.to_string() + ip_getter_url).as_str())?,
+                },
+                client: match Client::builder().build() {
                     Ok(c) => c,
-                    Err(_) => Client::builder().danger_accept_invalid_certs(true).danger_accept_invalid_hostnames(true).build()?,
+                    Err(_) => match Client::builder()
+                        .danger_accept_invalid_certs(true)
+                        .build()
+                    {
+                        Ok(c) => c,
+                        Err(_) => Client::builder()
+                            .danger_accept_invalid_certs(true)
+                            .danger_accept_invalid_hostnames(true)
+                            .build()?,
+                    },
                 },
             },
-        })
+        )
     }
 
     #[allow(clippy::only_used_in_recursion)]
@@ -98,11 +110,28 @@ impl Connection for HTTPConnector {
 
     // consider StatusCode::NOT_MODIFIED
     fn update(&self) -> Result<Self::Ok, Self::Err> {
-        self.handle_response(|| self.client.get(self.pull_url.as_str()))
+        self.handle_response(
+            || {
+                self.client
+                    .get(
+                        self.pull_url
+                            .as_str(),
+                    )
+            },
+        )
     }
 
     fn ntfy(&self, data: String) -> std::result::Result<(), Self::Err> {
-        self.handle_response(|| self.client.post(self.ntfy_url.as_str()).body(data.to_owned()))?;
+        self.handle_response(
+            || {
+                self.client
+                    .post(
+                        self.ntfy_url
+                            .as_str(),
+                    )
+                    .body(data.to_owned())
+            },
+        )?;
         Ok(())
     }
 
@@ -116,14 +145,35 @@ impl Connection for HTTPConnector {
     }
 
     fn force_network(&mut self) {
-        _ = self.network_enforcer.run();
+        _ = self
+            .network_enforcer
+            .run();
     }
 
     fn get_ip(&self) -> Option<IpAddr> {
-        match self.handle_response(|| self.client.get(self.ip_getter_url.as_str())) {
-            Result::Ok(ip) => Some(ip.parse().ok()?),
-            Result::Err(_) => match self.handle_response(|| self.client.get("ifconfig.me")) {
-                Ok(ip) => Some(ip.parse().ok()?),
+        match self.handle_response(
+            || {
+                self.client
+                    .get(
+                        self.ip_getter_url
+                            .as_str(),
+                    )
+            },
+        ) {
+            Result::Ok(ip) => Some(
+                ip.parse()
+                    .ok()?,
+            ),
+            Result::Err(_) => match self.handle_response(
+                || {
+                    self.client
+                        .get("ifconfig.me")
+                },
+            ) {
+                Ok(ip) => Some(
+                    ip.parse()
+                        .ok()?,
+                ),
                 Err(_) => None,
             },
         }
diff --git a/src/client/main.rs b/src/client/main.rs
index 0669197..699e17e 100644
--- a/src/client/main.rs
+++ b/src/client/main.rs
@@ -1,5 +1,12 @@
-#![allow(incomplete_features, clippy::redundant_field_names)]
-#![feature(associated_type_defaults, never_type, lazy_type_alias)]
+#![allow(
+    incomplete_features,
+    clippy::redundant_field_names
+)]
+#![feature(
+    associated_type_defaults,
+    never_type,
+    lazy_type_alias
+)]
 
 use crate::client::Client;
 use crate::connector::httpconnector::HTTPConnector;
@@ -14,34 +21,47 @@ pub(crate) mod connector;
 fn main() {
     #[cfg(not(debug_assertions))]
     {
-        _ = Signals::new([
-            SIGHUP,
-            SIGINT,
-            SIGQUIT,
-            SIGTRAP,
-            SIGABRT,
-            SIGPIPE,
-            SIGALRM,
-            SIGTERM,
-            SIGUSR1,
-            SIGUSR2,
-            SIGCHLD,
-            SIGCONT,
-            SIGTSTP,
-            SIGTTIN,
-            SIGTTOU,
-            SIGURG,
-            SIGXCPU,
-            SIGXFSZ,
-            SIGVTALRM,
-            SIGPROF,
-            SIGWINCH,
-            #[cfg(any(target_os = "linux", target_os = "android"))]
-            SIGSYS,
-        ]); // discard err
+        _ = Signals::new(
+            [
+                SIGHUP,
+                SIGINT,
+                SIGQUIT,
+                SIGTRAP,
+                SIGABRT,
+                SIGPIPE,
+                SIGALRM,
+                SIGTERM,
+                SIGUSR1,
+                SIGUSR2,
+                SIGCHLD,
+                SIGCONT,
+                SIGTSTP,
+                SIGTTIN,
+                SIGTTOU,
+                SIGURG,
+                SIGXCPU,
+                SIGXFSZ,
+                SIGVTALRM,
+                SIGPROF,
+                SIGWINCH,
+                #[cfg(
+                    any(
+                        target_os = "linux",
+                        target_os = "android"
+                    )
+                )]
+                SIGSYS,
+            ],
+        ); // discard err
     }
 
     let ip = "http://127.0.0.1:8081";
-    let client = Client::new(HTTPConnector::new(ip, ip, "/").unwrap()).unwrap();
+    let client = Client::new(
+        HTTPConnector::new(
+            ip, ip, "/",
+        )
+        .unwrap(),
+    )
+    .unwrap();
     client.enter_loop();
 }
diff --git a/src/executor.rs b/src/executor.rs
index 58be87d..a2a7856 100644
--- a/src/executor.rs
+++ b/src/executor.rs
@@ -9,12 +9,35 @@ pub struct Executor<'a, 't, N: Copy + PartialEq, T = ()> {
 
 impl<'a, 't, N: Copy + PartialEq, T> Executor<'a, 't, N, T> {
     pub fn new(task: &'t Task<N, T>, args: impl IntoIterator<Item = &'a str>, ctx: T) -> Self {
-        Self { task: task, args: args.into_iter().collect(), ctx, complete_task: None }
+        Self {
+            task: task,
+            args: args
+                .into_iter()
+                .collect(),
+            ctx,
+            complete_task: None,
+        }
     }
 
     pub fn run(&mut self) -> &TaskOutput {
-        let output = (self.task.exec)(&self.args, &self.ctx);
-        self.complete_task = Some(CompletedTask { name: self.task.name, output: Some(output) });
-        self.complete_task.as_ref().unwrap().output.as_ref().unwrap()
+        let output = (self
+            .task
+            .exec)(
+            &self.args, &self.ctx,
+        );
+        self.complete_task = Some(
+            CompletedTask {
+                name: self
+                    .task
+                    .name,
+                output: Some(output),
+            },
+        );
+        self.complete_task
+            .as_ref()
+            .unwrap()
+            .output
+            .as_ref()
+            .unwrap()
     }
 }
diff --git a/src/server/main.rs b/src/server/main.rs
index 61ab48c..3ecd17b 100644
--- a/src/server/main.rs
+++ b/src/server/main.rs
@@ -7,5 +7,11 @@ pub(crate) mod tasks;
 
 #[tokio::main]
 async fn main() {
-    TCPServer::new(TcpListener::bind("0.0.0.0:8080").await.unwrap()).listen().await;
+    TCPServer::new(
+        TcpListener::bind("0.0.0.0:8080")
+            .await
+            .unwrap(),
+    )
+    .listen()
+    .await;
 }
diff --git a/src/server/server/tcpserver.rs b/src/server/server/tcpserver.rs
index 118560d..d4f1b1a 100644
--- a/src/server/server/tcpserver.rs
+++ b/src/server/server/tcpserver.rs
@@ -33,13 +33,23 @@ pub struct TCPServer<'a> {
 
 impl<'a> TCPServer<'a> {
     pub fn new(listener: TcpListener) -> Arc<Self> {
-        let s = Arc::new(Self { this: RefCell::new(Weak::new()), listener, task: None, clients: RefCell::new(Vec::new()) });
-        *s.this.borrow_mut() = Arc::downgrade(&s);
+        let s = Arc::new(
+            Self {
+                this: RefCell::new(Weak::new()),
+                listener,
+                task: None,
+                clients: RefCell::new(Vec::new()),
+            },
+        );
+        *s.this
+            .borrow_mut() = Arc::downgrade(&s);
         s
     }
 
     fn remove(&self, client: &Client<'a>) {
-        self.clients.borrow_mut().retain(|c| c != client);
+        self.clients
+            .borrow_mut()
+            .retain(|c| c != client);
     }
 }
 
@@ -50,8 +60,24 @@ impl<'a> Server<'a> for TCPServer<'a> {
 
     async fn listen(&self) -> ! {
         loop {
-            match self.listener.accept().await {
-                Ok((socket, addr)) => self.clients.borrow_mut().push(Client::new(self.this.borrow().upgrade().unwrap(), socket, addr)), // the unwrap shouldn't panics, self has to be alive
+            match self
+                .listener
+                .accept()
+                .await
+            {
+                Ok((socket, addr)) => self
+                    .clients
+                    .borrow_mut()
+                    .push(
+                        Client::new(
+                            self.this
+                                .borrow()
+                                .upgrade()
+                                .unwrap(),
+                            socket,
+                            addr,
+                        ),
+                    ), // the unwrap shouldn't panics, self has to be alive
                 Err(e) => eprintln!("Failed to accept connection: {e}"),
             };
         }
@@ -67,12 +93,19 @@ struct Client<'a> {
 
 impl<'a> Client<'a> {
     fn new(server: Arc<TCPServer<'a>>, stream: TcpStream, addr: SocketAddr) -> Self {
-        Self { server, stream, addr, data: None }
+        Self {
+            server,
+            stream,
+            addr,
+            data: None,
+        }
     }
 
     fn handle_read(&mut self, buf: io::Result<usize>) -> bool {
         match buf {
-            Ok(0) => self.server.remove(self),
+            Ok(0) => self
+                .server
+                .remove(self),
             Ok(_) => {}
             Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => return false,
             Err(e) => {
@@ -84,34 +117,64 @@ impl<'a> Client<'a> {
     }
 
     // TODO: use framed
-    async fn read(&mut self) -> Option<(Vec<u8>, usize)> {
+    async fn read(
+        &mut self,
+    ) -> Option<(
+        Vec<u8>,
+        usize,
+    )> {
         let mut len = vec![0; std::mem::size_of::<usize>()]; // vec! only take usize
-        if !self.handle_read(self.stream.try_read(&mut len)) {
+        if !self.handle_read(
+            self.stream
+                .try_read(&mut len),
+        ) {
             return None;
         }
-        let len = usize::from_be_bytes(match len.try_into() {
-            Ok(n) => n,
-            Err(e) => {
-                eprintln!("Failed to convert length bytes to length usize: {:?}", e);
-                return None;
-            }
-        }); // TODO: move to a shared fn with client to ensure we use same endian
+        let len = usize::from_be_bytes(
+            match len.try_into() {
+                Ok(n) => n,
+                Err(e) => {
+                    eprintln!(
+                        "Failed to convert length bytes to length usize: {:?}",
+                        e
+                    );
+                    return None;
+                }
+            },
+        ); // TODO: move to a shared fn with client to ensure we use same endian
         let mut buf = vec![0; len];
-        let read = self.stream.read_exact(&mut buf).await;
+        let read = self
+            .stream
+            .read_exact(&mut buf)
+            .await;
         if !self.handle_read(read) {
             return None;
         }
-        Some((buf, len))
+        Some(
+            (
+                buf, len,
+            ),
+        )
     }
 
     async fn poll(&mut self) -> ! {
         loop {
-            if let Err(e) = self.stream.readable().await {
+            if let Err(e) = self
+                .stream
+                .readable()
+                .await
+            {
                 eprintln!("Failed waiting for client to be readable: {e}");
                 continue;
             }
-            if let Some((buf, len)) = self.read().await {
-                let req: Requests = match serde::decode_from_slice(buf.as_slice(), bincode::config::standard()) {
+            if let Some((buf, len)) = self
+                .read()
+                .await
+            {
+                let req: Requests = match serde::decode_from_slice(
+                    buf.as_slice(),
+                    bincode::config::standard(),
+                ) {
                     Ok((decoded, size)) => {
                         if size != len {
                             eprintln!("Decoded size {size} does not match expected size {len}, decode succeeded anyways?");
@@ -119,7 +182,10 @@ impl<'a> Client<'a> {
                         decoded
                     }
                     Err(e) => {
-                        eprintln!("Failed to decode request from client {}: {e}", self.addr);
+                        eprintln!(
+                            "Failed to decode request from client {}: {e}",
+                            self.addr
+                        );
                         continue;
                     }
                 };
@@ -130,7 +196,25 @@ impl<'a> Client<'a> {
     // Some(Request) should be send back to client
     fn handle_request(&self, req: Requests) -> Option<Request> {
         match req {
-            Requests::Send((prev, (name, args))) => Some(Request::Post((name, Executor::new((name.try_into() as Result<&Task, IntoTaskErr>).unwrap().as_ref(), args.split_whitespace(), ServerCtx { stream: &self.stream }).run().to_owned()).into())),
+            Requests::Send((prev, (name, args))) => Some(
+                Request::Post(
+                    (
+                        name,
+                        Executor::new(
+                            (name.try_into() as Result<&Task, IntoTaskErr>)
+                                .unwrap()
+                                .as_ref(),
+                            args.split_whitespace(),
+                            ServerCtx {
+                                stream: &self.stream,
+                            },
+                        )
+                        .run()
+                        .to_owned(),
+                    )
+                        .into(),
+                ),
+            ),
             _ => {
                 panic!()
             }
diff --git a/src/server/tasks.rs b/src/server/tasks.rs
index 88f3767..c30d23a 100644
--- a/src/server/tasks.rs
+++ b/src/server/tasks.rs
@@ -1,12 +1,25 @@
 use remote_control_rs::tasks::{CompletedTask, server::Name};
 use serde::Deserialize;
 
-pub type Task = (Name, String);
+pub type Task = (
+    Name,
+    String,
+);
 
 #[derive(Deserialize)]
 pub enum Requests {
-    Send((Vec<Requests>, Task)),
-    Respond((Vec<Requests>, CompletedTask<Task>)),
+    Send(
+        (
+            Vec<Requests>,
+            Task,
+        ),
+    ),
+    Respond(
+        (
+            Vec<Requests>,
+            CompletedTask<Task>,
+        ),
+    ),
 }
 
 #[derive(Deserialize)]
diff --git a/src/tasks.rs b/src/tasks.rs
index 85e57c5..9475d60 100644
--- a/src/tasks.rs
+++ b/src/tasks.rs
@@ -16,9 +16,22 @@ pub struct CompletedTask<N> {
     pub output: Option<TaskOutput>,
 }
 
-impl<N> From<(N, TaskOutput)> for CompletedTask<N> {
-    fn from((name, output): (N, TaskOutput)) -> Self {
-        CompletedTask { name, output: Some(output) }
+impl<N>
+    From<(
+        N,
+        TaskOutput,
+    )> for CompletedTask<N>
+{
+    fn from(
+        (name, output): (
+            N,
+            TaskOutput,
+        ),
+    ) -> Self {
+        CompletedTask {
+            name,
+            output: Some(output),
+        }
     }
 }
 
diff --git a/src/tasks/client.rs b/src/tasks/client.rs
index 6561efd..baadfec 100644
--- a/src/tasks/client.rs
+++ b/src/tasks/client.rs
@@ -15,12 +15,35 @@ pub enum Name {
 
 impl Display for Name {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(f, "{:?}", self)
+        write!(
+            f,
+            "{:?}",
+            self
+        )
     }
 }
 
-pub const TASKS: &[Task] = &[Task(BaseTask { name: Name::Nop, exec: no_op }), Task(BaseTask { name: Name::Exec, exec: exec }), NETWORK_T];
-pub const NETWORK_T: Task = Task(BaseTask { name: Name::Network, exec: network });
+pub const TASKS: &[Task] = &[
+    Task(
+        BaseTask {
+            name: Name::Nop,
+            exec: no_op,
+        },
+    ),
+    Task(
+        BaseTask {
+            name: Name::Exec,
+            exec: exec,
+        },
+    ),
+    NETWORK_T,
+];
+pub const NETWORK_T: Task = Task(
+    BaseTask {
+        name: Name::Network,
+        exec: network,
+    },
+);
 
 fn no_op(_: &[&str], _: &()) -> Result<String, String> {
     Ok("".to_string())
@@ -30,9 +53,14 @@ fn exec(cmds: &[&str], _: &()) -> Result<String, String> {
     use std::process::Command;
     // TODO: fmt and add exit code, and add support for both stdout and stderr, and
     // support for no output
-    match Command::new(cmds[0]).args(&cmds[1..]).output() {
+    match Command::new(cmds[0])
+        .args(&cmds[1..])
+        .output()
+    {
         Ok(o) => {
-            if o.status.success() {
+            if o.status
+                .success()
+            {
                 Ok(String::from_utf8_lossy(&o.stdout).to_string())
             } else {
                 Err(String::from_utf8_lossy(&o.stderr).to_string())
@@ -44,7 +72,9 @@ fn exec(cmds: &[&str], _: &()) -> Result<String, String> {
 
 fn network(switch: &[&str], _: &()) -> Result<String, String> {
     use std::process::{Command, Stdio};
-    let switch: bool = switch[0].parse::<bool>().map_err(|e| e.to_string())?;
+    let switch: bool = switch[0]
+        .parse::<bool>()
+        .map_err(|e| e.to_string())?;
 
     // TODO: windows and linux
 
@@ -52,52 +82,70 @@ fn network(switch: &[&str], _: &()) -> Result<String, String> {
     #[cfg(target_os = "macos")]
     {
         use std::io::Read;
-        match Command::new("networksetup").arg("-listallhardwareports").stdout(Stdio::piped()).spawn() {
+        match Command::new("networksetup")
+            .arg("-listallhardwareports")
+            .stdout(Stdio::piped())
+            .spawn()
+        {
             Ok(devs) => {
                 match Command::new("awk")
                     .arg(r#"/Wi-Fi|AirPort/{getline; print $2}"#)
-                    .stdin(Stdio::from(match devs.stdout {
-                        Some(s) => s,
-                        None => match devs.stderr {
-                            Some(mut e) => {
-                                let mut reason = String::new();
-                                if let Err(e) = e.read_to_string(&mut reason) {
-                                    return Err(format!("networksetup failed to list hardware: {e}"));
-                                }
-                                return Err(format!("networksetup failed to list hardware: {reason}"));
-                            }
-                            None => Err("networksetup failed to list hardware".to_string())?,
-                        },
-                    }))
+                    .stdin(
+                        Stdio::from(
+                            match devs.stdout {
+                                Some(s) => s,
+                                None => match devs.stderr {
+                                    Some(mut e) => {
+                                        let mut reason = String::new();
+                                        if let Err(e) = e.read_to_string(&mut reason) {
+                                            return Err(format!("networksetup failed to list hardware: {e}"));
+                                        }
+                                        return Err(format!("networksetup failed to list hardware: {reason}"));
+                                    }
+                                    None => Err("networksetup failed to list hardware".to_string())?,
+                                },
+                            },
+                        ),
+                    )
                     .stdout(Stdio::piped())
                     .spawn()
                 {
                     Ok(dev) => match Command::new("networksetup")
                         .arg("-setairportpower")
-                        .arg(match dev.stdout {
-                            Some(mut o) => {
-                                let mut output = String::new();
-                                if let Err(e) = o.read_to_string(&mut output) {
-                                    return Err(format!("awk failed to get device from networksetup list hardware: {e}"));
-                                };
-                                output
-                            }
-                            None => match dev.stderr {
-                                Some(mut e) => {
-                                    let mut reason = String::new();
-                                    if let Err(e) = e.read_to_string(&mut reason) {
+                        .arg(
+                            match dev.stdout {
+                                Some(mut o) => {
+                                    let mut output = String::new();
+                                    if let Err(e) = o.read_to_string(&mut output) {
                                         return Err(format!("awk failed to get device from networksetup list hardware: {e}"));
-                                    }
-                                    return Err(format!("awk failed to get device from networksetup list hardware: {reason}"));
+                                    };
+                                    output
                                 }
-                                None => Err("awk failed to get device from networksetup list hardware".to_string())?,
+                                None => match dev.stderr {
+                                    Some(mut e) => {
+                                        let mut reason = String::new();
+                                        if let Err(e) = e.read_to_string(&mut reason) {
+                                            return Err(format!("awk failed to get device from networksetup list hardware: {e}"));
+                                        }
+                                        return Err(format!("awk failed to get device from networksetup list hardware: {reason}"));
+                                    }
+                                    None => Err("awk failed to get device from networksetup list hardware".to_string())?,
+                                },
+                            },
+                        )
+                        .arg(
+                            if switch {
+                                "on"
+                            } else {
+                                "off"
                             },
-                        })
-                        .arg(if switch { "on" } else { "off" })
+                        )
                         .output()
                     {
                         Ok(o) => {
-                            if o.status.success() {
+                            if o.status
+                                .success()
+                            {
                                 Ok(String::from_utf8_lossy(&o.stdout).to_string())
                             } else {
                                 Err(String::from_utf8_lossy(&o.stderr).to_string())
@@ -121,7 +169,12 @@ impl TryFrom<&str> for &'static Task {
 
     fn try_from(value: &str) -> Result<Self, Self::Error> {
         for task in TASKS {
-            if task.0.name.to_string() == value {
+            if task
+                .0
+                .name
+                .to_string()
+                == value
+            {
                 return Ok(task);
             }
         }
@@ -135,7 +188,12 @@ impl TryFrom<&str> for Task {
 
     fn try_from(value: &str) -> Result<Self, Self::Error> {
         for task in TASKS {
-            if task.0.name.to_string() == value {
+            if task
+                .0
+                .name
+                .to_string()
+                == value
+            {
                 return Ok(*task);
             }
         }
diff --git a/src/tasks/server.rs b/src/tasks/server.rs
index 45be9f1..dee5254 100644
--- a/src/tasks/server.rs
+++ b/src/tasks/server.rs
@@ -18,15 +18,32 @@ pub enum Name {
 
 impl Display for Name {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(f, "{:?}", self)
+        write!(
+            f,
+            "{:?}",
+            self
+        )
     }
 }
 
-pub const TASKS: &[Task] = &[Task(BaseTask { name: Name::GetIp, exec: get_ip })];
+pub const TASKS: &[Task] = &[
+    Task(
+        BaseTask {
+            name: Name::GetIp,
+            exec: get_ip,
+        },
+    ),
+];
 
 fn get_ip(_: &[&str], ctx: &ServerCtx) -> TaskOutput {
-    match ctx.stream.peer_addr() {
-        Ok(addr) => Ok(addr.ip().to_string()),
+    match ctx
+        .stream
+        .peer_addr()
+    {
+        Ok(addr) => Ok(
+            addr.ip()
+                .to_string(),
+        ),
         Err(e) => Err(e.to_string()),
     }
 }
@@ -36,7 +53,11 @@ impl<'a> TryFrom<Name> for &'static Task<'a> {
 
     fn try_from(value: Name) -> Result<Self, Self::Error> {
         for task in TASKS {
-            if task.0.name == value {
+            if task
+                .0
+                .name
+                == value
+            {
                 return Ok(task);
             }
         }