Changes for end to end testing and debug logs (#46)

Author: EricGhildyal

Cargo.lock

@@ -1,13 +1,10 @@
 use std::ops::Deref;
 use std::sync::Arc;
 
-use super::{
-    BoxedIngress, BoxedMonitor, BoxedPlatform, IngressBuilder, MonitorBuilder, PlatformBuilder,
-    StatusCode,
-};
+use super::{BoxedIngress, BoxedMonitor, BoxedPlatform, StatusCode};
 use crate::Cli;
 use crate::fs::UserCreds;
-use crate::{artifacts::LambdaZip, fs::Session, metrics::ResponseStatusCode};
+use crate::{fs::Session, metrics::ResponseStatusCode};
 use chrono::DateTime;
 use miette::miette;
 use miette::{IntoDiagnostic, Result, bail};
@@ -203,30 +200,6 @@ impl BackendClient {
         Ok(response.deployment.id)
     }
 
-    /// Given the workspace name and the application name, fetch
-    /// the configuration of the application.
-    pub async fn fetch_config(
-        &self,
-        workspace: &str,
-        application_name: &str,
-        artifact: LambdaZip,
-    ) -> Result<ApplicationConfig> {
-        // • First, we have to exchange the workspace name for it's id.
-        let workspace = self.get_workspace_by_name(workspace).await?;
-        // • Then, we can do the same with the application name.
-        let application = self
-            .get_application_by_name(workspace.id, application_name)
-            .await?;
-        let ingress_conf = *application.ingress;
-        let platform_conf = *application.platform;
-        let monitor_conf = *application.monitor;
-        Ok(ApplicationConfig {
-            platform: PlatformBuilder::new(platform_conf, artifact).build().await,
-            ingress: IngressBuilder::new(ingress_conf).build().await,
-            monitor: MonitorBuilder::new(monitor_conf).build().await,
-        })
-    }
-
     /// This fuction logs the user into the backend by exchanging these credentials
     /// with the backend server.
     pub async fn exchange_creds(&self, email: &str, password: &str) -> Result<Session> {
@@ -292,7 +265,7 @@ impl BackendClient {
     }
 
     /// Return information about the workspace given its name.
-    async fn get_workspace_by_name(&self, name: &str) -> Result<WorkspaceSummary> {
+    pub(crate) async fn get_workspace_by_name(&self, name: &str) -> Result<WorkspaceSummary> {
         self.is_authenicated()?;
 
         // let mut workspaces = list_workspaces(&self.conf, Some(name))
@@ -321,7 +294,7 @@ impl BackendClient {
     //       isntead of having to filter by name.
     /// Given the id of the workspace containing the application, and the application's
     /// name, fetch the application's information.
-    async fn get_application_by_name(
+    pub(crate) async fn get_application_by_name(
         &self,
         workspace_id: WorkspaceId,
         name: &str,
@@ -416,7 +389,7 @@ impl From<LoginSuccess> for UserCreds {
     }
 }
 
-mod deploy_meta;
+pub mod deploy_meta;
 
 #[cfg(test)]
 mod tests {

src/adapters/backend/mod.rs

@@ -7,7 +7,7 @@ use crate::{Shutdownable, WholePercent};
 /// dispatched.
 pub type BoxedIngress = Box<dyn Ingress + Send + Sync>;
 
-pub(super) use builder::IngressBuilder;
+pub(crate) use builder::IngressBuilder;
 
 /// Ingresses are responsible for (1) controlling how much traffic the canary
 /// gets (hence the name ingress, since it functions like a virtual LB) and

src/adapters/ingresses/mod.rs

@@ -5,7 +5,7 @@ pub use ingresses::*;
 pub use monitors::*;
 pub use platforms::*;
 
-mod backend;
+pub mod backend;
 /// Contains the trait definition and ingress implementations. Ingresses are responsible
 /// for actuating changes to traffic.
 mod ingresses;

src/adapters/mod.rs

@@ -17,7 +17,7 @@ pub type StatusCode = CategoricalObservation<5, ResponseStatusCode>;
 // and there may not be a generic parameter on the Monitor type anymore.
 pub type BoxedMonitor = Box<dyn Monitor<Item = StatusCode> + Send + Sync>;
 
-pub(super) use builder::MonitorBuilder;
+pub(crate) use builder::MonitorBuilder;
 
 #[async_trait]
 pub trait Monitor: Shutdownable {

src/adapters/monitors/mod.rs

@@ -1,5 +1,6 @@
 use async_trait::async_trait;
 use bon::bon;
+use chrono::format;
 use miette::{IntoDiagnostic as _, Result, miette};
 
 use crate::{
@@ -51,14 +52,19 @@ impl Platform for LambdaPlatform {
         let res = self
             .client
             .update_function_code()
+            .publish(true)
             .function_name(&self.name)
             .zip_file(zip_file.clone())
             .send()
             .await
             .into_diagnostic()?;
 
-        self.arn = res.function_arn().map(|s| s.to_string());
+        let function_arn = res
+            .function_arn()
+            .map(ToString::to_string)
+            .ok_or(miette!("Couldn't get ARN of deployed lambda"))?;
 
+        self.arn = Some(function_arn);
         self.arn
             .clone()
             .ok_or_else(|| miette!("No ARN returned from AWS"))

src/adapters/platforms/lambda.rs

@@ -1,12 +1,15 @@
 use std::path::PathBuf;
 
-use crate::adapters::{ApplicationConfig, DeploymentMetadata};
+use crate::adapters::backend::{ApplicationId, WorkspaceId};
+use crate::adapters::{
+    ApplicationConfig, DeploymentMetadata, IngressBuilder, MonitorBuilder, PlatformBuilder,
+};
 use crate::fs::{FileSystem, SessionFile};
 use crate::subsystems::CONTROLLER_SUBSYSTEM_NAME;
 use crate::{
     Cli, ControllerSubsystem, adapters::BackendClient, artifacts::LambdaZip, config::RunSubcommand,
 };
-use miette::{IntoDiagnostic, Result};
+use miette::Result;
 use tokio::runtime::Runtime;
 use tokio::time::Duration;
 use tokio_graceful_shutdown::{IntoSubsystem as _, SubsystemBuilder, Toplevel};
@@ -21,8 +24,8 @@ const DEFAULT_SHUTDOWN_TIMEOUT: u64 = 5000;
 pub struct Run {
     _terminal: Terminal,
     artifact_path: PathBuf,
-    workspace: String,
-    application: String,
+    workspace_name: String,
+    application_name: String,
     backend: BackendClient,
 }
 
@@ -37,41 +40,53 @@ impl Run {
             _terminal: terminal,
             backend,
             artifact_path: args.artifact_path,
-            workspace: args.workspace,
-            application: args.application,
+            workspace_name: args.workspace,
+            application_name: args.application,
         })
     }
 
     pub fn dispatch(self) -> Result<()> {
+        dbg!("Executing the `run` command...");
         let rt = Runtime::new().unwrap();
         let _guard = rt.enter();
         rt.block_on(async {
-            // • First, we have to load the artifact.
-            //   This lets us fail fast in the case where the artifact
-            //   doesn't exist or we don't have permission to read the file.
+            // First, we have to load the artifact.
+            // This lets us fail fast in the case where the artifact
+            // doesn't exist or we don't have permission to read the file.
+            dbg!("Loading the lambda artifact...");
             let artifact = LambdaZip::load(&self.artifact_path).await?;
-            // • Now, we have to load the application's configuration
-            //   from the backend. We have the name of the workspace and
-            //   application, but we need to look up the details.
-            let conf = self
+            // We need to convert our workspace and application names into the full workspace and application object
+            dbg!("Loading workspace and application...");
+            let workspace = self
+                .backend
+                .get_workspace_by_name(&self.workspace_name)
+                .await?;
+            let application = self
                 .backend
-                .fetch_config(&self.workspace, &self.application, artifact)
+                .get_application_by_name(workspace.id, &self.application_name)
                 .await?;
-            let ApplicationConfig {
-                ingress,
-                platform,
-                monitor,
-            } = conf;
+            // Now, we have to load the application's configuration
+            // from the backend. We have the name of the workspace and
+            // application, but we need to look up the details.
+            dbg!("Loading application conf...");
+            let conf = ApplicationConfig {
+                platform: PlatformBuilder::new(*application.platform, artifact)
+                    .build()
+                    .await,
+                ingress: IngressBuilder::new(*application.ingress).build().await,
+                monitor: MonitorBuilder::new(*application.monitor).build().await,
+            };
 
             // Create a new deployment.
-            let metadata = self.create_deployment().await?;
+            let metadata = self.create_deployment(workspace.id, application.id).await?;
 
             // Build the ControllerSubsystem using the boxed objects.
+            dbg!("Building controller...");
             let controller = ControllerSubsystem::builder()
                 .backend(self.backend)
-                .monitor(monitor)
-                .ingress(ingress)
-                .platform(platform)
+                .monitor(conf.monitor)
+                .ingress(conf.ingress)
+                .platform(conf.platform)
                 .meta(metadata)
                 .build();
 
@@ -90,21 +105,21 @@ impl Run {
         })
     }
 
-    async fn create_deployment(&self) -> Result<DeploymentMetadata> {
-        // TODO: This `.parse().into_diagnostic()?` code is awful. Once
-        //       we settle on the type of WorkspaceId and ApplicationId,
-        //       we can clean it up instead of using the raw types.
+    async fn create_deployment(
+        &self,
+        workspace_id: WorkspaceId,
+        application_id: ApplicationId,
+    ) -> Result<DeploymentMetadata> {
+        dbg!("Creating new deployment...");
         let deployment_id = self
             .backend
-            .new_deployment(
-                self.workspace.parse().into_diagnostic()?,
-                self.application.parse().into_diagnostic()?,
-            )
+            .new_deployment(workspace_id, application_id)
             .await?;
 
+        dbg!("Creating new deployment metadata...");
         let meta = DeploymentMetadata::builder()
-            .workspace_id(self.workspace.parse().into_diagnostic()?)
-            .application_id(self.application.parse().into_diagnostic()?)
+            .workspace_id(workspace_id)
+            .application_id(application_id)
             .deployment_id(deployment_id)
             .build();
         Ok(meta)

src/cmd/run.rs

@@ -41,6 +41,7 @@ impl ControllerSubsystem {
         platform: BoxedPlatform,
         meta: DeploymentMetadata,
     ) -> Self {
+        dbg!("Creating a new controller subsystem...");
         Self {
             backend,
             monitor,
@@ -54,6 +55,7 @@ impl ControllerSubsystem {
 #[async_trait]
 impl IntoSubsystem<Report> for ControllerSubsystem {
     async fn run(self, subsys: SubsystemHandle) -> Result<()> {
+        dbg!("Running the controller subsystem...");
         let ingress_subsystem = IngressSubsystem::new(self.ingress);
         let ingress_handle = ingress_subsystem.handle();
 

src/subsystems/controller/mod.rs

@@ -151,6 +151,7 @@ impl IntoSubsystem<Report> for MonitorController<StatusCode> {
                         // Let's emit them to our output stream.
                         self.sender.send(batch).await.unwrap();
                     } else {
+                        dbg!("Shutting down in monitor");
                         // The stream has been closed. Shut down.
                         subsys.request_local_shutdown();
                     }

src/subsystems/controller/monitor.rs

@@ -96,6 +96,7 @@ impl IntoSubsystem<Report> for IngressSubsystem {
                     if let Some(mail) = mail {
                         self.respond_to_mail(mail).await;
                     } else {
+                        dbg!("Stream closed in ingress");
                         return self.shutdown().await;
                     }
                 }