feat: implement rds resource on beta platform

cargo-shuttle/src/lib.rs

@@ -1055,7 +1055,14 @@ impl Shuttle {
             client.get_service_resources(self.ctx.project_name()).await
         }
         .map_err(suggestions::resources::get_service_resources_failure)?;
-        let table = get_resource_tables(&resources, self.ctx.project_name(), raw, show_secrets);
+
+        let table = get_resource_tables(
+            &resources,
+            self.ctx.project_name(),
+            raw,
+            show_secrets,
+            self.beta,
+        );
 
         println!("{table}");
 
@@ -1261,7 +1268,15 @@ impl Shuttle {
 
         println!(
             "{}",
-            get_resource_tables(&mocked_responses, service_name.as_str(), false, false)
+            get_resource_tables(
+                &mocked_responses,
+                service_name.as_str(),
+                false,
+                false,
+                // Set beta to false to avoid breaking local run with beta changes.
+                // TODO: make local run compatible with --beta.
+                false
+            )
         );
 
         //
@@ -2102,7 +2117,8 @@ impl Shuttle {
         let resources = client
             .get_service_resources(self.ctx.project_name())
             .await?;
-        let resources = get_resource_tables(&resources, self.ctx.project_name(), false, false);
+        let resources =
+            get_resource_tables(&resources, self.ctx.project_name(), false, false, self.beta);
 
         println!("{resources}{service}");
 

common/src/lib.rs

@@ -81,7 +81,7 @@ impl AsRef<str> for ApiKey {
 ////// Resource Input/Output types
 
 /// The input given to Shuttle DB resources
-#[derive(Deserialize, Serialize, Default)]
+#[derive(Clone, Deserialize, Serialize, Default)]
 pub struct DbInput {
     pub local_uri: Option<String>,
     /// Override the default db name. Only applies to RDS.
@@ -172,6 +172,71 @@ impl DatabaseInfo {
     }
 }
 
+/// Holds the data for building a database connection string on the Beta platform.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DatabaseInfoBeta {
+    engine: String,
+    role_name: String,
+    role_password: Secret<String>,
+    database_name: String,
+    port: String,
+    hostname: String,
+    /// The RDS instance name, which is required for deleting provisioned RDS instances, it's
+    /// optional because it isn't needed for shared PG deletion.
+    instance_name: Option<String>,
+}
+
+impl DatabaseInfoBeta {
+    pub fn new(
+        engine: String,
+        role_name: String,
+        role_password: String,
+        database_name: String,
+        port: String,
+        hostname: String,
+        instance_name: Option<String>,
+    ) -> Self {
+        Self {
+            engine,
+            role_name,
+            role_password: Secret::new(role_password),
+            database_name,
+            port,
+            hostname,
+            instance_name,
+        }
+    }
+
+    /// For connecting to the database.
+    pub fn connection_string(&self, show_password: bool) -> String {
+        format!(
+            "{}://{}:{}@{}:{}/{}",
+            self.engine,
+            self.role_name,
+            if show_password {
+                self.role_password.expose()
+            } else {
+                self.role_password.redacted()
+            },
+            self.hostname,
+            self.port,
+            self.database_name,
+        )
+    }
+
+    pub fn role_name(&self) -> String {
+        self.role_name.to_string()
+    }
+
+    pub fn database_name(&self) -> String {
+        self.database_name.to_string()
+    }
+
+    pub fn instance_name(&self) -> Option<String> {
+        self.instance_name.clone()
+    }
+}
+
 /// Used to request a container from the local run provisioner
 #[derive(Serialize, Deserialize)]
 pub struct ContainerRequest {

common/src/models/resource.rs

@@ -2,22 +2,23 @@ use std::collections::HashMap;
 
 use comfy_table::{
     modifiers::UTF8_ROUND_CORNERS,
-    presets::{NOTHING, UTF8_FULL},
+    presets::{NOTHING, UTF8_BORDERS_ONLY, UTF8_FULL},
     Attribute, Cell, CellAlignment, ContentArrangement, Table,
 };
 use crossterm::style::Stylize;
 
 use crate::{
     resource::{Response, Type},
     secrets::SecretStore,
-    DatabaseResource,
+    DatabaseInfoBeta, DatabaseResource,
 };
 
 pub fn get_resource_tables(
     resources: &[Response],
     service_name: &str,
     raw: bool,
     show_secrets: bool,
+    beta: bool,
 ) -> String {
     if resources.is_empty() {
         if raw {
@@ -44,12 +45,21 @@ pub fn get_resource_tables(
         let mut output = Vec::new();
 
         if let Some(databases) = resource_groups.get("Databases") {
-            output.push(get_databases_table(
-                databases,
-                service_name,
-                raw,
-                show_secrets,
-            ));
+            if beta {
+                output.push(get_databases_table_beta(
+                    databases,
+                    service_name,
+                    raw,
+                    show_secrets,
+                ));
+            } else {
+                output.push(get_databases_table(
+                    databases,
+                    service_name,
+                    raw,
+                    show_secrets,
+                ));
+            }
         };
 
         if let Some(secrets) = resource_groups.get("Secrets") {
@@ -137,6 +147,46 @@ fn get_databases_table(
     format!("These databases are linked to {service_name}\n{table}\n{show_secret_hint}")
 }
 
+fn get_databases_table_beta(
+    databases: &Vec<&Response>,
+    service_name: &str,
+    raw: bool,
+    show_secrets: bool,
+) -> String {
+    let mut table = Table::new();
+
+    if raw {
+        table
+            .load_preset(NOTHING)
+            .set_content_arrangement(ContentArrangement::Disabled)
+            .set_header(vec![
+                Cell::new("Type").set_alignment(CellAlignment::Left),
+                Cell::new("Connection string").set_alignment(CellAlignment::Left),
+            ]);
+    } else {
+        table
+            .load_preset(UTF8_BORDERS_ONLY)
+            .set_content_arrangement(ContentArrangement::Disabled)
+            .set_header(vec![Cell::new("Type"), Cell::new("Connection string")]);
+    }
+
+    for database in databases {
+        let connection_string = serde_json::from_value::<DatabaseInfoBeta>(database.data.clone())
+            .expect("resource data to be a valid database")
+            .connection_string(show_secrets);
+
+        table.add_row(vec![database.r#type.to_string(), connection_string]);
+    }
+
+    let show_secret_hint = if databases.is_empty() || show_secrets {
+        ""
+    } else {
+        "Hint: you can show the secrets of these resources using `cargo shuttle resource list --show-secrets`\n"
+    };
+
+    format!("These databases are linked to {service_name}\n{table}\n{show_secret_hint}")
+}
+
 fn get_secrets_table(secrets: &[&Response], service_name: &str, raw: bool) -> String {
     let mut table = Table::new();
 

common/src/resource.rs

@@ -51,6 +51,7 @@ pub enum ResourceState {
     Failed,
     Ready,
     Deleting,
+    Deleted,
 }
 
 /// Returned when provisioning a Shuttle resource

runtime/src/alpha.rs

@@ -311,7 +311,7 @@ where
             // it has sent a load response, so that the ECS task will fail.
             tokio::spawn(async move {
                 // Note: The timeout is quite long since RDS can take a long time to provision.
-                tokio::time::sleep(Duration::from_secs(180)).await;
+                tokio::time::sleep(Duration::from_secs(270)).await;
                 if !matches!(state.lock().unwrap().deref(), State::Running) {
                     println!("the runtime failed to enter the running state before timing out");