data model: add run-time configuration (#437)

based on @fricklerhandwerk's work at https://git.fediversity.eu/fricklerhandwerk/Fediversity/compare/main...data-model-as-diagram part of #103.
supersedes #402.

on the application model, feedback on a [sample implementation](#2) welcome as well.

Reviewed-on: Fediversity/Fediversity#437
Reviewed-by: Valentin Gagarin <valentin.gagarin@tweag.io>
Co-authored-by: Kiara Grouwstra <kiara@procolix.eu>
Co-committed-by: Kiara Grouwstra <kiara@procolix.eu>

default.nix

@@ -9,6 +9,8 @@ let
     git-hooks
     gitignore
     ;
+  inherit (import sources.flake-inputs) import-flake;
+  inputs = (import-flake { src = ./.; }).inputs;
   inherit (pkgs) lib;
   inherit (import sources.flake-inputs) import-flake;
   inherit ((import-flake { src = ./.; }).inputs) nixops4;
@@ -76,6 +78,7 @@ in
   # re-export inputs so they can be overridden granularly
   # (they can't be accessed from the outside any other way)
   inherit
+    inputs
     sources
     system
     pkgs

deployment/data-model-test.nix

@@ -1,9 +1,13 @@
 let
-  inherit (import ../default.nix { }) pkgs;
+  inherit (import ../default.nix { }) pkgs inputs;
   inherit (pkgs) lib;
+  inherit (lib) mkOption;
   eval =
     module:
     (lib.evalModules {
+      specialArgs = {
+        inherit inputs;
+      };
       modules = [
         module
         ./data-model.nix
@@ -16,32 +20,51 @@ in
   test-eval = {
     expr =
       let
-        example = eval {
+        fediversity = eval (
-          runtime-environments.bar.nixos = {
+          { config, ... }:
-            module =
+          {
-              { ... }:
+            config = {
-              {
+              applications.hello =
-                system.stateVersion = "25.05";
+                { ... }:
+                {
+                  description = ''Command-line tool that will print "Hello, world!" on the terminal'';
+                  module =
+                    { ... }:
+                    {
+                      options = {
+                        enable = lib.mkEnableOption "Hello in the shell";
+                      };
+                    };
+                  implementation =
+                    cfg:
+                    lib.optionalAttrs cfg.enable {
+                      dummy.login-shell.packages.hello = pkgs.hello;
+                    };
+                };
+            };
+            options = {
+              example-configuration = mkOption {
+                type = config.configuration;
+                readOnly = true;
+                default = {
+                  enable = true;
+                  applications.hello.enable = true;
+                };
               };
-          };
+            };
-          applications.foo = {
+          }
-            module =
+        );
-              { pkgs, ... }:
-              {
-                environment.systemPackages = [
-                  pkgs.hello
-                ];
-              };
-          };
-        };
       in
       {
-        has-runtime = lib.isAttrs example.runtime-environments.bar.nixos.module;
+        inherit (fediversity)
-        has-application = lib.isAttrs example.applications.foo.module;
+          example-configuration
+          ;
       };
     expected = {
-      has-runtime = true;
+      example-configuration = {
-      has-application = true;
+        enable = true;
+        applications.hello.enable = true;
+      };
     };
   };
 }

deployment/data-model.nix

@@ -1,45 +1,89 @@
 {
   lib,
+  config,
   ...
 }:
 let
-  inherit (lib) types mkOption;
+  inherit (lib) mkOption types;
+  inherit (lib.types)
+    attrsOf
+    attrTag
+    deferredModuleWith
+    submodule
+    optionType
+    functionTo
+    ;
+
+  functionType = import ./function.nix;
+  application-resources = {
+    options.resources = mkOption {
+      # TODO: maybe transpose, and group the resources by type instead
+      type = attrsOf (
+        attrTag (lib.mapAttrs (_name: resource: mkOption { type = resource.request; }) config.resources)
+      );
+    };
+  };
 in
-with types;
 {
   _class = "nixops4Deployment";
 
   options = {
-    runtime-environments = mkOption {
+    applications = mkOption {
-      description = "Collection of runtime environments into which applications can be deployed";
+      description = "Collection of Fediversity applications";
-      type = attrsOf (attrTag {
+      type = attrsOf (
-        nixos = mkOption {
+        submodule (application: {
-          description = "A single NixOS machine";
+          _class = "fediversity-application";
-          type = submodule {
+          options = {
-            options = {
+            description = mkOption {
-              module = mkOption {
+              description = "Description to be shown in the application overview";
-                description = "The NixOS module describing the base configuration for that machine";
+              type = types.str;
-                type = deferredModule;
+            };
+            module = mkOption {
+              description = "Operator-facing configuration options for the application";
+              type = deferredModuleWith { staticModules = [ { _class = "fediversity-application-config"; } ]; };
+            };
+            implementation = mkOption {
+              description = "Mapping of application configuration to deployment resources, a description of what an application needs to run";
+              type = application.config.config-mapping.function-type;
+            };
+            resources = mkOption {
+              description = "Compute resources required by an application";
+              type = functionTo application.config.config-mapping.output-type;
+              readOnly = true;
+              default = input: (application.config.implementation input).output;
+            };
+            config-mapping = mkOption {
+              description = "Function type for the mapping from application configuration to required resources";
+              type = submodule functionType;
+              readOnly = true;
+              default = {
+                input-type = application.config.module;
+                output-type = application-resources;
               };
             };
           };
-        };
+        })
-      });
+      );
     };
-    applications = mkOption {
+    configuration = mkOption {
-      description = "Collection of Fediversity applications";
+      description = "Configuration type declaring options to be set by operators";
-      type = attrsOf (submoduleWith {
+      type = optionType;
-        modules = [
+      readOnly = true;
-          {
+      default = submodule {
-            options = {
+        options = {
-              module = mkOption {
+          enable = lib.mkEnableOption {
-                description = "The NixOS module for that application, for configuring that application";
+            description = "your Fediversity configuration";
-                type = deferredModule;
+          };
-              };
+          applications = lib.mapAttrs (
-            };
+            _name: application:
-          }
+            mkOption {
-        ];
+              description = application.description;
-      });
+              type = submodule application.module;
+              default = { };
+            }
+          ) config.applications;
+        };
+      };
     };
   };
 }

deployment/function.nix

@@ -0,0 +1,37 @@
+/**
+  Modular function type
+*/
+{ config, lib, ... }:
+let
+  inherit (lib) mkOption types;
+  inherit (types)
+    deferredModule
+    submodule
+    functionTo
+    optionType
+    ;
+in
+{
+  options = {
+    input-type = mkOption {
+      type = deferredModule;
+    };
+    output-type = mkOption {
+      type = deferredModule;
+    };
+    function-type = mkOption {
+      type = optionType;
+      readOnly = true;
+      default = functionTo (submodule {
+        options = {
+          input = mkOption {
+            type = submodule config.input-type;
+          };
+          output = mkOption {
+            type = submodule config.output-type;
+          };
+        };
+      });
+    };
+  };
+}