[Aptos Node] Improve error messages for config file loading.

Author: JoshLind

aptos-node/src/lib.rs

@@ -133,17 +133,26 @@ impl AptosNodeArgs {
             )
             .expect("Test mode should start correctly");
         } else {
-            // Load the config file
+            // Get the config file path
             let config_path = self.config.expect("Config is required to launch node");
+            if !config_path.exists() {
+                panic!(
+                    "The node config file could not be found! Ensure the given path is correct: {:?}",
+                    config_path.display()
+                )
+            }
+
+            // A config file exists, attempt to parse the config
             let config = NodeConfig::load(config_path.clone()).unwrap_or_else(|error| {
                 panic!(
-                    "Failed to load node config file! Given file path: {:?}. Error: {:?}",
-                    config_path, error
+                    "Failed to parse node config file! Given file path: {:?}. Error: {:?}",
+                    config_path.display(),
+                    error
                 )
             });
-            println!("Using node config {:?}", &config);
 
             // Start the node
+            println!("Using node config {:?}", &config);
             start(config, None).expect("Node should start correctly");
         };
     }

config/src/config/error.rs

@@ -15,6 +15,8 @@ pub enum Error {
     Yaml(String, #[source] serde_yaml::Error),
     #[error("Config is missing expected value: {0}")]
     Missing(&'static str),
+    #[error("Unexpected error: {0}")]
+    Unexpected(String),
 }
 
 pub fn invariant(cond: bool, msg: String) -> Result<(), Error> {

config/src/config/execution_config.rs

@@ -56,13 +56,41 @@ impl Default for ExecutionConfig {
 impl ExecutionConfig {
     pub fn load(&mut self, root_dir: &RootPath) -> Result<(), Error> {
         if !self.genesis_file_location.as_os_str().is_empty() {
-            let path = root_dir.full_path(&self.genesis_file_location);
-            let mut file = File::open(&path).map_err(|e| Error::IO("genesis".into(), e))?;
+            // Ensure the genesis file exists
+            let genesis_path = root_dir.full_path(&self.genesis_file_location);
+            if !genesis_path.exists() {
+                return Err(Error::Unexpected(format!(
+                    "The genesis file could not be found! Ensure the given path is correct: {:?}",
+                    genesis_path.display()
+                )));
+            }
+
+            // Open the genesis file and read the bytes
+            let mut file = File::open(&genesis_path).map_err(|error| {
+                Error::Unexpected(format!(
+                    "Failed to open the genesis file: {:?}. Error: {:?}",
+                    genesis_path.display(),
+                    error
+                ))
+            })?;
             let mut buffer = vec![];
-            file.read_to_end(&mut buffer)
-                .map_err(|e| Error::IO("genesis".into(), e))?;
-            let data = bcs::from_bytes(&buffer).map_err(|e| Error::BCS("genesis", e))?;
-            self.genesis = Some(data);
+            file.read_to_end(&mut buffer).map_err(|error| {
+                Error::Unexpected(format!(
+                    "Failed to read the genesis file into a buffer: {:?}. Error: {:?}",
+                    genesis_path.display(),
+                    error
+                ))
+            })?;
+
+            // Deserialize the genesis file and store it
+            let genesis = bcs::from_bytes(&buffer).map_err(|error| {
+                Error::Unexpected(format!(
+                    "Failed to BCS deserialize the genesis file: {:?}. Error: {:?}",
+                    genesis_path.display(),
+                    error
+                ))
+            })?;
+            self.genesis = Some(genesis);
         }
 
         Ok(())

config/src/config/mod.rs

@@ -132,13 +132,27 @@ impl WaypointConfig {
     pub fn waypoint(&self) -> Waypoint {
         let waypoint = match &self {
             WaypointConfig::FromConfig(waypoint) => Some(*waypoint),
-            WaypointConfig::FromFile(path) => {
-                let content = fs::read_to_string(path)
-                    .unwrap_or_else(|_| panic!("Failed to read waypoint file {}", path.display()));
-                Some(
-                    Waypoint::from_str(content.trim())
-                        .unwrap_or_else(|_| panic!("Failed to parse waypoint: {}", content.trim())),
-                )
+            WaypointConfig::FromFile(waypoint_path) => {
+                if !waypoint_path.exists() {
+                    panic!(
+                        "Waypoint file not found! Ensure the given path is correct: {:?}",
+                        waypoint_path.display()
+                    );
+                }
+                let content = fs::read_to_string(waypoint_path).unwrap_or_else(|error| {
+                    panic!(
+                        "Failed to read waypoint file {:?}. Error: {:?}",
+                        waypoint_path.display(),
+                        error
+                    )
+                });
+                Some(Waypoint::from_str(content.trim()).unwrap_or_else(|error| {
+                    panic!(
+                        "Failed to parse waypoint: {:?}. Error: {:?}",
+                        content.trim(),
+                        error
+                    )
+                }))
             }
             WaypointConfig::FromStorage(backend) => {
                 let storage: Storage = backend.into();
@@ -255,8 +269,8 @@ impl NodeConfig {
     }
 
     /// Reads the config file and returns the configuration object in addition to doing some
-    /// post-processing of the config
-    /// Paths used in the config are either absolute or relative to the config location
+    /// post-processing of the config.
+    /// Paths used in the config are either absolute or relative to the config location.
     pub fn load<P: AsRef<Path>>(input_path: P) -> Result<Self, Error> {
         let mut config = Self::load_config(&input_path)?;
 
@@ -420,11 +434,23 @@ impl NodeConfig {
 
 pub trait PersistableConfig: Serialize + DeserializeOwned {
     fn load_config<P: AsRef<Path>>(path: P) -> Result<Self, Error> {
-        let mut file = File::open(&path)
-            .map_err(|e| Error::IO(path.as_ref().to_str().unwrap().to_string(), e))?;
+        // Open the file and read it into a string
+        let config_path_string = path.as_ref().to_str().unwrap().to_string();
+        let mut file = File::open(&path).map_err(|error| {
+            Error::Unexpected(format!(
+                "Failed to open config file: {:?}. Error: {:?}",
+                config_path_string, error
+            ))
+        })?;
         let mut contents = String::new();
-        file.read_to_string(&mut contents)
-            .map_err(|e| Error::IO(path.as_ref().to_str().unwrap().to_string(), e))?;
+        file.read_to_string(&mut contents).map_err(|error| {
+            Error::Unexpected(format!(
+                "Failed to read the config file into a string: {:?}. Error: {:?}",
+                config_path_string, error
+            ))
+        })?;
+
+        // Parse the file string
         Self::parse(&contents)
     }