refactor!: refactor status to check on demand instead of attempting to track the state dynamically

Author: brianheineman

Cargo.lock

@@ -3,6 +3,7 @@
 
 targets = [
     { triple = "aarch64-unknown-linux-gnu" },
+    { triple = "aarch64-unknown-linux-musl" },
     { triple = "aarch64-apple-darwin" },
     { triple = "x86_64-apple-darwin" },
     { triple = "x86_64-pc-windows-msvc" },
@@ -35,4 +36,4 @@ name = "ring"
 expression = "MIT AND ISC AND OpenSSL"
 license-files = [
     { path = "LICENSE", hash = 0xbd0eed23 }
-]
+]

deny.toml

@@ -8,5 +8,5 @@ version.workspace = true
 [dependencies]
 anyhow = { workspace = true }
 postgresql_embedded = { path = "../../postgresql_embedded" }
-sqlx = { version = "0.7", no-default-features = true, features = ["postgres", "runtime-tokio-rustls"] }
+sqlx = { version = "0.7", default-features = true, features = ["postgres", "runtime-tokio-rustls"] }
 tokio = { workspace = true }

examples/sqlx_embedded/Cargo.toml

@@ -55,28 +55,28 @@ impl PostgreSQL {
     }
 
     /// Stop the database gracefully (smart mode) and wait for the shutdown to complete.
-    pub fn stop(&mut self) -> Result<()> {
+    pub fn stop(&self) -> Result<()> {
         RUNTIME
             .handle()
             .block_on(async move { self.inner.stop().await })
     }
 
     /// Create a new database with the given name.
-    pub fn create_database<S: AsRef<str>>(&mut self, database_name: S) -> Result<()> {
+    pub fn create_database<S: AsRef<str>>(&self, database_name: S) -> Result<()> {
         RUNTIME
             .handle()
             .block_on(async move { self.inner.create_database(database_name).await })
     }
 
     /// Check if a database with the given name exists.
-    pub fn database_exists<S: AsRef<str>>(&mut self, database_name: S) -> Result<bool> {
+    pub fn database_exists<S: AsRef<str>>(&self, database_name: S) -> Result<bool> {
         RUNTIME
             .handle()
             .block_on(async move { self.inner.database_exists(database_name).await })
     }
 
     /// Drop a database with the given name.
-    pub fn drop_database<S: AsRef<str>>(&mut self, database_name: S) -> Result<()> {
+    pub fn drop_database<S: AsRef<str>>(&self, database_name: S) -> Result<()> {
         RUNTIME
             .handle()
             .block_on(async move { self.inner.drop_database(database_name).await })

postgresql_embedded/src/blocking/mod.rs

@@ -39,26 +39,17 @@ pub(crate) const ARCHIVE: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/post
 pub enum Status {
     /// Archive not installed
     NotInstalled,
-    /// Installing software from archive
-    Installing,
     /// Installation complete; not initialized
     Installed,
-    /// Initialization running
-    Initializing,
-    /// Server starting
-    Starting,
     /// Server started
     Started,
-    /// Server stopping
-    Stopping,
     /// Server initialized and stopped
     Stopped,
 }
 
 /// PostgreSQL server
 #[derive(Clone, Debug)]
 pub struct PostgreSQL {
-    status: Status,
     version: Version,
     settings: Settings,
 }
@@ -68,7 +59,6 @@ impl PostgreSQL {
     /// Create a new [`PostgreSQL`] instance
     pub fn new(version: Version, settings: Settings) -> Self {
         let mut postgresql = PostgreSQL {
-            status: Status::NotInstalled,
             version,
             settings,
         };
@@ -85,8 +75,6 @@ impl PostgreSQL {
                 postgresql.settings.installation_dir =
                     postgresql.settings.installation_dir.join(version_string);
             }
-
-            postgresql.update_status();
         }
 
         postgresql
@@ -101,23 +89,17 @@ impl PostgreSQL {
         }
     }
 
-    /// Determine the status of the PostgreSQL server based on the settings
-    fn update_status(&mut self) {
-        let is_installed = self.is_installed();
-        let is_initialized = self.is_initialized();
-
-        if is_installed && is_initialized {
-            self.status = Status::Stopped
-        } else if is_installed {
-            self.status = Status::Installed
-        } else {
-            self.status = Status::NotInstalled
-        }
-    }
-
     /// Get the [status](Status) of the PostgreSQL server
     pub fn status(&self) -> Status {
-        self.status
+        if self.is_running() {
+            Status::Started
+        } else if self.is_initialized() {
+            Status::Stopped
+        } else if self.is_installed() {
+            Status::Installed
+        } else {
+            Status::NotInstalled
+        }
     }
 
     /// Get the [version](Version) of the PostgreSQL server
@@ -145,6 +127,12 @@ impl PostgreSQL {
         self.settings.data_dir.join("postgresql.conf").exists()
     }
 
+    /// Check if the PostgreSQL server is running
+    fn is_running(&self) -> bool {
+        let pid_file = self.settings.data_dir.join("postmaster.pid");
+        pid_file.exists()
+    }
+
     /// Set up the database by extracting the archive and initializing the database.
     /// If the installation directory already exists, the archive will not be extracted.
     /// If the data directory already exists, the database will not be initialized.
@@ -182,7 +170,6 @@ impl PostgreSQL {
 
         if self.settings.installation_dir.exists() {
             debug!("Installation directory already exists");
-            self.update_status();
             return Ok(());
         }
 
@@ -201,10 +188,8 @@ impl PostgreSQL {
         let (version, bytes) = { get_archive(&self.version).await? };
 
         self.version = version;
-        self.status = Status::Installing;
         create_dir_all(&self.settings.installation_dir)?;
         extract(&bytes, &self.settings.installation_dir).await?;
-        self.status = Status::Installed;
 
         debug!(
             "Installed PostgreSQL version {} to {}",
@@ -236,18 +221,15 @@ impl PostgreSQL {
             .username(&self.settings.username)
             .encoding("UTF8");
 
-        self.status = Status::Initializing;
         match self.execute_command(initdb).await {
             Ok((_stdout, _stderr)) => {
-                self.status = Status::Stopped;
                 debug!(
                     "Initialized database {}",
                     self.settings.data_dir.to_string_lossy()
                 );
                 Ok(())
             }
             Err(error) => {
-                self.update_status();
                 Err(DatabaseInitializationError(error.into()))
             }
         }
@@ -276,10 +258,8 @@ impl PostgreSQL {
             .options(options)
             .wait();
 
-        self.status = Status::Starting;
         match self.execute_command(pg_ctl).await {
             Ok((_stdout, _stderr)) => {
-                self.status = Status::Started;
                 debug!(
                     "Started database {} on port {}",
                     self.settings.data_dir.to_string_lossy(),
@@ -288,14 +268,13 @@ impl PostgreSQL {
                 Ok(())
             }
             Err(error) => {
-                self.update_status();
                 Err(DatabaseStartError(error.into()))
             }
         }
     }
 
     /// Stop the database gracefully (smart mode) and wait for the shutdown to complete.
-    pub async fn stop(&mut self) -> Result<()> {
+    pub async fn stop(&self) -> Result<()> {
         debug!(
             "Stopping database {}",
             self.settings.data_dir.to_string_lossy()
@@ -307,25 +286,22 @@ impl PostgreSQL {
             .shutdown_mode(Fast)
             .wait();
 
-        self.status = Status::Stopping;
         match self.execute_command(pg_ctl).await {
             Ok((_stdout, _stderr)) => {
-                self.status = Status::Stopped;
                 debug!(
                     "Stopped database {}",
                     self.settings.data_dir.to_string_lossy()
                 );
                 Ok(())
             }
             Err(error) => {
-                self.update_status();
                 Err(DatabaseStopError(error.into()))
             }
         }
     }
 
     /// Create a new database with the given name.
-    pub async fn create_database<S: AsRef<str>>(&mut self, database_name: S) -> Result<()> {
+    pub async fn create_database<S: AsRef<str>>(&self, database_name: S) -> Result<()> {
         debug!(
             "Creating database {} for {}:{}",
             database_name.as_ref(),
@@ -358,7 +334,7 @@ impl PostgreSQL {
     }
 
     /// Check if a database with the given name exists.
-    pub async fn database_exists<S: AsRef<str>>(&mut self, database_name: S) -> Result<bool> {
+    pub async fn database_exists<S: AsRef<str>>(&self, database_name: S) -> Result<bool> {
         debug!(
             "Checking if database {} exists for {}:{}",
             database_name.as_ref(),
@@ -389,7 +365,7 @@ impl PostgreSQL {
     }
 
     /// Drop a database with the given name.
-    pub async fn drop_database<S: AsRef<str>>(&mut self, database_name: S) -> Result<()> {
+    pub async fn drop_database<S: AsRef<str>>(&self, database_name: S) -> Result<()> {
         debug!(
             "Dropping database {} for {}:{}",
             database_name.as_ref(),
@@ -457,7 +433,7 @@ impl Default for PostgreSQL {
 /// Stop the PostgreSQL server and remove the data directory if it is marked as temporary.
 impl Drop for PostgreSQL {
     fn drop(&mut self) {
-        if self.status == Status::Starting || self.status == Status::Started {
+        if self.status() == Status::Started {
             let mut pg_ctl = PgCtlBuilder::new()
                 .program_dir(self.settings.binary_dir())
                 .mode(Stop)