Refactor models to reduce duplication

To be able to have `models/lib.rs` with shared code, we needed to stop symlinking the entire `src` directory and instead treat the variant-specific code as Rust modules, symlinking the correct one to `variant::current` so that `lib.rs` can re-export `Settings`.  (We also have to symlink in `variant/mod.rs` so Rust knows it's part of the module hierarchy.)

Now, each variant defines a `Settings` structure using common sub-structures.  Those sub-structures live in the main `lib.rs`, and the modeled types are now in a shared `modeled_types` module.  No changes were made to the code, just its organization.

Documentation was updated to reflect these changes, including using cargo-readme to generate README.md now that there's a single source.

Dockerfile

@@ -77,7 +77,7 @@ RUN --mount=target=/host \
 USER builder
 RUN --mount=source=.cargo,target=/home/builder/.cargo \
     --mount=type=cache,target=/home/builder/.cache,from=cache,source=/cache \
-    --mount=type=cache,target=/home/builder/rpmbuild/BUILD/workspaces/models/current,from=variantcache,source=/variantcache \
+    --mount=type=cache,target=/home/builder/rpmbuild/BUILD/workspaces/models/src/variant,from=variantcache,source=/variantcache \
     --mount=source=workspaces,target=/home/builder/rpmbuild/BUILD/workspaces \
     rpmbuild -ba --clean rpmbuild/SPECS/${PACKAGE}.spec
 

workspaces/api/storewolf/src/main.rs

@@ -310,7 +310,7 @@ fn populate_default_datastore<P: AsRef<Path>>(
     }
 
     // Read and parse defaults
-    let defaults_str = include_str!("../../../models/current/src/defaults.toml");
+    let defaults_str = include_str!("../../../models/src/variant/current/defaults.toml");
     let mut defaults_val: toml::Value =
         toml::from_str(defaults_str).context(error::DefaultsFormatting)?;
 

workspaces/models/.gitignore

@@ -1 +1,2 @@
-/current/src
+/src/variant/current
+/src/variant/mod.rs

workspaces/models/Cargo.toml

@@ -3,6 +3,8 @@ name = "models"
 version = "0.1.0"
 authors = ["Tom Kirchner <tjk@amazon.com>"]
 edition = "2018"
+publish = false
+build = "build.rs"
 
 [dependencies]
 base64 = "0.10"
@@ -13,6 +15,11 @@ snafu = "0.5"
 toml = "0.5"
 url = "2.1"
 
+[build-dependencies]
+cargo-readme = "3.1"
+
 [lib]
+# We're picking the current *model* with build.rs, so users shouldn't think
+# about importing *models* (plural), just the one current model.
 name = "model"
-path = "current/src/model.rs"
+path = "src/lib.rs"

workspaces/models/README.md

@@ -1,20 +1,32 @@
-# API models
+# models
+
+Current version: 0.1.0
+
+## API models
 
 Thar has different variants supporting different features and use cases.
 Each variant has its own set of software, and therefore needs its own configuration.
 We support having an API model for each variant to support these different configurations.
 
-## aws-k8s: Kubernetes
+Each model defines a top-level `Settings` structure.
+It can use pre-defined structures inside, or custom ones as needed.
+
+This `Settings` essentially becomes the schema for the variant's data store.
+`apiserver::datastore` offers serialization and deserialization modules that make it easy to map between Rust types and the data store, and thus, all inputs and outputs are type-checked.
+
+At the field level, standard Rust types can be used, or ["modeled types"](src/modeled_types) that add input validation.
 
-* [Model](aws-k8s/lib.rs)
-* [Defaults](aws-k8s/defaults.toml)
+### aws-k8s: Kubernetes
 
-## aws-dev: Development build
+* [Model](src/aws-k8s/mod.rs)
+* [Defaults](src/aws-k8s/defaults.toml)
 
-* [Model](aws-dev/lib.rs)
-* [Defaults](aws-dev/defaults.toml)
+### aws-dev: Development build
 
-# This directory
+* [Model](src/aws-dev/mod.rs)
+* [Defaults](src/aws-dev/defaults.toml)
+
+## This directory
 
 We use `build.rs` to symlink the proper API model source code for Cargo to build.
 We determine the "proper" model by using the `VARIANT` environment variable.
@@ -25,7 +37,15 @@ When building with the Thar build system, `VARIANT` is based on `BUILDSYS_VARIAN
 
 Note: when building with the build system, we can't create the symlink in the source directory during a build - the directories are owned by `root`, but we're `builder`.
 We can't use a read/write bind mount with current Docker syntax.
-To get around this, in the top-level `Dockerfile`, we mount a "cache" directory at `current` that we can modify.
-We set Cargo (via `Cargo.toml`) to look for the source at `current/src`, rather than the default `src`.
+To get around this, in the top-level `Dockerfile`, we mount a "cache" directory at `src/variant` that we can modify, and create a `current` symlink inside.
+The code in `src/lib.rs` then imports the requested model using `variant/current`.
+
+Note: for the same reason, we symlink `variant/mod.rs` to `variant_mod.rs`.
+Rust needs a `mod.rs` file to understand that a directory is part of the module structure, so we have to have `variant/mod.rs`.
+`variant/` is the cache mount that starts empty, so we have to store the file elsewhere and link it in.
 
 Note: all models share the same `Cargo.toml`.
+
+## Colophon
+
+This text was generated from `README.tpl` using [cargo-readme](https://crates.io/crates/cargo-readme), and includes the rustdoc from `src/lib.rs`.

workspaces/models/README.tpl

@@ -0,0 +1,9 @@
+# {{crate}}
+
+Current version: {{version}}
+
+{{readme}}
+
+## Colophon
+
+This text was generated from `README.tpl` using [cargo-readme](https://crates.io/crates/cargo-readme), and includes the rustdoc from `src/lib.rs`.