<snip>

> > +# Frozen makes the object immutable. This enables further optimizations,
> > +# and makes it thread safe should we every want to move in that
> direction.
> > +@dataclass(slots=True, frozen=True)
> > +class NodeConfiguration:
> > +    name: str
> > +    hostname: str
> > +    user: str
> > +    password: Optional[str]
> > +
> > +    @staticmethod
> > +    def from_dict(d: dict) -> "NodeConfiguration":
> > +        return NodeConfiguration(
> > +            name=d["name"],
> > +            hostname=d["hostname"],
> > +            user=d["user"],
> > +            password=d.get("password"),
> > +        )
> > +
> Out of curiosity, what is the reason for having a static "from_dict" method
> rather than just a regular constructor function that takes a dict as
> parameter?
>

@dataclass(...) is a class annotation that transforms the thing it
annotates into a dataclass. This means it creates the constructor for you
based on the property type annotations. If you create your own constructor,
you need a constructor that can either take a single dictionary or all of
the parameters like a normal constructor. Making it a static method also
means that each class can manage how it should be constructed from a
dictionary. Some of the other classes will transform lists or perform other
assertions. It also makes it easier to have specialized types. For
instance, a NICConfiguration class would have to handle all of the possible
device arguments that could be passed to any PMD driver if things were
passed as parameters.


> > +
> > +@dataclass(slots=True, frozen=True)
> > +class ExecutionConfiguration:
> > +    system_under_test: NodeConfiguration
> > +
> Minor comment: seems strange having only a single member variable in this
> class, effectively duplicating the class above.
>

More is intended to go here. For instance, what tests to run, configuration
for virtual machines, the traffic generator node.

<snip>

> > +    @staticmethod
> > +    def from_dict(d: dict, node_map: dict) -> "ExecutionConfiguration":
> from reading the code it appears that node_map is a dict of
> NodeConfiguration objects, right? Might be worth adding that to the
> definition for clarity, and also the specific type of the dict "d" (if it
> has one)
> > +        sut_name = d["system_under_test"]
> > +        assert sut_name in node_map, f"Unknown SUT {sut_name} in
> execution {d}"
> > +
> > +        return ExecutionConfiguration(
> > +            system_under_test=node_map[sut_name],
> > +        )
> > +
> > +
> > +@dataclass(slots=True, frozen=True)
> > +class Configuration:
> > +    executions: list[ExecutionConfiguration]
> > +
> > +    @staticmethod
> > +    def from_dict(d: dict) -> "Configuration":
> > +        nodes: list[NodeConfiguration] = list(
> > +            map(NodeConfiguration.from_dict, d["nodes"])
> So "d" is a dict of dicts?
>

d is a dictionary which matches the json schema for the class. In the case
of the Configuration class, it is a dictionary matching the entire json
schema.


> > +        )
> > +        assert len(nodes) > 0, "There must be a node to test"
> > +
> > +        node_map = {node.name: node for node in nodes}
> > +        assert len(nodes) == len(node_map), "Duplicate node names are
> not allowed"
> > +
> > +        executions: list[ExecutionConfiguration] = list(
> > +            map(
> > +                ExecutionConfiguration.from_dict, d["executions"],
> [node_map for _ in d]
> > +            )
> > +        )
> > +
> > +        return Configuration(executions=executions)
> > +
> > +
> > +def load_config() -> Configuration:
> > +    """
> > +    Loads the configuration file and the configuration file schema,
> > +    validates the configuration file, and creates a configuration
> object.
> > +    """
> > +    with open(SETTINGS.config_file_path, "r") as f:
> > +        config_data = yaml.safe_load(f)
> > +
> > +    schema_path = os.path.join(
> > +        pathlib.Path(__file__).parent.resolve(), "conf_yaml_schema.json"
> > +    )
> > +
> > +    with open(schema_path, "r") as f:
> > +        schema = json.load(f)
> > +    config: dict[str, Any] = warlock.model_factory(schema,
> name="_Config")(config_data)
> > +    config_obj: Configuration = Configuration.from_dict(dict(config))
> > +    return config_obj
> > +
> > +
> > +CONFIGURATION = load_config()
> <snip>