Rust Configuration Parser: Apply Settings & Handle errors

Rust Error Propagation: Exercise-4 with Solution

Write a Rust function that parses a configuration file, applies settings, and handles configuration errors.

Sample Solution:

Rust Code:

use std::fs; // Import the fs module for file handling
use serde_json; // Import the serde_json crate for JSON parsing
use std::collections::HashMap; // Import HashMap for storing configuration settings
use std::error::Error; // Import the Error trait for error handling

// Function to parse the configuration file and apply settings
fn parse_config(config_file: &str) -> Result, Box> {
    let file_content = fs::read_to_string(config_file)?; // Read the contents of the configuration file
    
    let config_data: HashMap = serde_json::from_str(&file_content)?; // Parse the JSON data into a HashMap
    
    Ok(config_data) // Return the HashMap containing configuration settings
}

fn main() -> Result<(), Box> {
    
    let config_file = "config.json"; // Specify the path of the JSON file
        let json_data = r#"{"key1": "value1", "key2": "value2", "key3": "value3"}"#; // JSON data to write to the file

    // Create the JSON file with the specified data
    fs::write(config_file, json_data)?;

    // Call the function to parse the configuration file
    match parse_config(config_file) {
        Ok(config_data) => {
            println!("Configuration settings:");
            for (key, value) in config_data.iter() {
                println!("{}: {}", key, value);
            }
        },
        Err(err) => eprintln!("Error parsing configuration file: {}", err), // Print an error message if parsing fails
    }
    
    Ok(()) // Return Ok if the program completes successfully
}

Output:

Configuration settings:
key2: value2
key1: value1
key3: value3

Explanation:

Here is a brief explanation of the above Rust code:

• Imports necessary modules and crates:
• std::fs for file handling.
• serde_json crate for JSON parsing.
• std::collections::HashMap for storing configuration settings.
• std::error::Error trait for error handling.
• Defines a function "parse_config()" that takes a configuration file path (config_file) as input and returns a 'Result' containing a HashMap<String, String> representing the configuration settings or a boxed dynamic 'Error' trait object if parsing fails.
• Reads the contents of the configuration file using fs::read_to_string.
• Parses the JSON data from the file content into a HashMap<String, String> using serde_json::from_str.
• Returns the parsed configuration data in a 'Result'.
• Defines the "main()" function, which is the entry point of the program and returns a Result<(), Box<dyn Error>>.
• Specifies the path of the JSON file ('config_file') and the JSON data to be written to the file ('json_data').
• Creates the JSON file with the specified data using fs::write.
• Calls the "parse_config()" function to parse the configuration file.
• Prints the parsed configuration settings if parsing is successful using println!.
• Prints an error message if parsing fails using eprintln!.
• Returns Ok(()) if the program completes successfully.

Rust Code Editor:

Previous: Rust Program: Interacting with Web Service for Authentication & Data retrieval.
Next: Rust user input validation: Propagate Validation Errors.