fix: flush data for write on fs crate (#2092)

* fix: flush data for write on fs crate

* flush on e2e runner

Author: gsanchezgavier

agent-control/src/cli/on_host/config_gen.rs

@@ -10,6 +10,7 @@ use crate::cli::{
         proxy_config::ProxyConfig,
     },
 };
+use fs::file::{LocalFile, writer::FileWriter};
 use std::{collections::HashMap, path::PathBuf};
 use tracing::info;
 
@@ -154,7 +155,7 @@ fn write_config_and_generate_system_identity(args: &Args) -> Result<(), CliError
 
     let yaml = generate_config_and_system_identity(args, provide_identity)?;
 
-    std::fs::write(&args.output_path, yaml).map_err(|err| {
+    LocalFile.write(&args.output_path, yaml).map_err(|err| {
         CliError::Command(format!(
             "error writing the configuration file to '{}': {}",
             args.output_path.to_string_lossy(),
@@ -176,13 +177,14 @@ fn write_env_var_config(args: &Args) -> Result<(), CliError> {
 
     let yaml = generate_env_var_config(args)?;
 
-    std::fs::write(path, yaml).map_err(|err| {
+    LocalFile.write(path, yaml).map_err(|err| {
         CliError::Command(format!(
             "error writing the environment variables file to '{}': {}",
             path.display(),
             err
         ))
     })?;
+
     info!(env_vars_path=%path.display(), "Environment variables file generated successfully");
 
     Ok(())
@@ -215,7 +217,7 @@ fn generate_env_var_config(args: &Args) -> Result<String, CliError> {
 fn generate_config_and_system_identity<F>(
     args: &Args,
     provide_identity_fn: F,
-) -> Result<Vec<u8>, CliError>
+) -> Result<String, CliError>
 where
     F: Fn(&Args) -> Result<Identity, CliError>,
 {
@@ -249,10 +251,8 @@ where
         agents: args.agent_set.into(),
     };
 
-    let mut buffer = Vec::new();
-    serde_yaml::to_writer(&mut buffer, &config)
-        .map_err(|err| CliError::Command(format!("failed to serialize configuration: {err}")))?;
-    Ok(buffer)
+    serde_yaml::to_string(&config)
+        .map_err(|err| CliError::Command(format!("failed to serialize configuration: {err}")))
 }
 
 #[cfg(test)]
@@ -375,11 +375,8 @@ mod tests {
     ) {
         let args = create_test_args(fleet_enabled, region, agent_set, proxy_config);
 
-        let yaml = String::from_utf8(
-            generate_config_and_system_identity(&args, identity_provider_mock)
-                .expect("result expected to be OK"),
-        )
-        .unwrap();
+        let yaml = generate_config_and_system_identity(&args, identity_provider_mock)
+            .expect("result expected to be OK");
 
         // Check that the config can be used in Agent Control
         let _: AgentControlConfig =

agent-control/src/cli/on_host/host_monitoring_gen/otel_config_gen.rs

@@ -4,6 +4,8 @@ use crate::agent_control::defaults::{
 };
 use crate::cli::error::CliError;
 use crate::on_host::file_store::build_config_name;
+use fs::file::LocalFile;
+use fs::file::writer::FileWriter;
 use std::path::PathBuf;
 use tracing::info;
 
@@ -65,8 +67,10 @@ impl OtelConfigGen {
             .collect::<Vec<_>>()
             .join("\n");
 
-        std::fs::write(file_path, modified_content)
+        LocalFile
+            .write(&file_path, modified_content)
             .map_err(|err| CliError::Command(format!("error writing otel values file: {err}")))?;
+
         Ok(())
     }
 }

agent-control/tests/on_host/tools/config.rs

@@ -1,8 +1,9 @@
-use std::fs::{File, create_dir_all};
-use std::io::Write;
+use std::fs::create_dir_all;
 use std::path::PathBuf;
 use std::sync::Arc;
 
+use fs::file::LocalFile;
+use fs::file::writer::FileWriter;
 use newrelic_agent_control::agent_control::agent_id::AgentID;
 use newrelic_agent_control::agent_control::defaults::{
     AGENT_CONTROL_ID, FOLDER_NAME_FLEET_DATA, FOLDER_NAME_LOCAL_DATA, STORE_KEY_LOCAL_DATA_CONFIG,
@@ -67,8 +68,9 @@ agents: {}
 pub fn create_file(content: String, path: PathBuf) {
     create_dir_all(path.parent().unwrap()).unwrap();
 
-    let mut local_file = File::create(path).expect("failed to create local config file");
-    write!(local_file, "{content}").unwrap();
+    LocalFile
+        .write(&path, content)
+        .expect("failed to create file");
 }
 
 /// Creates local values config for the agent_id provided on the base_dir

agent-control/tests/on_host/tools/custom_agent_type.rs

@@ -1,8 +1,8 @@
 use std::fmt::Display;
-use std::fs::File;
-use std::io::Write;
 use std::path::PathBuf;
 
+use fs::file::LocalFile;
+use fs::file::writer::FileWriter;
 use newrelic_agent_control::agent_control::run::on_host::AGENT_CONTROL_MODE_ON_HOST;
 use newrelic_agent_control::agent_type::agent_type_id::AgentTypeID;
 use newrelic_agent_control::agent_type::definition::AgentTypeDefinition;
@@ -232,9 +232,9 @@ regex: \d+\.\d+\.\d+
         );
 
         std::fs::create_dir_all(agent_type_file_path.parent().unwrap()).unwrap();
-        let mut local_file =
-            File::create(agent_type_file_path.clone()).expect("failed to create local config file");
-        write!(local_file, "{self}").expect("failed to write custom agent type");
+        LocalFile
+            .write(&agent_type_file_path, self.to_string())
+            .expect("failed to write custom agent type");
         self.agent_type_id.to_string()
     }
 }

fs/src/file/writer.rs

@@ -27,12 +27,14 @@ impl FileWriter for LocalFile {
             file_options.mode(LocalFile::get_file_permissions().mode());
         }
 
-        file_options.open(path)?.write_all(content.as_bytes())?;
+        let mut file = file_options.open(path)?;
+        file.write_all(content.as_bytes())?;
 
         #[cfg(target_family = "windows")]
         crate::win_permissions::set_file_permissions_for_administrator(path)
             .map_err(io::Error::other)?;
 
+        file.sync_all()?;
         Ok(())
     }
 }

test/e2e-runner/src/linux/scenarios/migration.rs

@@ -1,4 +1,4 @@
-use std::{fs, time::Duration};
+use std::time::Duration;
 
 use tracing::{debug, info};
 
@@ -9,7 +9,7 @@ use crate::{
         install::{Args, RecipeData, install_agent_control_from_recipe},
         service,
     },
-    tools::{config, nrql, test::retry},
+    tools::{config, file::write, nrql, test::retry},
 };
 
 pub fn test_migration(args: Args) {
@@ -90,7 +90,7 @@ curl -Ls https://download.newrelic.com/install/newrelic-cli/scripts/install.sh |
     debug!("Output:\n{output}");
 
     // Update infra-agent configuration
-    fs::write(
+    write(
         "/etc/newrelic-infra.yml",
         format!(
             r#"
@@ -101,10 +101,7 @@ license_key: {}
     "#,
             args.nr_license_key
         ),
-    )
-    .unwrap_or_else(|err| {
-        panic!("Error updating infra-agent config: {err}");
-    });
+    );
 
     // Run a mysql service and install the nri-mysql integration
     let docker_command =
@@ -120,7 +117,7 @@ license_key: {}
         panic!("Could not install nri-mysql: {err}");
     });
 
-    fs::write(
+    write(
         "/etc/newrelic-infra/integrations.d/nri-mysql-config.yml",
         format!(
             r#"
@@ -139,10 +136,7 @@ integrations:
     inventory_source: config/mysql
 "#
         ),
-    )
-    .unwrap_or_else(|err| {
-        panic!("Error writing nri-mysql config: {err}");
-    });
+    );
 
     service::restart_service("newrelic-infra");
 }

test/e2e-runner/src/tools.rs

@@ -5,6 +5,7 @@ use tracing::warn;
 use crate::tools::test::TestResult;
 
 pub mod config;
+pub mod file;
 pub mod logs;
 pub mod nrql;
 pub mod test;

test/e2e-runner/src/tools/config.rs

@@ -1,7 +1,9 @@
 use serde_yaml::Value;
-use std::{fs, io::Write, path::PathBuf, thread, time::Duration};
+use std::{fs, io::Write, path::PathBuf};
 use tracing::info;
 
+use crate::tools::file::write;
+
 pub const LOCAL_CONFIG_FILE_NAME: &str = "local_config.yaml";
 
 /// Updates the agent control config in `config_path` to include the content specified in `new_content`
@@ -31,12 +33,7 @@ pub fn update_config(config_path: &str, new_content: &str) {
 
     info!("Updating configuration to: \n---\n{}\n---", updated_content);
 
-    fs::write(config_path, updated_content).unwrap_or_else(|e| {
-        panic!("failed to write YAML configuration: {}", e);
-    });
-
-    // Wait a few seconds to prevent doing anything before the configuration is written
-    thread::sleep(Duration::from_secs(3));
+    write(config_path, updated_content);
 }
 
 /// Merges two YAML values, with `new` taking precedence over `base`
@@ -77,11 +74,7 @@ pub fn write_agent_local_config(config_dir: &str, content: String) {
     fs::create_dir_all(&path).unwrap_or_else(|err| {
         panic!("Error creating local config: {err}");
     });
-    fs::write(path.join(LOCAL_CONFIG_FILE_NAME), content).unwrap_or_else(|err| {
-        panic!("Error writing local config: {err}");
-    });
-    // Wait a few seconds to prevent doing anything before the configuration is written
-    thread::sleep(Duration::from_secs(3));
+    write(path.join(LOCAL_CONFIG_FILE_NAME), content);
 }
 
 /// Replaces all the occurrences of `old` to `new` in the provided `config_path`.
@@ -91,12 +84,7 @@ pub fn replace_string_in_file(config_path: &str, old: &str, new: &str) {
 
     let updated_content = config_content.replace(old, new);
 
-    fs::write(config_path, updated_content).unwrap_or_else(|err| {
-        panic!("Error writing to {config_path}: {err}");
-    });
-
-    // Wait a few seconds to prevent doing anything before the configuration is written
-    thread::sleep(Duration::from_secs(3));
+    write(config_path, updated_content);
 }
 
 /// Appends `content` to the configuration file in `config_path`
@@ -110,6 +98,7 @@ pub fn append_to_config_file(config_path: &str, content: &str) {
     writeln!(config_file, "{content}").unwrap_or_else(|err| {
         panic!("Error appending content to '{config_path}' file: {err}");
     });
-    // Wait a few seconds to prevent doing anything before the configuration is written
-    thread::sleep(Duration::from_secs(3));
+    config_file.sync_data().unwrap_or_else(|err| {
+        panic!("Error syncing data to disk for '{config_path}' file: {err}");
+    });
 }

test/e2e-runner/src/tools/file.rs

@@ -0,0 +1,32 @@
+use std::fs::OpenOptions;
+use std::io::Write;
+use std::path::Path;
+
+/// Writes contents to a file and ensures data is flushed to disk before returning.
+/// If the file does not exist, it will be created. If it does exist, it will be truncated.
+pub fn write<P: AsRef<Path>, C: AsRef<[u8]>>(path: P, contents: C) {
+    let mut file_options = OpenOptions::new();
+    file_options.write(true).create(true).truncate(true);
+
+    let mut file = file_options.open(path.as_ref()).unwrap_or_else(|err| {
+        panic!(
+            "Could not open file for writing: {}: {}",
+            path.as_ref().display(),
+            err
+        )
+    });
+    file.write_all(contents.as_ref()).unwrap_or_else(|err| {
+        panic!(
+            "Could not write to file: {}: {}",
+            path.as_ref().display(),
+            err
+        )
+    });
+    file.sync_data().unwrap_or_else(|err| {
+        panic!(
+            "Could not sync data to disk for file: {}: {}",
+            path.as_ref().display(),
+            err
+        )
+    });
+}

test/e2e-runner/src/windows/install.rs

@@ -1,10 +1,10 @@
-use std::{fs, path::PathBuf, process::Command, time::Duration};
+use std::{path::PathBuf, process::Command, time::Duration};
 
 use tempfile::tempdir;
 use tracing::{debug, info};
 
 use crate::{
-    tools::test::retry,
+    tools::{file::write, test::retry},
     windows::powershell::{exec_powershell_cmd, exec_powershell_command},
 };
 
@@ -179,8 +179,7 @@ $env:NEW_RELIC_AGENT_CONTROL_SKIP_BINARY_SIGNATURE_VALIDATION='true'; `
     debug!("Install script content: \n{install_command}");
     let script_dir = tempdir().expect("failed to create temp dir for script");
     let script_path = script_dir.path().join("install_command.ps1");
-    fs::write(&script_path, &install_command)
-        .unwrap_or_else(|err| panic!("failed to write install script: {err}"));
+    write(&script_path, &install_command);
 
     info!("Executing install script to install Agent Control through the recipe");
     let output = retry(3, Duration::from_secs(30), "recipe installation", || {