Robust Configuration Management in Rust

Configuration management is a crucial aspect of any software application, allowing for flexibility and adaptability across different environments. This challenge asks you to build a simple configuration management system in Rust, capable of loading configuration data from a file (TOML format) and providing access to it in a type-safe manner. This will demonstrate your understanding of Rust's type system, error handling, and data serialization.

Problem Description

You are tasked with creating a module named config that handles loading and accessing configuration data. The configuration data will be stored in a TOML file. Your module should provide a struct Config that represents the configuration data, and functions to load the configuration from a file path and access individual configuration values.

Key Requirements:

• TOML Parsing: The module must be able to parse TOML files using a suitable crate (e.g., toml).
• Type-Safe Access: The Config struct should define the structure of the configuration data with specific types for each field. This ensures type safety when accessing configuration values.
• Error Handling: The module must handle potential errors gracefully, such as file not found, invalid TOML format, or missing configuration fields. Return appropriate Result types to indicate success or failure.
• Clear API: Provide a clean and easy-to-use API for loading and accessing configuration data.

Expected Behavior:

1. The load_config function should take a file path as input and return a Result<Config, Error> where Error is an enum representing possible errors (e.g., FileNotFound, InvalidToml, MissingField).
2. The Config struct should contain fields representing the configuration parameters.
3. Accessing configuration values should be type-safe and return the correct type.
4. If a configuration file is not found, the load_config function should return a FileNotFound error.
5. If the TOML file is invalid, the load_config function should return an InvalidToml error.
6. If a required field is missing from the TOML file, the load_config function should return a MissingField error.

Edge Cases to Consider:

• Empty TOML file.
• TOML file with comments.
• TOML file with incorrect data types for configuration values.
• File path that does not exist.
• Permissions issues when trying to read the file.

Examples

Example 1:

Input: config_file.toml containing:
```toml
[database]
host = "localhost"
port = 5432
user = "admin"
password = "password123"

[server]
port = 8080
timeout = 30

Output: A Config struct with database.host = "localhost", database.port = 5432, database.user = "admin", database.password = "password123", server.port = 8080, server.timeout = 30
Explanation: The `load_config` function successfully parses the TOML file and creates a `Config` struct with the specified values.

Example 2:

Input: config_file.toml containing:
```toml
[database]
host = "localhost"
port = "abc"  # Invalid port type

Output: Err(Error::InvalidToml)
Explanation: The TOML parser detects an invalid data type (string for port) and returns an `InvalidToml` error.

Example 3:

Input: config_file.toml containing:
```toml
[server]
port = 8080

Output: Err(Error::MissingField)
Explanation: The `database` section is missing from the TOML file, and the `load_config` function returns a `MissingField` error.

Constraints

• The TOML file path should be a string slice (&str).
• The Config struct should contain at least the following fields:
  • database: A struct with host (String), port (i32), user (String), and password (String).
  • server: A struct with port (i32) and timeout (i32).
• The load_config function must return a Result type.
• The Error enum must have at least the following variants: FileNotFound, InvalidToml, MissingField.
• The solution should be well-documented and follow Rust coding conventions.

Notes

• Consider using the toml crate for parsing TOML files. Add it to your Cargo.toml file.
• Think about how to handle potential errors during TOML parsing and data conversion.
• Use Rust's Result type to propagate errors effectively.
• The Config struct can be defined using structs and nested structs to represent the hierarchical nature of configuration data.
• Focus on creating a robust and type-safe configuration management system.
• Consider using serde for serialization and deserialization if you want to extend the functionality later.