clean up

src/api/assets.rs

@@ -40,7 +40,7 @@ impl ApiClient for AssetsClient {
 
     fn base_url(&self) -> String {
         let domain = std::env::var("EV_DOMAIN").unwrap_or_else(|_| String::from("evervault.com"));
-        format!("https://cage-build-assets.{}", domain)
+        format!("https://enclave-build-assets.{}", domain)
     }
 
     fn auth(&self) -> &super::AuthMode {

src/api/client.rs

@@ -129,7 +129,6 @@ pub trait HandleResponse {
 #[async_trait]
 impl HandleResponse for ReqwestResult<Response> {
     async fn handle_json_response<T: DeserializeOwned>(self) -> ApiResult<T> {
-        println!("self: {:?}", self);
         match self {
             Ok(res) if res.status().is_success() => res
                 .json()

src/api/enclave.rs

@@ -450,7 +450,7 @@ impl CreateEnclaveRequest {
 #[serde(rename_all = "camelCase")]
 pub struct CreateEnclaveDeploymentIntentResponse {
     signed_url: String,
-    uuid: String,
+    enclave_uuid: String,
     deployment_uuid: String,
     version: u32,
 }
@@ -461,7 +461,7 @@ impl CreateEnclaveDeploymentIntentResponse {
     }
 
     pub fn enclave_uuid(&self) -> &str {
-        &self.uuid
+        &self.enclave_uuid
     }
 
     pub fn deployment_uuid(&self) -> &str {
@@ -752,14 +752,14 @@ impl GetEnclaveResponse {
 pub struct GetEnclaveDeploymentResponse {
     #[serde(flatten)]
     pub deployment: EnclaveDeployment,
-    pub tee_enclave_version: EnclaveVersion,
-    pub tee_enclave_signing_cert: EnclaveSigningCert,
-    pub tee_enclave_regional_deployments: Vec<EnclaveRegionalDeployment>,
+    pub enclave_version: EnclaveVersion,
+    pub enclave_signing_cert: EnclaveSigningCert,
+    pub enclave_regional_deployments: Vec<EnclaveRegionalDeployment>,
 }
 
 impl GetEnclaveDeploymentResponse {
     pub fn is_built(&self) -> bool {
-        matches!(self.tee_enclave_version.build_status, BuildStatus::Ready)
+        matches!(self.enclave_version.build_status, BuildStatus::Ready)
     }
 
     pub fn is_finished(&self) -> bool {
@@ -768,25 +768,25 @@ impl GetEnclaveDeploymentResponse {
 
     //TODO: Handle multi region deployment failures
     pub fn is_failed(&self) -> bool {
-        let build_failed = matches!(self.tee_enclave_version.build_status, BuildStatus::Failed);
+        let build_failed = matches!(self.enclave_version.build_status, BuildStatus::Failed);
         build_failed
             || self
-                .tee_enclave_regional_deployments
+                .enclave_regional_deployments
                 .first()
                 .map(|depl| depl.is_failed())
                 .unwrap_or_default()
     }
 
     pub fn get_failure_reason(&self) -> Option<String> {
-        self.tee_enclave_version.failure_reason.clone().or_else(|| {
-            self.tee_enclave_regional_deployments
+        self.enclave_version.failure_reason.clone().or_else(|| {
+            self.enclave_regional_deployments
                 .first()
                 .map(|depl| depl.get_failure_reason())
         })
     }
 
     pub fn get_detailed_status(&self) -> Option<String> {
-        self.tee_enclave_regional_deployments
+        self.enclave_regional_deployments
             .first()
             .map(|depl| depl.get_detailed_status())
     }
@@ -937,9 +937,9 @@ mod test {
         let cert = get_testing_cert();
         let deployment_with_empty_regional = GetEnclaveDeploymentResponse {
             deployment,
-            tee_enclave_version: version,
-            tee_enclave_signing_cert: cert,
-            tee_enclave_regional_deployments: vec![],
+            enclave_version: version,
+            enclave_signing_cert: cert,
+            enclave_regional_deployments: vec![],
         };
 
         assert!(deployment_with_empty_regional
@@ -961,9 +961,9 @@ mod test {
         let detailed_failure_reason = "Insufficient capacity".to_string();
         let deployment_with_regional = GetEnclaveDeploymentResponse {
             deployment,
-            tee_enclave_version: version,
-            tee_enclave_signing_cert: cert,
-            tee_enclave_regional_deployments: vec![EnclaveRegionalDeployment {
+            enclave_version: version,
+            enclave_signing_cert: cert,
+            enclave_regional_deployments: vec![EnclaveRegionalDeployment {
                 uuid: "abc".to_string(),
                 deployment_uuid: "def".to_string(),
                 deployment_order: 1,

src/cli/deploy.rs

@@ -180,6 +180,7 @@ pub async fn run(deploy_args: DeployArgs) -> exitcode::ExitCode {
     enclave_config.set_attestation(&eif_measurements);
     crate::common::save_enclave_config(&enclave_config, &deploy_args.config);
 
+    println!("Deploying enclave");
     if let Err(e) = deploy_eif(
         &validated_config,
         enclave_api,

src/test_utils.rs

@@ -81,7 +81,7 @@ pub fn build_get_enclave_deployment(
             started_at: started_at.clone(),
             completed_at: completed_at.clone(),
         },
-        tee_enclave_version: EnclaveVersion {
+        enclave_version: EnclaveVersion {
             uuid: "".into(),
             version: 0,
             control_plane_img_url: Some("".into()),
@@ -92,15 +92,15 @@ pub fn build_get_enclave_deployment(
             started_at: started_at.clone(),
             healthcheck: None,
         },
-        tee_enclave_signing_cert: EnclaveSigningCert {
+        enclave_signing_cert: EnclaveSigningCert {
             name: Some("".into()),
             uuid: "".into(),
             app_uuid: "".into(),
             cert_hash: "".into(),
             not_before: None,
             not_after: None,
         },
-        tee_enclave_regional_deployments: vec![EnclaveRegionalDeployment {
+        enclave_regional_deployments: vec![EnclaveRegionalDeployment {
             uuid: "".into(),
             deployment_uuid: "".into(),
             deployment_order: 0,