chore: production environment deployed and tested

Author: Utilitycoder

Diff for: Dockerfile

@@ -13,5 +13,7 @@ ENV SQLX_OFFLINE true
 # Let's build our binary!
 # We'll use the release profile to make it faaaast
 RUN cargo build --release
+# Instruct the binary in our Docker image to use the production configuration
+ENV APP_ENVIRONMENT production
 # When `docker run` is executed, launch the
 ENTRYPOINT ["./target/release/robust-rust"]

Diff for: configuration.yaml

@@ -1,9 +1,15 @@
-use secrecy::{Secret, ExposeSecret};
+use secrecy::{ExposeSecret, Secret};
 
 #[derive(serde::Deserialize)]
 pub struct Settings {
     pub database: DatabaseSettings,
-    pub application_port: u16,
+    pub application: ApplicationSettings,
+}
+
+#[derive(serde::Deserialize)]
+pub struct ApplicationSettings {
+    pub port: u16,
+    pub host: String,
 }
 
 #[derive(serde::Deserialize)]
@@ -19,25 +25,72 @@ impl DatabaseSettings {
     pub fn connection_string(&self) -> Secret<String> {
         Secret::new(format!(
             "postgres://{}:{}@{}:{}/{}",
-            self.username, self.password.expose_secret(), self.host, self.port, self.database_name
+            self.username,
+            self.password.expose_secret(),
+            self.host,
+            self.port,
+            self.database_name
         ))
     }
 
     pub fn connection_string_without_db(&self) -> Secret<String> {
         Secret::new(format!(
             "postgres://{}:{}@{}:{}",
-            self.username, self.password.expose_secret(), self.host, self.port
+            self.username,
+            self.password.expose_secret(),
+            self.host,
+            self.port
         ))
     }
 }
 
 pub fn get_configuration() -> Result<Settings, config::ConfigError> {
     // Initialize our configuration reader
     let mut settings = config::Config::default();
-    // Add configuration values from a file named `configuration`
-    // with the `ini` file format
-    settings.merge(config::File::with_name("configuration"))?;
-    // Try to convert the configuration values it read into
-    // our Settings type
+    let base_path = std::env::current_dir().expect("Failed to determine the current directory");
+    let configuration_directory = base_path.join("configuration");
+
+    // Read the "default" configuration file
+    settings.merge(config::File::from(configuration_directory.join("base")).required(true))?;
+
+    // Detect the running environment
+    // Default to 'local' if unspecified
+    let environment: Environment = std::env::var("APP_ENVIRONMENT")
+        .unwrap_or_else(|_| "local".into())
+        .try_into()
+        .expect("APP_ENVIRONMENT must be 'local' or 'production'");
+
+    // Layer on environment specific values
+    settings.merge(
+        config::File::from(configuration_directory.join(environment.as_str())).required(true)
+    )?;
+
     settings.try_into()
 }
+
+// The possible runtime environment for our application
+// We can run our application in either "local" or "production" mode
+pub enum Environment {
+    Local,
+    Production,
+}
+
+impl Environment {
+    pub fn as_str(&self) -> &str {
+        match self {
+            Environment::Local => "local",
+            Environment::Production => "production",
+        }
+    }
+}
+
+impl TryFrom<String> for Environment {
+    type Error = String;
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        match value.to_lowercase().as_str() {
+            "local" => Ok(Self::Local),
+            "production" => Ok(Self::Production),
+            _ => Err(format!("{} is not a supported environment. Use either local or production", value)),
+        }
+    }
+}

Diff for: src/configuration.rs

@@ -1,19 +1,22 @@
 use robust_rust::configuration::get_configuration;
 use robust_rust::startup::run;
 use robust_rust::telemetry::{get_subscriber, init_subscriber};
+use secrecy::ExposeSecret;
 use sqlx::PgPool;
 use std::net::TcpListener;
-use secrecy::ExposeSecret;
 
 #[tokio::main]
 async fn main() -> std::io::Result<()> {
     let subscriber = get_subscriber("robust_rust".into(), "info".into(), std::io::stdout);
     init_subscriber(subscriber);
     let configuration = get_configuration().expect("Failed to read configuration.");
-    let connection_pool = PgPool::connect(configuration.database.connection_string().expose_secret())
-        .await
-        .expect("Failed to connect to Postgres.");
-    let address = format!("127.0.0.1:{}", configuration.application_port);
+    let connection_pool =
+        PgPool::connect_lazy(configuration.database.connection_string().expose_secret())
+            .expect("Failed to connect to Postgres.");
+    let address = format!(
+        "{}:{}",
+        configuration.application.host, configuration.application.port
+    );
     let listener = TcpListener::bind(address).expect("Failed to bind random port");
     run(listener, connection_pool)?.await?;
     Ok(())

Diff for: src/main.rs

@@ -1,7 +1,7 @@
 use actix_web::{web, HttpResponse};
 use chrono::Utc;
-use sqlx::PgPool;
 use sqlx::types::Uuid;
+use sqlx::PgPool;
 // use uuid::Uuid;
 
 #[allow(dead_code)]
@@ -32,7 +32,7 @@ pub async fn subscribe(form: web::Form<FormData>, pool: web::Data<PgPool>) -> Ht
 
 #[tracing::instrument(
     name = "Saving a new subscriber details in the database",
-    skip(form, pool),
+    skip(form, pool)
 )]
 async fn insert_subscriber(form: &FormData, pool: &PgPool) -> Result<(), sqlx::Error> {
     let subscribe_id = Uuid::new_v4();

Diff for: src/routes/subscriptions.rs

@@ -5,10 +5,10 @@ use robust_rust::{
     startup::run,
     telemetry::{get_subscriber, init_subscriber},
 };
+use secrecy::ExposeSecret;
 use sqlx::{Connection, Executor, PgConnection, PgPool};
 use std::net::TcpListener;
 use uuid::Uuid;
-use secrecy::ExposeSecret;
 
 // Ensure that the `tracing` stack is only initialized once using `Lazy`.
 static TRACING: Lazy<()> = Lazy::new(|| {
@@ -55,9 +55,10 @@ async fn spawn_app() -> TestApp {
 
 pub async fn configure_database(config: &DatabaseSettings) -> PgPool {
     // Create database
-    let mut connection = PgConnection::connect(config.connection_string_without_db().expose_secret())
-        .await
-        .expect("Failed to connect to Postgres");
+    let mut connection =
+        PgConnection::connect(config.connection_string_without_db().expose_secret())
+            .await
+            .expect("Failed to connect to Postgres");
     connection
         .execute(format!(r#"CREATE DATABASE "{}";"#, config.database_name).as_str())
         .await