gateway-probe fixes for run-local

nym-gateway-probe/src/lib.rs

@@ -130,12 +130,20 @@ pub enum TestedNode {
     SameAsEntry,
     Custom {
         identity: NodeIdentity,
+        shares_entry: bool,
     },
 }
 
 impl TestedNode {
     pub fn is_same_as_entry(&self) -> bool {
-        matches!(self, TestedNode::SameAsEntry)
+        matches!(
+            self,
+            TestedNode::SameAsEntry
+                | TestedNode::Custom {
+                    shares_entry: true,
+                    ..
+                }
+        )
     }
 }
 
@@ -309,7 +317,20 @@ impl Probe {
         let entry_gateway = directory.entry_gateway(&self.entrypoint)?;
 
         let node_info: TestedNodeDetails = match self.tested_node {
-            TestedNode::Custom { identity } => {
+            TestedNode::Custom {
+                identity: _,
+                shares_entry: true,
+            } => {
+                debug!(
+                    "testing node {} as both entry and exit",
+                    entry_gateway.identity()
+                );
+                entry_gateway.to_testable_node()?
+            }
+            TestedNode::Custom {
+                identity,
+                shares_entry: false,
+            } => {
                 let node = directory.get_nym_node(identity)?;
                 info!(
                     "testing node {} (via entry {})",
@@ -421,12 +442,17 @@ impl Probe {
                 storage.credential_store().clone(),
                 client,
             );
-            let credential = bw_controller
-                .prepare_ecash_ticket(
+            let (wg_ticket_type, credential_provider) = if tested_entry {
+                (
                     TicketType::V1WireguardEntry,
                     nym_address.gateway().to_bytes(),
-                    1,
                 )
+            } else {
+                (TicketType::V1WireguardExit, node_info.identity.to_bytes())
+            };
+
+            let credential = bw_controller
+                .prepare_ecash_ticket(wg_ticket_type, credential_provider, 1)
                 .await?
                 .data;
 
@@ -711,11 +737,7 @@ async fn do_ping_entry(
     }
     info!("Successfully mixnet pinged ourselves");
 
-    if tested_entry {
-        Entry::success()
-    } else {
-        Entry::NotTested
-    }
+    Entry::success()
 }
 
 async fn connect_exit(

nym-gateway-probe/src/nodes.rs

@@ -199,6 +199,16 @@ impl NymApiDirectory {
             .map(|(id, _)| *id)
     }
 
+    pub fn random_entry_gateway(&self) -> anyhow::Result<NodeIdentity> {
+        info!("Selecting random entry gateway");
+        self.nodes
+            .iter()
+            .filter(|(_, n)| n.described.description.declared_role.entry)
+            .choose(&mut rand::thread_rng())
+            .ok_or(anyhow!("no entry gateways available"))
+            .map(|(id, _)| *id)
+    }
+
     pub fn get_nym_node(&self, identity: NodeIdentity) -> anyhow::Result<DirectoryNode> {
         self.nodes
             .get(&identity)

nym-gateway-probe/src/run.rs

@@ -124,16 +124,31 @@ pub(crate) async fn run() -> anyhow::Result<ProbeResult> {
 
     let directory = NymApiDirectory::new(api_url).await?;
 
-    let entry = if let Some(gateway) = &args.entry_gateway {
-        NodeIdentity::from_base58_string(gateway)?
+    let node_override = args.node;
+    let entry_override = if let Some(gateway) = &args.entry_gateway {
+        Some(NodeIdentity::from_base58_string(gateway)?)
     } else {
-        directory.random_exit_with_ipr()?
+        None
     };
 
-    let test_point = if let Some(node) = args.node {
-        TestedNode::Custom { identity: node }
+    let entry = if let Some(entry) = entry_override {
+        entry
+    } else if let Some(node) = node_override {
+        node
     } else {
-        TestedNode::SameAsEntry
+        directory.random_entry_gateway()?
+    };
+
+    let test_point = match (node_override, entry_override) {
+        (Some(node), Some(_)) => TestedNode::Custom {
+            identity: node,
+            shares_entry: false,
+        },
+        (Some(node), None) => TestedNode::Custom {
+            identity: node,
+            shares_entry: true,
+        },
+        (None, _) => TestedNode::SameAsEntry,
     };
 
     let mut trial =