refactor: remove annoying state param

Author: koitococo

src/main.rs

@@ -1,6 +1,6 @@
 use clap::Parser;
 use serde::{Deserialize, Serialize};
-use std::{collections::HashMap, fmt::Display};
+use std::{cell::RefCell, collections::HashMap, fmt::Display, rc::Rc};
 use tokio::fs;
 mod ztapi;
 use crate::ztapi::Client;
@@ -16,14 +16,13 @@ async fn main() -> anyhow::Result<()> {
   }
 
   env_logger::init();
-  Args::parse().apply((), &mut ()).await
+  Args::parse().apply(()).await
 }
 
 trait Apply {
   type Context;
-  type PersistentState;
 
-  async fn apply(self, ctx: Self::Context, ps: &mut Self::PersistentState) -> anyhow::Result<()>;
+  async fn apply(self, ctx: Self::Context) -> anyhow::Result<()>;
 }
 
 #[derive(Debug, Parser)]
@@ -51,28 +50,14 @@ struct Args {
   /// Base URL for the ZeroTier API endpoint
   endpoint: String,
 
-  #[clap(long = "state_path", short = 's', env = "STATE_PATH", default_value = "state.json")]
-  /// Path to state file which contains datas used only by ztcli
-  state_path: String,
-
-  #[clap(long = "disable_state", short = 'S', env = "DISABLE_STATE", default_value = "false")]
-  /// If true, ztcli will not read state from filesystem, and will not sync changes to it
-  disable_state: bool,
-
   #[clap(subcommand)]
   cmd: Command,
 }
 
-#[derive(Serialize, Deserialize, Default)]
-struct States {
-  ctrl_net_states: CtrlNetStates,
-}
-
 impl Apply for Args {
   type Context = ();
-  type PersistentState = ();
 
-  async fn apply(self, _: Self::Context, _: &mut Self::PersistentState) -> anyhow::Result<()> {
+  async fn apply(self, _: Self::Context) -> anyhow::Result<()> {
     let Some(token) = self.token.clone().or_else(|| match std::fs::read_to_string(&self.token_path) {
       Ok(content) => Some(content),
       Err(e) => {
@@ -83,20 +68,11 @@ impl Apply for Args {
       anyhow::bail!("No authentication token provided");
     };
 
-    let mut ps: States = if self.disable_state || !std::fs::exists(&self.state_path)? {
-      Default::default()
-    } else {
-      let content = fs::read_to_string(&self.state_path).await?;
-      serde_json::from_str(&content)?
-    };
+    //TODO:
 
     let client = ztapi::Client::new(self.endpoint.as_str(), &token)?;
-    self.cmd.apply(client, &mut ps.ctrl_net_states).await?;
+    self.cmd.apply(client).await?;
 
-    if !self.disable_state {
-      let content = serde_json::to_string(&ps)?;
-      fs::write(&self.state_path, content).await?;
-    }
     Ok(())
   }
 }
@@ -136,12 +112,11 @@ enum Command {
 
 impl Apply for Command {
   type Context = Client;
-  type PersistentState = CtrlNetStates;
 
-  async fn apply(self, client: Self::Context, ps: &mut Self::PersistentState) -> anyhow::Result<()> {
+  async fn apply(self, client: Self::Context) -> anyhow::Result<()> {
     match self {
       #[cfg(feature = "clap_complete")]
-      Self::Completions(args) => args.apply((), &mut ()).await?,
+      Self::Completions(args) => args.apply(()).await?,
       #[cfg(feature = "clap_usage")]
       Self::Usage => {
         use clap::CommandFactory as _;
@@ -168,15 +143,15 @@ impl Apply for Command {
           pretty_print(&i);
         }
       }
-      Self::Network(args) => args.apply(client, &mut ()).await?,
+      Self::Network(args) => args.apply(client).await?,
       Self::ListPeers => {
         let r = client.get_peers().await?;
         log::info!("Peers information: {:?}", r);
         for i in r {
           pretty_print(&i);
         }
       }
-      Self::PeerInfo(args) => args.apply(client, &mut ()).await?,
+      Self::PeerInfo(args) => args.apply(client).await?,
 
       Self::ControllerStatus => {
         let r = client.get_controller_status().await?;
@@ -190,7 +165,7 @@ impl Apply for Command {
           pretty_print(&i);
         }
       }
-      Self::Controller(args) => args.apply(client, ps).await?,
+      Self::Controller(args) => args.apply(client).await?,
     }
     Ok(())
   }
@@ -205,9 +180,8 @@ struct CompletionsArgs {
 #[cfg(feature = "clap_complete")]
 impl Apply for CompletionsArgs {
   type Context = ();
-  type PersistentState = ();
 
-  async fn apply(self, _: Self::Context, _: &mut Self::PersistentState) -> anyhow::Result<()> {
+  async fn apply(self, _: Self::Context) -> anyhow::Result<()> {
     use clap::CommandFactory as _;
 
     clap_complete::generate(
@@ -241,11 +215,8 @@ struct CtrlNetStates {
 
 impl Apply for CtrlNetArgs {
   type Context = Client;
-  type PersistentState = CtrlNetStates;
 
-  async fn apply(self, client: Self::Context, ps: &mut Self::PersistentState) -> anyhow::Result<()> {
-    self.cmd.apply((client, self.network_id), ps).await
-  }
+  async fn apply(self, client: Self::Context) -> anyhow::Result<()> { self.cmd.apply((client, self.network_id)).await }
 }
 
 #[derive(Debug, Parser)]
@@ -269,17 +240,21 @@ enum CtrlNetCmds {
   Members,
 }
 
+type CtrlNetMemTagStatesRef = Rc<RefCell<Option<CtrlNetMemTagStates>>>;
+
 impl Apply for CtrlNetCmds {
   type Context = (Client, String);
-  type PersistentState = CtrlNetStates;
 
-  async fn apply(self, (client, network_id): Self::Context, ps: &mut Self::PersistentState) -> anyhow::Result<()> {
-    let next_ps = if let Some(inner) = ps.networks.get_mut(&network_id) {
-      inner
-    } else {
-      ps.networks.insert(network_id.clone(), Default::default());
-      ps.networks.get_mut(&network_id).unwrap() // We can assume this unwrap is always safe
+  async fn apply(self, (client, network_id): Self::Context) -> anyhow::Result<()> {
+    const STATE_PATH: &str = "ztcli.json";
+
+    let mut controller_state: CtrlNetStates = {
+      let content = fs::read_to_string(STATE_PATH).await?;
+      serde_json::from_str(&content)?
     };
+
+    let network_state = controller_state.networks.remove(&network_id).unwrap_or_default();
+    let network_state = Rc::new(RefCell::new(Some(network_state)));
     match self {
       Self::Create(args) => {
         let r = client.generate_controller_network(&network_id, &(*args).into()).await?;
@@ -291,7 +266,7 @@ impl Apply for CtrlNetCmds {
         log::info!("Network updated successfully: {:?}", r);
         pretty_print(&r);
       }
-      Self::Member(args) => args.apply((client, network_id), next_ps).await?,
+      Self::Member(args) => args.apply((client, network_id.clone(), network_state.clone())).await?,
       Self::Info => {
         let r = client.get_controller_network(&network_id).await?;
         log::info!("Network information: {:?}", r);
@@ -301,16 +276,29 @@ impl Apply for CtrlNetCmds {
         let r = client.get_controller_network_members(&network_id).await?;
 
         log::info!("Members information: {:?}", r);
-        for (k, v) in r {
-          let msg = if let Some(tag) = next_ps.tags.get_mut(&k) {
-            format!("{k}: {v} ({tag})")
-          } else {
-            format!("{k}: {v}")
-          };
-          pretty_print(&msg);
+        let network_state = controller_state.networks.get(network_id.as_str());
+        if let Some(network_state) = network_state {
+          for (k, v) in r {
+            let msg = if let Some(tag) = network_state.tags.get(&k) {
+              format!("{k}: {v} ({tag})")
+            } else {
+              format!("{k}: {v}")
+            };
+            pretty_print(&msg);
+          }
+        } else {
+          for (k, v) in r {
+            pretty_print(&format!("{k}: {v}"));
+          }
         }
       }
     }
+    let content = {
+      let mut state = network_state.borrow_mut();
+      controller_state.networks.insert(network_id, state.take().unwrap());
+      serde_json::to_string(&controller_state)?
+    };
+    fs::write(STATE_PATH, content).await?;
     Ok(())
   }
 }
@@ -473,11 +461,10 @@ struct CtrlNetMemArgs {
 }
 
 impl Apply for CtrlNetMemArgs {
-  type Context = (Client, String);
-  type PersistentState = CtrlNetMemTagStates;
+  type Context = (Client, String, CtrlNetMemTagStatesRef);
 
-  async fn apply(self, (client, network_id): Self::Context, ps: &mut Self::PersistentState) -> anyhow::Result<()> {
-    self.cmd.apply((client, network_id, self.member_id), ps).await
+  async fn apply(self, (client, network_id, ps): Self::Context) -> anyhow::Result<()> {
+    self.cmd.apply((client, network_id, self.member_id, ps)).await
   }
 }
 
@@ -494,12 +481,9 @@ enum CtrlNetMemCmds {
 }
 
 impl Apply for CtrlNetMemCmds {
-  type Context = (Client, String, String);
-  type PersistentState = CtrlNetMemTagStates;
+  type Context = (Client, String, String, CtrlNetMemTagStatesRef);
 
-  async fn apply(
-    self, (client, network_id, member_id): Self::Context, ps: &mut Self::PersistentState,
-  ) -> anyhow::Result<()> {
+  async fn apply(self, (client, network_id, member_id, ps): Self::Context) -> anyhow::Result<()> {
     match self {
       Self::Info => {
         let r = client.get_controller_network_member(&network_id, &member_id).await?;
@@ -513,7 +497,7 @@ impl Apply for CtrlNetMemCmds {
         pretty_print(&r);
       }
       Self::Tag(args) => {
-        args.apply(member_id, ps).await?;
+        args.apply((member_id, ps)).await?;
       }
     }
     Ok(())
@@ -601,19 +585,20 @@ struct CtrlNetMemTagStates {
 }
 
 impl Apply for CtrlNetMemTagArgs {
-  type Context = String;
-  type PersistentState = CtrlNetMemTagStates;
+  type Context = (String, CtrlNetMemTagStatesRef);
 
-  async fn apply(self, id: Self::Context, ps: &mut Self::PersistentState) -> anyhow::Result<()> {
+  async fn apply(self, (id, ref_state): Self::Context) -> anyhow::Result<()> {
+    let mut borrowed_state = ref_state.borrow_mut();
+    let network_state = borrowed_state.as_mut().unwrap();
     if let Some(tag) = self.tag {
       if tag.is_empty() {
-        ps.tags.remove(&id);
+        network_state.tags.remove(&id);
         log::info!("Tag removed for {}", id);
       } else {
-        ps.tags.insert(id.clone(), tag.clone());
+        network_state.tags.insert(id.clone(), tag.clone());
         log::info!("Tag set for {}: {}", id, tag);
       }
-    } else if let Some(tag) = ps.tags.get(&id) {
+    } else if let Some(tag) = network_state.tags.get(&id) {
       pretty_print(tag);
     } else {
       log::info!("No tag found for {}", id);
@@ -631,9 +616,8 @@ struct PeerInfoArgs {
 
 impl Apply for PeerInfoArgs {
   type Context = Client;
-  type PersistentState = ();
 
-  async fn apply(self, client: Self::Context, _: &mut Self::PersistentState) -> anyhow::Result<()> {
+  async fn apply(self, client: Self::Context) -> anyhow::Result<()> {
     let r = client.get_peer(&self.peer_id).await?;
     log::info!("Peer information: {:?}", r);
     pretty_print(&r);
@@ -653,11 +637,8 @@ struct NetEditArgs {
 
 impl Apply for NetEditArgs {
   type Context = Client;
-  type PersistentState = ();
 
-  async fn apply(self, client: Self::Context, ps: &mut Self::PersistentState) -> anyhow::Result<()> {
-    self.cmd.apply((client, self.network_id), ps).await
-  }
+  async fn apply(self, client: Self::Context) -> anyhow::Result<()> { self.cmd.apply((client, self.network_id)).await }
 }
 
 #[derive(Debug, Parser)]
@@ -674,9 +655,8 @@ enum NetEditCmds {
 
 impl Apply for NetEditCmds {
   type Context = (Client, String);
-  type PersistentState = ();
 
-  async fn apply(self, (client, network_id): Self::Context, _: &mut Self::PersistentState) -> anyhow::Result<()> {
+  async fn apply(self, (client, network_id): Self::Context) -> anyhow::Result<()> {
     match self {
       Self::Info => {
         let r = client.get_network(&network_id).await?;