keylimectl: Use detected API version for verifier in push-mode

Also, correct the URL to add the agent to the verifier.

Signed-off-by: Anderson Toshiyuki Sasaki <[email protected]>

Author: ansasaki

keylimectl/src/client/factory.rs

@@ -18,7 +18,6 @@ use crate::error::KeylimectlError;
 use std::sync::OnceLock;
 
 static VERIFIER_CLIENT: OnceLock<VerifierClient> = OnceLock::new();
-static VERIFIER_CLIENT_OVERRIDE: OnceLock<VerifierClient> = OnceLock::new();
 static REGISTRAR_CLIENT: OnceLock<RegistrarClient> = OnceLock::new();
 
 /// Get or create the verifier client
@@ -62,52 +61,6 @@ pub async fn get_verifier() -> Result<&'static VerifierClient, KeylimectlError>
     }
 }
 
-/// Get or create the verifier client with API version override
-///
-/// This function is used for push-model where we need to force API v3.0
-/// for verifier requests while still benefiting from version detection.
-///
-/// # Arguments
-///
-/// * `api_version` - The API version to use (e.g., "3.0")
-///
-/// # Errors
-///
-/// Returns an error if the client cannot be created.
-///
-/// # Examples
-///
-/// ```rust,ignore
-/// use keylimectl::client::factory;
-///
-/// // For push-model operations
-/// let verifier = factory::get_verifier_with_override("3.0").await?;
-/// ```
-pub async fn get_verifier_with_override(
-    api_version: &str,
-) -> Result<&'static VerifierClient, KeylimectlError> {
-    if let Some(client) = VERIFIER_CLIENT_OVERRIDE.get() {
-        return Ok(client);
-    }
-
-    // Create and initialize the client with override
-    let config = get_config();
-    let client = VerifierClient::builder()
-        .config(config)
-        .override_api_version(api_version)
-        .build()
-        .await?;
-
-    // Try to set it
-    match VERIFIER_CLIENT_OVERRIDE.set(client) {
-        Ok(()) => Ok(VERIFIER_CLIENT_OVERRIDE.get().unwrap()),
-        Err(client) => {
-            drop(client);
-            Ok(VERIFIER_CLIENT_OVERRIDE.get().unwrap())
-        }
-    }
-}
-
 /// Get or create the registrar client
 ///
 /// This function returns a cached registrar client if one exists, or creates

keylimectl/src/client/verifier.rs

@@ -159,16 +159,12 @@ pub struct VerifierClient {
 #[derive(Debug)]
 pub struct VerifierClientBuilder<'a> {
     config: Option<&'a Config>,
-    override_api_version: Option<String>,
 }
 
 impl<'a> VerifierClientBuilder<'a> {
     /// Create a new builder instance
     pub fn new() -> Self {
-        Self {
-            config: None,
-            override_api_version: None,
-        }
+        Self { config: None }
     }
 
     /// Set the configuration for the client
@@ -177,40 +173,19 @@ impl<'a> VerifierClientBuilder<'a> {
         self
     }
 
-    /// Override the API version after detection
-    ///
-    /// This allows you to override the detected API version for specific
-    /// operations while still benefiting from detection for component
-    /// discovery. Useful for push-model where verifier needs v3.0 but
-    /// other components may use different versions.
-    pub fn override_api_version(mut self, version: &str) -> Self {
-        self.override_api_version = Some(version.to_string());
-        self
-    }
-
     /// Build the VerifierClient with automatic API version detection
     ///
     /// This is the recommended way to create a client for production use,
     /// as it will automatically detect the optimal API version supported
     /// by the verifier service.
-    ///
-    /// If `override_api_version()` was called, the detected version will
-    /// be overridden after detection completes.
     pub async fn build(self) -> Result<VerifierClient, KeylimectlError> {
         let config = self.config.ok_or_else(|| {
             KeylimectlError::validation(
                 "Configuration is required for VerifierClient",
             )
         })?;
 
-        let mut client = VerifierClient::new(config).await?;
-
-        // Override API version if specified
-        if let Some(version) = self.override_api_version {
-            client.api_version = version;
-        }
-
-        Ok(client)
+        VerifierClient::new(config).await
     }
 }
 
@@ -580,16 +555,11 @@ impl VerifierClient {
     ) -> Result<Value, KeylimectlError> {
         debug!("Adding agent {agent_uuid} to verifier");
 
-        // API v3.0+ uses POST /v3.0/agents/ (without agent ID)
-        // API v2.x uses POST /v2.x/agents/{agent_id}
-        let url = if self.api_version.parse::<f32>().unwrap_or(2.1) >= 3.0 {
-            format!("{}/v{}/agents/", self.base.base_url, self.api_version)
-        } else {
-            format!(
-                "{}/v{}/agents/{}",
-                self.base.base_url, self.api_version, agent_uuid
-            )
-        };
+        // POST to /agents/:agent_uuid for all API versions
+        let url = format!(
+            "{}/v{}/agents/{}",
+            self.base.base_url, self.api_version, agent_uuid
+        );
 
         debug!(
             "POST {url} with data: {}",
@@ -1991,22 +1961,7 @@ mod tests {
         }
 
         #[tokio::test]
-        async fn test_builder_override_api_version() {
-            let config = create_test_config();
-            let client = VerifierClient::builder()
-                .config(&config)
-                .override_api_version("3.0")
-                .build()
-                .await;
-
-            assert!(client.is_ok());
-            let client = client.unwrap();
-            // Should use the overridden version
-            assert_eq!(client.api_version, "3.0");
-        }
-
-        #[tokio::test]
-        async fn test_builder_without_override() {
+        async fn test_builder() {
             let config = create_test_config();
             let client =
                 VerifierClient::builder().config(&config).build().await;

keylimectl/src/commands/agent.rs

@@ -758,18 +758,9 @@ async fn add_agent(
     // Step 2: Determine API version and enrollment approach
     output.step(2, 4, "Detecting verifier API version");
 
-    // For push model, we need to use API v3.0 for verifier requests
-    let verifier_client = if params.push_model {
-        factory::get_verifier_with_override("3.0")
-            .await
-            .map_err(|e| {
-                CommandError::resource_error("verifier", e.to_string())
-            })?
-    } else {
-        factory::get_verifier().await.map_err(|e| {
-            CommandError::resource_error("verifier", e.to_string())
-        })?
-    };
+    let verifier_client = factory::get_verifier().await.map_err(|e| {
+        CommandError::resource_error("verifier", e.to_string())
+    })?;
 
     let api_version =
         verifier_client.api_version().parse::<f32>().unwrap_or(2.1);