Make nix.conf changes deterministic (#620)

* Make nix.conf changes deterministic

* Add mac fixture

* Warn/error if user settings don't match our needs

* Repair mac fixture

* fmt

* clipster

* Tidy up some feedback

* fmt

* resolve some nits

Cargo.toml

@@ -56,7 +56,6 @@ uuid = { version = "1.2.2", features = ["serde"] }
 os-release = { version = "0.1.0", default-features = false }
 is_ci = { version = "1.1.1", default-features = false, optional = true }
 strum = { version = "0.25.0", features = ["derive"] }
-nix-config-parser = { version = "0.1.2", features = ["serde"] }
 which = "4.4.0"
 sysctl = "0.5.4"
 walkdir = "2.3.3"

src/action/base/create_file.rs

@@ -27,7 +27,7 @@ pub struct CreateFile {
     group: Option<String>,
     mode: Option<u32>,
     buf: String,
-    force: bool,
+    replace: bool,
 }
 
 impl CreateFile {
@@ -38,7 +38,7 @@ impl CreateFile {
         group: impl Into<Option<String>>,
         mode: impl Into<Option<u32>>,
         buf: String,
-        force: bool,
+        replace: bool,
     ) -> Result<StatefulAction<Self>, ActionError> {
         let path = path.as_ref().to_path_buf();
         let mode = mode.into();
@@ -50,7 +50,7 @@ impl CreateFile {
             group,
             mode,
             buf,
-            force,
+            replace,
         };
 
         if this.path.exists() {
@@ -128,7 +128,7 @@ impl CreateFile {
                 .map_err(|e| ActionErrorKind::Read(this.path.clone(), e))
                 .map_err(Self::error)?;
 
-            if discovered_buf != this.buf {
+            if discovered_buf != this.buf && !this.replace {
                 return Err(Self::error(ActionErrorKind::DifferentContent(
                     this.path.clone(),
                 )));
@@ -183,7 +183,8 @@ impl Action for CreateFile {
             group,
             mode,
             buf,
-            force: _,
+            // If `replace` was not set, and the file existed, the `plan` step would have errored
+            replace: _,
         } = self;
 
         if tracing::enabled!(tracing::Level::TRACE) {
@@ -247,7 +248,7 @@ impl Action for CreateFile {
             group: _,
             mode: _,
             buf: _,
-            force: _,
+            replace: _,
         } = &self;
 
         vec![ActionDescription::new(
@@ -264,7 +265,7 @@ impl Action for CreateFile {
             group: _,
             mode: _,
             buf: _,
-            force: _,
+            replace: _,
         } = self;
         // The user already deleted it
         if !path.exists() {

src/action/base/create_or_insert_into_file.rs

@@ -19,6 +19,10 @@ use tracing::{span, Span};
 pub enum Position {
     Beginning,
     End,
+    Before {
+        index: usize,
+        expected_content: String,
+    },
 }
 
 /** Create a file at the given location with the provided `buf` as
@@ -140,6 +144,20 @@ impl CreateOrInsertIntoFile {
                 return Ok(StatefulAction::completed(this));
             }
 
+            if let Position::Before {
+                index,
+                expected_content,
+            } = &this.position
+            {
+                if discovered_buf.lines().nth(*index) != Some(expected_content.as_str()) {
+                    return Err(ActionErrorKind::DifferentLineContent(
+                        this.path.clone(),
+                        this.position.clone(),
+                    ))
+                    .map_err(Self::error);
+                }
+            }
+
             // If not, we can't skip this, so we still do it
         }
 
@@ -221,33 +239,75 @@ impl Action for CreateOrInsertIntoFile {
                 ActionErrorKind::Open(temp_file_path.clone(), e)
             }).map_err(Self::error)?;
 
-        if *position == Position::End {
-            if let Some(ref mut orig_file) = orig_file {
-                tokio::io::copy(orig_file, &mut temp_file)
+        match position {
+            Position::End => {
+                if let Some(ref mut orig_file) = orig_file {
+                    tokio::io::copy(orig_file, &mut temp_file)
+                        .await
+                        .map_err(|e| {
+                            ActionErrorKind::Copy(path.to_owned(), temp_file_path.to_owned(), e)
+                        })
+                        .map_err(Self::error)?;
+                }
+
+                temp_file
+                    .write_all(buf.as_bytes())
                     .await
-                    .map_err(|e| {
-                        ActionErrorKind::Copy(path.to_owned(), temp_file_path.to_owned(), e)
-                    })
+                    .map_err(|e| ActionErrorKind::Write(temp_file_path.clone(), e))
+                    .map_err(Self::error)?;
+            },
+            Position::Beginning => {
+                temp_file
+                    .write_all(buf.as_bytes())
+                    .await
+                    .map_err(|e| ActionErrorKind::Write(temp_file_path.clone(), e))
                     .map_err(Self::error)?;
-            }
-        }
 
-        temp_file
-            .write_all(buf.as_bytes())
-            .await
-            .map_err(|e| ActionErrorKind::Write(temp_file_path.clone(), e))
-            .map_err(Self::error)?;
+                if let Some(ref mut orig_file) = orig_file {
+                    tokio::io::copy(orig_file, &mut temp_file)
+                        .await
+                        .map_err(|e| {
+                            ActionErrorKind::Copy(path.to_owned(), temp_file_path.to_owned(), e)
+                        })
+                        .map_err(Self::error)?;
+                }
+            },
+            Position::Before {
+                index,
+                expected_content,
+            } => {
+                let mut original_content_buf = Vec::new();
+                if let Some(ref mut orig_file) = orig_file {
+                    tokio::io::copy(orig_file, &mut original_content_buf)
+                        .await
+                        .map_err(|e| {
+                            ActionErrorKind::Copy(path.to_owned(), temp_file_path.to_owned(), e)
+                        })
+                        .map_err(Self::error)?;
+                }
+                let original_content = String::from_utf8(original_content_buf)
+                    .map_err(ActionErrorKind::FromUtf8)
+                    .map_err(Self::error)?;
+                let mut original_content_lines = original_content.lines().collect::<Vec<_>>();
+                // The last line should match expected
+                if original_content_lines.get(*index).copied() != Some(expected_content.as_str()) {
+                    return Err(ActionErrorKind::DifferentLineContent(
+                        path.clone(),
+                        position.clone(),
+                    ))
+                    .map_err(Self::error);
+                }
+
+                original_content_lines.insert(*index, buf);
+                let new_content = original_content_lines.join("\n");
 
-        if *position == Position::Beginning {
-            if let Some(ref mut orig_file) = orig_file {
-                tokio::io::copy(orig_file, &mut temp_file)
+                temp_file
+                    .write_all(new_content.as_bytes())
                     .await
-                    .map_err(|e| {
-                        ActionErrorKind::Copy(path.to_owned(), temp_file_path.to_owned(), e)
-                    })
+                    .map_err(|e| ActionErrorKind::Write(temp_file_path.clone(), e))
                     .map_err(Self::error)?;
-            }
-        }
+            },
+        };
 
         let gid = if let Some(group) = group {
             Some(