feat(snops): add private_key, env, and binary config action flags

crates/snops-agent/src/cli.rs

@@ -101,6 +101,14 @@ impl Cli {
         std::process::exit(0);
     }
 
+    pub fn get_local_ip(&self) -> IpAddr {
+        if self.bind_addr.is_unspecified() {
+            IpAddr::V4(Ipv4Addr::LOCALHOST)
+        } else {
+            self.bind_addr
+        }
+    }
+
     pub fn endpoint_and_uri(&self) -> (String, Uri) {
         // get the endpoint
         let endpoint = self

crates/snops-agent/src/metrics/mod.rs

@@ -1,11 +1,6 @@
 pub mod tps;
 
-use std::{
-    collections::HashMap,
-    net::{IpAddr, Ipv4Addr, SocketAddr},
-    sync::Arc,
-    time::Duration,
-};
+use std::{collections::HashMap, net::SocketAddr, sync::Arc, time::Duration};
 
 use self::tps::TpsMetric;
 use crate::state::GlobalState;
@@ -39,7 +34,7 @@ pub fn init(state: Arc<GlobalState>) {
                 let response = match client
                     .get(format!(
                         "http://{}/",
-                        SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), state.cli.ports.metrics)
+                        SocketAddr::new(state.cli.get_local_ip(), state.cli.ports.metrics)
                     ))
                     .send()
                     .await

crates/snops-agent/src/rpc/control.rs

@@ -428,7 +428,8 @@ impl AgentService for AgentRpcServer {
             .network;
 
         let url = format!(
-            "http://127.0.0.1:{}/{network}{route}",
+            "http://{}:{}/{network}{route}",
+            self.state.cli.get_local_ip(),
             self.state.cli.ports.rest
         );
         let response = reqwest::get(&url)
@@ -460,7 +461,8 @@ impl AgentService for AgentRpcServer {
             .network;
 
         let url = format!(
-            "http://127.0.0.1:{}/{network}/transaction/broadcast",
+            "http://{}:{}/{network}/transaction/broadcast",
+            self.state.cli.get_local_ip(),
             self.state.cli.ports.rest
         );
         let response = reqwest::Client::new()

crates/snops-cli/Cargo.toml

@@ -18,6 +18,7 @@ reqwest = { workspace = true, features = ["blocking", "json"] }
 serde.workspace = true
 serde_json.workspace = true
 snops-common = { workspace = true, features = ["aot_cmds"] }
+thiserror.workspace = true
 
 [build-dependencies]
 anyhow.workspace = true

crates/snops-cli/src/commands/env/action/mod.rs

@@ -1,4 +1,4 @@
-use std::str::FromStr;
+use std::{collections::HashMap, str::FromStr};
 
 use anyhow::Result;
 use clap::Parser;
@@ -9,7 +9,7 @@ use snops_common::{
     action_models::{AleoValue, WithTargets},
     key_source::KeySource,
     node_targets::{NodeTarget, NodeTargetError, NodeTargets},
-    state::{CannonId, DocHeightRequest, EnvId},
+    state::{CannonId, DocHeightRequest, EnvId, InternedId},
 };
 
 //scli env canary action online client/*
@@ -132,12 +132,42 @@ pub enum Action {
         /// Configure the validators of the target nodes, or `none`.
         #[clap(long, short)]
         validators: Option<NodesOption>,
+        /// Set environment variables for a node: `--env FOO=bar`
+        #[clap(long, short, number_of_values = 1, value_parser = clap::value_parser!(KeyEqValue))]
+        env: Option<Vec<KeyEqValue>>,
+        // Remove environment variables from a node: `--del-env FOO,BAR`
+        #[clap(long, short, value_delimiter = ',', allow_hyphen_values = true)]
+        del_env: Option<Vec<String>>,
         /// The nodes to configure.
         #[clap(num_args = 1, value_delimiter = ' ')]
         nodes: Vec<NodeTarget>,
+        /// Configure the binary for a node.
+        #[clap(long, short)]
+        binary: Option<InternedId>,
+        /// Configure the private key for a node.
+        #[clap(long, short)]
+        private_key: Option<KeySource>,
     },
 }
 
+#[derive(Clone, Debug)]
+pub struct KeyEqValue(pub String, pub String);
+
+impl FromStr for KeyEqValue {
+    type Err = &'static str;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        let (l, r) = s.split_once('=').ok_or("missing = in `key=value`")?;
+        Ok(Self(l.to_owned(), r.to_owned()))
+    }
+}
+
+impl KeyEqValue {
+    pub fn pair(self) -> (String, String) {
+        (self.0, self.1)
+    }
+}
+
 impl Action {
     pub fn execute(self, url: &str, env_id: EnvId, client: Client) -> Result<Response> {
         use Action::*;
@@ -251,6 +281,10 @@ impl Action {
                 peers,
                 validators,
                 nodes,
+                env,
+                del_env,
+                binary,
+                private_key,
             } => {
                 let ep = format!("{url}/api/v1/env/{env_id}/action/config");
 
@@ -270,6 +304,21 @@ impl Action {
                 if let Some(validators) = validators {
                     json["validators"] = json!(NodeTargets::from(validators));
                 }
+                if let Some(binary) = binary {
+                    json["binary"] = json!(binary);
+                }
+                if let Some(private_key) = private_key {
+                    json["private_key"] = json!(private_key);
+                }
+                if let Some(env) = env {
+                    json["set_env"] = json!(env
+                        .into_iter()
+                        .map(KeyEqValue::pair)
+                        .collect::<HashMap<_, _>>())
+                }
+                if let Some(del_env) = del_env {
+                    json["del_env"] = json!(del_env)
+                }
 
                 // this api accepts a list of json objects
                 client.post(ep).json(&json!(vec![json])).send()?

crates/snops-common/src/action_models.rs

@@ -1,11 +1,12 @@
 use std::str::FromStr;
 
+use indexmap::{IndexMap, IndexSet};
 use serde::{Deserialize, Serialize};
 
 use crate::{
     key_source::KeySource,
     node_targets::{NodeTarget, NodeTargets},
-    state::{CannonId, DocHeightRequest},
+    state::{CannonId, DocHeightRequest, InternedId},
 };
 
 #[derive(Deserialize, Serialize, Clone)]
@@ -120,7 +121,12 @@ pub struct Reconfig {
     pub peers: Option<NodeTargets>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub validators: Option<NodeTargets>,
-    // TODO: private key
-    // TODO: env
-    // TODO: binary
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub binary: Option<InternedId>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub private_key: Option<KeySource>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub set_env: Option<IndexMap<String, String>>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub del_env: Option<IndexSet<String>>,
 }

crates/snops-common/src/state/node_state.rs

@@ -162,6 +162,10 @@ impl KeyState {
             _ => None,
         }
     }
+
+    pub fn is_none(&self) -> bool {
+        matches!(self, KeyState::None)
+    }
 }
 
 #[derive(

crates/snops/src/server/actions/config.rs

@@ -6,7 +6,7 @@ use axum::{
 };
 use snops_common::{
     action_models::{Reconfig, WithTargets},
-    state::{AgentId, AgentState},
+    state::{AgentId, AgentState, InternedId},
 };
 
 use super::Env;
@@ -31,7 +31,7 @@ pub async fn config(
                         AgentState::Inventory => (),
                         AgentState::Node(_, ref mut n) => {
                             $({
-                                let $key = &n.$key;
+                                let $key = &mut n.$key;
                                 n.$key = $val;
                             })*
                         }
@@ -43,7 +43,7 @@ pub async fn config(
                         $agent.client_owned(),
                         $agent.state().clone().map_node(|mut n| {
                             $({
-                                let $key = &n.$key;
+                                let $key = &mut n.$key;
                                 n.$key = $val;
                             })*
                             n
@@ -78,6 +78,41 @@ pub async fn config(
                     .collect::<Vec<_>>();
                 set_node_field!(agent, validators = v.clone());
             }
+
+            if let Some(b) = &data.binary {
+                set_node_field!(agent, binary = (*b != InternedId::default()).then_some(*b));
+            }
+
+            if let Some(k) = &data.private_key {
+                let key = env.storage.sample_keysource_pk(k);
+                if key.is_none() {
+                    return ServerError::NotFound(format!("key source not found: `{k}`"))
+                        .into_response();
+                }
+                set_node_field!(agent, private_key = key.clone());
+            }
+
+            // inject env fields
+            if let Some(e) = &data.set_env {
+                set_node_field!(
+                    agent,
+                    env = {
+                        env.extend(e.clone());
+                        std::mem::take(env)
+                    }
+                )
+            }
+
+            // remove env fields
+            if let Some(e) = &data.del_env {
+                set_node_field!(
+                    agent,
+                    env = {
+                        env.retain(|k, _| !e.contains(k));
+                        std::mem::take(env)
+                    }
+                )
+            }
         }
     }