Add options to run the cluster in a faster but less safe mode

These are `--faster-but-less-safe` and `--safer-but-slower` flags, available at
present only to the `shell` subcommand.

Author: allenap

src/cli.rs

@@ -16,6 +16,9 @@ pub enum Commands {
     /// Start a psql shell, creating and starting the cluster as necessary.
     #[clap(display_order = 1)]
     Shell {
+        #[clap(flatten)]
+        cluster: ClusterArgs,
+
         #[clap(flatten)]
         database: DatabaseArgs,
 
@@ -27,6 +30,9 @@ pub enum Commands {
     /// necessary.
     #[clap(display_order = 2)]
     Exec {
+        #[clap(flatten)]
+        cluster: ClusterArgs,
+
         #[clap(flatten)]
         database: DatabaseArgs,
 
@@ -50,7 +56,7 @@ pub enum Commands {
 }
 
 #[derive(Args)]
-pub struct DatabaseArgs {
+pub struct ClusterArgs {
     /// The directory in which to place, or find, the cluster.
     #[clap(
         short = 'D',
@@ -62,6 +68,43 @@ pub struct DatabaseArgs {
     )]
     pub dir: PathBuf,
 
+    /// Run the cluster in a "faster" mode.
+    ///
+    /// This disables `fsync` and `full_page_writes` in the cluster. This can
+    /// make the cluster faster but it can also lead to unrecoverable data
+    /// corruption in the event of a power failure or system crash. Useful for
+    /// tests, for example, but probably not production.
+    ///
+    /// In the future this may make additional or different changes. See
+    /// https://www.postgresql.org/docs/16/runtime-config-wal.html for more
+    /// information.
+    ///
+    /// This option is STICKY. Once you've used it, the cluster will be
+    /// configured to be "faster but less safe" and you do not need to specify
+    /// it again. To find out if the cluster is running in this mode, open a
+    /// `psql` shell (e.g. `postgresfixture shell`) and run `SHOW fsync;` and
+    /// `SHOW full_page_writes;`.
+    #[clap(long = "faster-but-less-safe", action = clap::ArgAction::SetTrue, default_value_t = false, display_order = 2)]
+    pub faster: bool,
+
+    /// Run the cluster in a "safer" mode.
+    ///
+    /// This is the opposite of `--faster-but-less-safe`, i.e. it runs with
+    /// `fsync` and `full_page_writes` enabled in the cluster. This is the
+    /// default when neither `--faster-but-less-safe` nor `--safe-but-slower`
+    /// have been specified.
+    ///
+    /// This option is STICKY. Once you've used it, the cluster will be
+    /// configured to be "slower and safer" and you do not need to specify it
+    /// again. To find out if the cluster is running in this mode, open a `psql`
+    /// shell (e.g. `postgresfixture shell`) and run `SHOW fsync;` and `SHOW
+    /// full_page_writes;`.
+    #[clap(long = "slower-but-safer", action = clap::ArgAction::SetTrue, default_value_t = false, display_order = 3, conflicts_with = "faster")]
+    pub slower: bool,
+}
+
+#[derive(Args)]
+pub struct DatabaseArgs {
     /// The database to connect to.
     #[clap(
         short = 'd',
@@ -73,6 +116,7 @@ pub struct DatabaseArgs {
     )]
     pub name: String,
 }
+
 #[derive(Args)]
 pub struct LifecycleArgs {
     /// Destroy the cluster after use. WARNING: This will DELETE THE DATA

src/coordinate.rs

@@ -12,7 +12,7 @@
 //! let cluster = cluster::Cluster::new(&data_dir, runtime);
 //! let lock_file = cluster_dir.path().join("lock");
 //! let lock = lock::UnlockedFile::try_from(lock_file.as_path()).unwrap();
-//! assert!(coordinate::run_and_stop(&cluster, lock, || cluster.exists()).unwrap())
+//! assert!(coordinate::run_and_stop(&cluster, lock, |_| Ok(()), |cluster| cluster.exists()).unwrap())
 //! ```
 
 use std::time::Duration;
@@ -30,16 +30,18 @@ use crate::lock;
 /// (maybe) stops the cluster again, and finally returns the result of `action`.
 /// If there are other users of the cluster – i.e. if an exclusive lock cannot
 /// be acquired during the shutdown phase – then the cluster is left running.
-pub fn run_and_stop<F, T>(
-    cluster: &Cluster,
+pub fn run_and_stop<'a, INIT, ACTION, T>(
+    cluster: &'a Cluster,
     lock: lock::UnlockedFile,
-    action: F,
+    initialise: INIT,
+    action: ACTION,
 ) -> Result<T, ClusterError>
 where
-    F: std::panic::UnwindSafe + FnOnce() -> T,
+    INIT: std::panic::UnwindSafe + FnOnce(&'a Cluster) -> Result<(), ClusterError>,
+    ACTION: std::panic::UnwindSafe + FnOnce(&'a Cluster) -> T,
 {
-    let lock = startup(cluster, lock)?;
-    let action_res = std::panic::catch_unwind(action);
+    let lock = startup(cluster, lock, initialise)?;
+    let action_res = std::panic::catch_unwind(|| action(cluster));
     let _: Option<bool> = shutdown(cluster, lock, |cluster| cluster.stop())?;
     match action_res {
         Ok(result) => Ok(result),
@@ -54,27 +56,33 @@ where
 /// returning. If there are other users of the cluster – i.e. if an exclusive
 /// lock cannot be acquired during the shutdown phase – then the cluster is left
 /// running and is **not** destroyed.
-pub fn run_and_destroy<F, T>(
-    cluster: &Cluster,
+pub fn run_and_destroy<'a, INIT, ACTION, T>(
+    cluster: &'a Cluster,
     lock: lock::UnlockedFile,
-    action: F,
+    initialise: INIT,
+    action: ACTION,
 ) -> Result<T, ClusterError>
 where
-    F: std::panic::UnwindSafe + FnOnce() -> T,
+    INIT: std::panic::UnwindSafe + FnOnce(&'a Cluster) -> Result<(), ClusterError>,
+    ACTION: std::panic::UnwindSafe + FnOnce(&'a Cluster) -> T,
 {
-    let lock = startup(cluster, lock)?;
-    let action_res = std::panic::catch_unwind(action);
+    let lock = startup(cluster, lock, initialise)?;
+    let action_res = std::panic::catch_unwind(|| action(cluster));
     let shutdown_res = shutdown(cluster, lock, |cluster| cluster.destroy());
     match action_res {
         Ok(result) => shutdown_res.map(|_| result),
         Err(err) => std::panic::resume_unwind(err),
     }
 }
 
-fn startup(
-    cluster: &Cluster,
+fn startup<'a, INIT>(
+    cluster: &'a Cluster,
     mut lock: lock::UnlockedFile,
-) -> Result<lock::LockedFileShared, ClusterError> {
+    initialise: INIT,
+) -> Result<lock::LockedFileShared, ClusterError>
+where
+    INIT: std::panic::UnwindSafe + FnOnce(&'a Cluster) -> Result<(), ClusterError>,
+{
     loop {
         lock = match lock.try_lock_exclusive() {
             Ok(Left(lock)) => {
@@ -85,6 +93,8 @@ fn startup(
                 // exclusive lock, so we must check if the cluster is
                 // running _now_, else loop back to the top again.
                 if cluster.running()? {
+                    // Perform post-start initialisation.
+                    initialise(cluster)?;
                     return Ok(lock);
                 } else {
                     // Release all locks then sleep for a random time between
@@ -101,7 +111,9 @@ fn startup(
                 }
             }
             Ok(Right(lock)) => {
-                // We have an exclusive lock, so try to start the cluster.
+                // We have an exclusive lock. Perform pre-start initialisation.
+                initialise(cluster)?;
+                // Now try to start the cluster.
                 cluster.start()?;
                 // Once started, downgrade to a shared log.
                 return Ok(lock.lock_shared()?);

src/main.rs

@@ -18,27 +18,79 @@ fn main() -> Result<()> {
     let cli = cli::Cli::parse();
     let result = match cli.command {
         cli::Commands::Shell {
+            cluster:
+                cli::ClusterArgs {
+                    dir,
+                    faster,
+                    slower,
+                },
             database,
             lifecycle,
-        } => run(database.dir, &database.name, lifecycle.destroy, |cluster| {
-            check_exit(
-                cluster
-                    .shell(&database.name)
-                    .wrap_err("Starting PostgreSQL shell in cluster failed")?,
+        } => {
+            run(
+                dir,
+                &database.name,
+                lifecycle.destroy,
+                |cluster| match (cluster.running()?, faster, slower) {
+                    // No change to go faster or slower, so do nothing.
+                    (_, false, false) => Ok(()),
+                    // Request to go faster; cluster is running.
+                    (true, true, _) => {
+                        let mut conn = cluster.connect("template1")?;
+                        conn.execute("ALTER SYSTEM SET fsync = 'off'", &[])?;
+                        conn.execute("ALTER SYSTEM SET full_page_writes = 'off'", &[])?;
+                        Ok(())
+                    }
+                    // Request to go slower; cluster is running.
+                    (true, _, true) => {
+                        let mut conn = cluster.connect("template1")?;
+                        conn.execute("ALTER SYSTEM SET fsync = 'on'", &[])?;
+                        conn.execute("ALTER SYSTEM SET full_page_writes = 'on'", &[])?;
+                        Ok(())
+                    }
+                    // Request to go faster; cluster is NOT running.
+                    (false, true, _) => cluster
+                        .single(&[
+                            "ALTER SYSTEM SET fsync = 'off'",
+                            "ALTER SYSTEM SET full_page_writes = 'off'",
+                        ])
+                        .map(|_output| ()),
+                    // Request to go slower; cluster is NOT running.
+                    (false, _, true) => cluster
+                        .single(&[
+                            "ALTER SYSTEM SET fsync = 'on'",
+                            "ALTER SYSTEM SET full_page_writes = 'on'",
+                        ])
+                        .map(|_output| ()),
+                },
+                |cluster| {
+                    check_exit(
+                        cluster
+                            .shell(&database.name)
+                            .wrap_err("Starting PostgreSQL shell in cluster failed")?,
+                    )
+                },
             )
-        }),
+        }
         cli::Commands::Exec {
+            cluster,
             database,
             command,
             args,
             lifecycle,
-        } => run(database.dir, &database.name, lifecycle.destroy, |cluster| {
-            check_exit(
-                cluster
-                    .exec(&database.name, command, &args)
-                    .wrap_err("Executing command in cluster failed")?,
-            )
-        }),
+        } => run(
+            cluster.dir,
+            &database.name,
+            lifecycle.destroy,
+            |_cluster| Ok(()),
+            |cluster| {
+                check_exit(
+                    cluster
+                        .exec(&database.name, command, &args)
+                        .wrap_err("Executing command in cluster failed")?,
+                )
+            },
+        ),
         cli::Commands::Runtimes => {
             let runtimes_on_path = runtime::Runtime::find_on_path();
 
@@ -83,9 +135,16 @@ fn check_exit(status: ExitStatus) -> Result<i32> {
 
 const UUID_NS: uuid::Uuid = uuid::Uuid::from_u128(93875103436633470414348750305797058811);
 
-fn run<F>(database_dir: PathBuf, database_name: &str, destroy: bool, action: F) -> Result<i32>
+fn run<INIT, ACTION>(
+    database_dir: PathBuf,
+    database_name: &str,
+    destroy: bool,
+    initialise: INIT,
+    action: ACTION,
+) -> Result<i32>
 where
-    F: FnOnce(&cluster::Cluster) -> Result<i32> + std::panic::UnwindSafe,
+    INIT: std::panic::UnwindSafe + FnOnce(&cluster::Cluster) -> Result<(), cluster::ClusterError>,
+    ACTION: FnOnce(&cluster::Cluster) -> Result<i32> + std::panic::UnwindSafe,
 {
     // Create the cluster directory first.
     match fs::create_dir(&database_dir) {
@@ -119,7 +178,7 @@ where
         coordinate::run_and_stop
     };
 
-    runner(&cluster, lock, || {
+    runner(&cluster, lock, initialise, |cluster: &cluster::Cluster| {
         if !cluster
             .databases()
             .wrap_err("Could not list databases")?
@@ -137,6 +196,6 @@ where
         ctrlc::set_handler(|| ()).wrap_err("Could not set signal handler")?;
 
         // Finally, run the given action.
-        action(&cluster)
+        action(cluster)
     })?
 }