fix(sdk, rust): adds build-able TlsKeyConfig

Author: tuddman

Cargo.lock

@@ -9,6 +9,7 @@ authors = ["Encifher <encifher@rizelabs.io>"]
 [dependencies]
 alloy = { version = "0.15", features = ["signers", "signer-local"] }
 anyhow.workspace = true
+bon.workspace = true
 hex.workspace = true 
 http.workspace = true 
 http-client-unix-domain-socket = "0.1.1"

sdk/rust/Cargo.toml

@@ -51,6 +51,19 @@ pub struct EventLog {
     event_payload: String,
 }
 
+#[derive(bon::Builder, Serialize)]
+pub struct TlsKeyConfig {
+    #[builder(into)]
+    pub subject: Option<String>,
+    pub alt_names: Option<Vec<String>>,
+    #[builder(default = false)]
+    pub usage_ra_tls: bool,
+    #[builder(default = true)]
+    pub usage_server_auth: bool,
+    #[builder(default = false)]
+    pub usage_client_auth: bool,
+}
+
 #[derive(Serialize, Deserialize)]
 pub struct GetKeyResponse {
     pub key: String,
@@ -248,22 +261,8 @@ impl DstackClient {
         Ok(())
     }
 
-    pub async fn get_tls_key(
-        &self,
-        subject: Option<String>,
-        alt_names: Option<Vec<String>>,
-        usage_ra_tls: bool,
-        usage_server_auth: bool,
-        usage_client_auth: bool,
-    ) -> Result<GetTlsKeyResponse> {
-        let data = json!({
-            "subject": subject.unwrap_or_default(),
-            "alt_names": alt_names.unwrap_or_default(),
-            "usage_ra_tls": usage_ra_tls,
-            "usage_server_auth": usage_server_auth,
-            "usage_client_auth": usage_client_auth
-        });
-        let response = self.send_rpc_request("/GetTlsKey", &data).await?;
+    pub async fn get_tls_key(&self, tls_key_config: TlsKeyConfig) -> Result<GetTlsKeyResponse> {
+        let response = self.send_rpc_request("/GetTlsKey", &tls_key_config).await?;
         let response = serde_json::from_value::<GetTlsKeyResponse>(response)?;
 
         Ok(response)

sdk/rust/src/dstack_client.rs

@@ -19,25 +19,19 @@ async fn test_async_client_get_quote() {
 #[tokio::test]
 async fn test_async_client_get_tls_key() {
     let client = AsyncDstackClient::new(None);
-    let result = client
-        .get_tls_key(None, None, false, false, false)
-        .await
-        .unwrap();
+    let key_config = dstack_sdk::dstack_client::TlsKeyConfig::builder().build();
+    let result = client.get_tls_key(key_config).await.unwrap();
     assert!(result.key.starts_with("-----BEGIN PRIVATE KEY-----"));
     assert!(!result.certificate_chain.is_empty());
 }
 
 #[tokio::test]
 async fn test_tls_key_uniqueness() {
     let client = AsyncDstackClient::new(None);
-    let result1 = client
-        .get_tls_key(None, None, false, false, false)
-        .await
-        .unwrap();
-    let result2 = client
-        .get_tls_key(None, None, false, false, false)
-        .await
-        .unwrap();
+    let key_config_1 = dstack_sdk::dstack_client::TlsKeyConfig::builder().build();
+    let key_config_2 = dstack_sdk::dstack_client::TlsKeyConfig::builder().build();
+    let result1 = client.get_tls_key(key_config_1).await.unwrap();
+    let result2 = client.get_tls_key(key_config_2).await.unwrap();
     assert_ne!(result1.key, result2.key);
 }
 

sdk/rust/tests/test_client.rs

@@ -1,6 +1,5 @@
-use dstack_rust::dstack_client::{DstackClient, GetKeyResponse};
-use dstack_rust::ethereum::to_account;
-use tokio;
+use dstack_sdk::dstack_client::{DstackClient, GetKeyResponse};
+use dstack_sdk::ethereum::to_account;
 
 #[tokio::test]
 async fn test_async_to_keypair() {