forked from fediversity/fediversity
773 lines
28 KiB
Nix
773 lines
28 KiB
Nix
{
|
|
lib,
|
|
config,
|
|
inputs,
|
|
pkgs,
|
|
sources ? import ../npins,
|
|
...
|
|
}:
|
|
let
|
|
inherit (lib) mkOption types;
|
|
inherit (lib.types)
|
|
attrTag
|
|
attrsOf
|
|
deferredModuleWith
|
|
functionTo
|
|
nullOr
|
|
optionType
|
|
raw
|
|
str
|
|
submodule
|
|
;
|
|
toBash =
|
|
v:
|
|
lib.replaceStrings [ "\"" ] [ "\\\"" ] (
|
|
if lib.isPath v || builtins.isNull v then
|
|
toString v
|
|
else if lib.isString v then
|
|
v
|
|
else
|
|
lib.strings.toJSON v
|
|
);
|
|
withPackages = packages: {
|
|
makeWrapperArgs = [
|
|
"--prefix"
|
|
"PATH"
|
|
":"
|
|
"${lib.makeBinPath packages}"
|
|
];
|
|
};
|
|
writeConfig =
|
|
{
|
|
system,
|
|
module,
|
|
root-path,
|
|
deployment-type,
|
|
deployment-name,
|
|
args,
|
|
}:
|
|
builtins.toString (
|
|
pkgs.writers.writeText "configuration.nix" ''
|
|
import ${root-path}/deployment/nixos.nix {
|
|
system = "${system}";
|
|
configuration = (import "${root-path}/${module}" (builtins.fromJSON "${
|
|
lib.replaceStrings [ "\"" ] [ "\\\"" ] (lib.strings.toJSON args)
|
|
}")).${deployment-name}.${deployment-type}.nixos-configuration;
|
|
}
|
|
''
|
|
);
|
|
|
|
functionType = submodule ./function.nix;
|
|
application-resources = submodule {
|
|
options.resources = mkOption {
|
|
# TODO: maybe transpose, and group the resources by type instead
|
|
type = attrsOf (
|
|
attrTag (
|
|
lib.mapAttrs (_name: resource: mkOption { type = submodule resource.request; }) config.resources
|
|
)
|
|
);
|
|
};
|
|
};
|
|
nixops4Deployment = types.deferredModuleWith {
|
|
staticModules = [
|
|
inputs.nixops4.modules.nixops4Deployment.default
|
|
|
|
{
|
|
_class = "nixops4Deployment";
|
|
_module.args = {
|
|
resourceProviderSystem = pkgs.system;
|
|
resources = { };
|
|
};
|
|
}
|
|
];
|
|
};
|
|
nixos-configuration = mkOption {
|
|
description = "A NixOS configuration.";
|
|
type = raw;
|
|
};
|
|
host-ssh = mkOption {
|
|
description = "SSH connection info to connect to a single host.";
|
|
type = submodule {
|
|
options = {
|
|
host = mkOption {
|
|
description = "the host to access by SSH";
|
|
type = str;
|
|
};
|
|
username = mkOption {
|
|
description = "the SSH user to use";
|
|
type = nullOr str;
|
|
default = null;
|
|
};
|
|
key-file = mkOption {
|
|
description = "path to the user's SSH private key";
|
|
type = nullOr str;
|
|
example = "/root/.ssh/id_ed25519";
|
|
};
|
|
sshOpts = mkOption {
|
|
description = "Extra SSH options (`-o`) to use.";
|
|
type = types.listOf str;
|
|
default = [ ];
|
|
example = "ConnectTimeout=60";
|
|
};
|
|
};
|
|
};
|
|
};
|
|
# FIXME allow custom deployment types
|
|
# FIXME make deployments environment resources?
|
|
deployment-type = attrTag {
|
|
ssh-host = mkOption {
|
|
description = "A deployment by SSH to update a single existing NixOS host.";
|
|
type = submodule (ssh-host: {
|
|
options = {
|
|
system = mkOption {
|
|
description = "The architecture of the system to deploy to.";
|
|
type = types.str;
|
|
};
|
|
inherit nixos-configuration;
|
|
ssh = host-ssh;
|
|
module = mkOption {
|
|
description = "The module to call to obtain the NixOS configuration from.";
|
|
type = types.str;
|
|
};
|
|
args = mkOption {
|
|
description = "The arguments with which to call the module to obtain the NixOS configuration.";
|
|
type = types.attrs;
|
|
};
|
|
deployment-name = mkOption {
|
|
description = "The name of the deployment for which to obtain the NixOS configuration.";
|
|
type = types.str;
|
|
};
|
|
root-path = mkOption {
|
|
description = "The path to the root of the repository.";
|
|
type = types.path;
|
|
};
|
|
run = mkOption {
|
|
type = types.package;
|
|
# error: The option `ssh-deployment.ssh-host.run' is read-only, but it's set multiple times.
|
|
# readOnly = true;
|
|
default =
|
|
let
|
|
inherit (ssh-host.config)
|
|
system
|
|
ssh
|
|
module
|
|
args
|
|
deployment-name
|
|
root-path
|
|
;
|
|
inherit (ssh)
|
|
host
|
|
username
|
|
key-file
|
|
sshOpts
|
|
;
|
|
environment = {
|
|
key_file = key-file;
|
|
ssh_opts = sshOpts;
|
|
inherit
|
|
host
|
|
username
|
|
;
|
|
nixos_conf = writeConfig {
|
|
inherit
|
|
system
|
|
module
|
|
args
|
|
deployment-name
|
|
root-path
|
|
;
|
|
deployment-type = "ssh-host";
|
|
};
|
|
};
|
|
in
|
|
pkgs.writers.writeBashBin "deploy-sh.sh"
|
|
(withPackages [
|
|
pkgs.jq
|
|
])
|
|
''
|
|
env ${
|
|
toString (lib.mapAttrsToList (k: v: "${k}=\"${toBash v}\"") environment)
|
|
} bash ./deployment/run/ssh-single-host/run.sh
|
|
'';
|
|
};
|
|
};
|
|
});
|
|
};
|
|
nixops4 = mkOption {
|
|
description = "A NixOps4 NixOS deployment. For an example, see https://github.com/nixops4/nixops4-nixos/blob/main/example/deployment.nix.";
|
|
type = nixops4Deployment;
|
|
};
|
|
tf-host = mkOption {
|
|
description = "A Terraform deployment by SSH to update a single existing NixOS host.";
|
|
type = submodule (tf-host: {
|
|
options = {
|
|
system = mkOption {
|
|
description = "The architecture of the system to deploy to.";
|
|
type = types.str;
|
|
};
|
|
inherit nixos-configuration;
|
|
ssh = host-ssh;
|
|
module = mkOption {
|
|
description = "The module to call to obtain the NixOS configuration from.";
|
|
type = types.str;
|
|
};
|
|
args = mkOption {
|
|
description = "The arguments with which to call the module to obtain the NixOS configuration.";
|
|
type = types.attrs;
|
|
};
|
|
deployment-name = mkOption {
|
|
description = "The name of the deployment for which to obtain the NixOS configuration.";
|
|
type = types.str;
|
|
};
|
|
root-path = mkOption {
|
|
description = "The path to the root of the repository.";
|
|
type = types.path;
|
|
};
|
|
run = mkOption {
|
|
type = types.package;
|
|
# error: The option `tf-deployment.tf-host.run' is read-only, but it's set multiple times.
|
|
# readOnly = true;
|
|
default =
|
|
let
|
|
inherit (tf-host.config)
|
|
system
|
|
ssh
|
|
module
|
|
args
|
|
deployment-name
|
|
root-path
|
|
;
|
|
inherit (ssh)
|
|
host
|
|
username
|
|
key-file
|
|
sshOpts
|
|
;
|
|
environment = {
|
|
key_file = key-file;
|
|
ssh_opts = sshOpts;
|
|
inherit
|
|
host
|
|
username
|
|
;
|
|
nixos_conf = writeConfig {
|
|
inherit
|
|
system
|
|
module
|
|
args
|
|
deployment-name
|
|
root-path
|
|
;
|
|
deployment-type = "tf-host";
|
|
};
|
|
};
|
|
tf-env = pkgs.callPackage ./run/tf-single-host/tf-env.nix { };
|
|
in
|
|
pkgs.writers.writeBashBin "deploy-tf.sh"
|
|
(withPackages [
|
|
pkgs.jq
|
|
(pkgs.callPackage ./run/tf-single-host/tf.nix { inherit sources; })
|
|
])
|
|
''
|
|
env ${toString (lib.mapAttrsToList (k: v: "TF_VAR_${k}=\"${toBash v}\"") environment)} \
|
|
tf_env=${tf-env} bash ./deployment/run/tf-single-host/run.sh
|
|
'';
|
|
};
|
|
};
|
|
});
|
|
};
|
|
bash-proxmox-host = mkOption {
|
|
description = "A bash deployment by SSH to create or update a NixOS VM in ProxmoX.";
|
|
type = submodule (bash-proxmox-host: {
|
|
options = {
|
|
system = mkOption {
|
|
description = "The architecture of the system to deploy to.";
|
|
type = types.str;
|
|
};
|
|
inherit nixos-configuration;
|
|
# TODO: add proxmox info
|
|
module = mkOption {
|
|
description = "The module to call to obtain the NixOS configuration from.";
|
|
type = types.str;
|
|
};
|
|
args = mkOption {
|
|
description = "The arguments with which to call the module to obtain the NixOS configuration.";
|
|
type = types.attrs;
|
|
};
|
|
deployment-name = mkOption {
|
|
description = "The name of the deployment for which to obtain the NixOS configuration.";
|
|
type = types.str;
|
|
};
|
|
root-path = mkOption {
|
|
description = "The path to the root of the repository.";
|
|
type = types.path;
|
|
};
|
|
proxmox-host = mkOption {
|
|
description = "The host of the ProxmoX instance to use.";
|
|
type = types.str;
|
|
default = "192.168.51.81";
|
|
};
|
|
vm-names = mkOption {
|
|
description = "The names of VMs to provision.";
|
|
type = types.listOf types.str;
|
|
};
|
|
proxmox-user = mkOption {
|
|
description = "The ProxmoX user to use.";
|
|
type = types.str;
|
|
default = "root@pam";
|
|
};
|
|
# TODO: is sensitivity here handled properly?
|
|
proxmox-password = mkOption {
|
|
description = "The ProxmoX password to use.";
|
|
type = types.str;
|
|
};
|
|
node-name = mkOption {
|
|
description = "the name of the ProxmoX node to use.";
|
|
type = types.str;
|
|
};
|
|
run = mkOption {
|
|
type = types.package;
|
|
# error: The option `.run' is read-only, but it's set multiple times.
|
|
# readOnly = true;
|
|
default =
|
|
let
|
|
deployment-type = "bash-proxmox-host";
|
|
inherit (bash-proxmox-host.config)
|
|
system
|
|
module
|
|
args
|
|
deployment-name
|
|
root-path
|
|
node-name
|
|
proxmox-host
|
|
proxmox-user
|
|
proxmox-password
|
|
vm-names
|
|
;
|
|
nixos_conf = writeConfig {
|
|
inherit
|
|
system
|
|
module
|
|
args
|
|
deployment-name
|
|
root-path
|
|
deployment-type
|
|
;
|
|
};
|
|
in
|
|
pkgs.writers.writeBashBin "provision-proxmox.sh"
|
|
(withPackages [
|
|
pkgs.httpie
|
|
pkgs.jq
|
|
])
|
|
''
|
|
bash ./infra/proxmox-remove.sh \
|
|
--api-url "https://${proxmox-host}:8006/api2/json" \
|
|
--username "${proxmox-user}" \
|
|
--password "${proxmox-password}" \
|
|
--node "${node-name}" \
|
|
7014
|
|
# ^ hardcoded ID of test14
|
|
# ${lib.concatStringsSep " " vm-names}
|
|
|
|
bash ./infra/proxmox-provision.sh \
|
|
--api-url "https://${proxmox-host}:8006/api2/json" \
|
|
--username "${proxmox-user}" \
|
|
--password "${proxmox-password}" \
|
|
--node "${node-name}" \
|
|
${
|
|
# lib.concatStringsSep " " vm-names
|
|
lib.concatStringsSep " " (lib.lists.map (k: "${k}:${nixos_conf}") vm-names)
|
|
}
|
|
# ${lib.concatStringsSep " " vm-names}
|
|
'';
|
|
};
|
|
};
|
|
});
|
|
};
|
|
tf-proxmox-host = mkOption {
|
|
description = "A Terraform deployment by SSH to update a single existing NixOS host.";
|
|
# type = submodule (tf-host: {
|
|
type = submodule (
|
|
tf-host:
|
|
let
|
|
raw = {
|
|
# formatConfig = "${pkgs.nixos-generators}/share/nixos-generator/formats/raw.nix";
|
|
formatConfig = "${pkgs.nixos-generators}/share/nixos-generator/formats/raw-efi.nix";
|
|
formatAttr = "raw";
|
|
fileExtension = ".img";
|
|
};
|
|
format = raw;
|
|
# qcow = {
|
|
# formatConfig = "${pkgs.nixos-generators}/share/nixos-generator/formats/qcow.nix";
|
|
# formatAttr = "qcow";
|
|
# fileExtension = ".qcow2";
|
|
# };
|
|
# format = qcow;
|
|
# qcow-efi = {
|
|
# formatConfig = "${pkgs.nixos-generators}/share/nixos-generator/formats/qcow-efi.nix";
|
|
# formatAttr = "qcow-efi";
|
|
# fileExtension = ".qcow2";
|
|
# };
|
|
# format = qcow-efi;
|
|
inherit (format) formatConfig fileExtension formatAttr;
|
|
# inherit (format) formatConfig fileExtension; # formatAttr
|
|
in
|
|
{
|
|
options = {
|
|
system = mkOption {
|
|
description = "The architecture of the system to deploy to.";
|
|
type = types.str;
|
|
};
|
|
inherit nixos-configuration;
|
|
ssh = host-ssh;
|
|
# TODO: add proxmox info
|
|
module = mkOption {
|
|
description = "The module to call to obtain the NixOS configuration from.";
|
|
type = types.str;
|
|
};
|
|
args = mkOption {
|
|
description = "The arguments with which to call the module to obtain the NixOS configuration.";
|
|
type = types.attrs;
|
|
};
|
|
deployment-name = mkOption {
|
|
description = "The name of the deployment for which to obtain the NixOS configuration.";
|
|
type = types.str;
|
|
};
|
|
root-path = mkOption {
|
|
description = "The path to the root of the repository.";
|
|
type = types.path;
|
|
};
|
|
proxmox-user = mkOption {
|
|
description = "The ProxmoX user to use.";
|
|
type = types.str;
|
|
default = "root@pam";
|
|
};
|
|
# TODO: is sensitivity here handled properly?
|
|
proxmox-password = mkOption {
|
|
description = "The ProxmoX password to use.";
|
|
type = types.str;
|
|
};
|
|
node-name = mkOption {
|
|
description = "the name of the ProxmoX node to use.";
|
|
type = types.str;
|
|
};
|
|
run = mkOption {
|
|
type = types.package;
|
|
# error: The option `tf-deployment.tf-host.run' is read-only, but it's set multiple times.
|
|
# readOnly = true;
|
|
default =
|
|
let
|
|
inherit (tf-host.config)
|
|
system
|
|
ssh
|
|
module
|
|
args
|
|
deployment-name
|
|
root-path
|
|
proxmox-user
|
|
proxmox-password
|
|
node-name
|
|
;
|
|
# image = let
|
|
# # TODO parameterize things to let this flow into the terraform
|
|
# # btw qcow can be made by nixos-generators (qcow, qcow-efi) or by `image.repart`
|
|
# # wait, so i generate an image for the nixos config from the data model? how would i then propagate that to deploy?
|
|
# gen = import "${pkgs.nixos-generators}/share/nixos-generator/nixos-generate.nix" {
|
|
# inherit system formatConfig;
|
|
# inherit (sources) nixpkgs;
|
|
# # configuration = import "${pkgs.nixos-generators}/share/nixos-generator/configuration.nix";
|
|
# # formatConfig = "${pkgs.nixos-generators}/share/nixos-generator/formats/proxmox.nix";
|
|
# configuration = tf-host.config.nixos-configuration;
|
|
# # configuration = {
|
|
# # imports = [
|
|
# # # "${pkgs.nixos-generators}/share/nixos-generator/configuration.nix"
|
|
# # # "${sources.nixpkgs}/nixos/modules/profiles/qemu-guest.nix"
|
|
# # # "${sources.agenix}/modules/age.nix"
|
|
# # # "${sources.disko}/module.nix"
|
|
# # # "${sources.home-manager}/nixos"
|
|
# # ];
|
|
# # };
|
|
# };
|
|
# machine = gen.config;
|
|
# in
|
|
# machine.system.build.${formatAttr};
|
|
inherit (ssh)
|
|
host
|
|
username
|
|
key-file
|
|
sshOpts
|
|
;
|
|
deployment-type = "tf-proxmox-host";
|
|
nixos_conf = writeConfig {
|
|
inherit
|
|
system
|
|
module
|
|
args
|
|
deployment-name
|
|
root-path
|
|
deployment-type
|
|
;
|
|
};
|
|
environment = {
|
|
key_file = key-file;
|
|
ssh_opts = sshOpts;
|
|
inherit
|
|
host
|
|
nixos_conf
|
|
;
|
|
proxmox_user = proxmox-user;
|
|
proxmox_password = proxmox-password;
|
|
ssh_user = username;
|
|
node_name = node-name;
|
|
# image = "${image}/nixos${fileExtension}";
|
|
# image = "${image}/nixos.img";
|
|
};
|
|
# image = "${image}/nixos${fileExtension}";
|
|
# image = "${image}/nixos.img";
|
|
tf-env = pkgs.callPackage ./run/tf-proxmox/tf-env.nix { };
|
|
proxmox-host = "192.168.51.81"; # root@fediversity-proxmox
|
|
vm-names = [ "test14" ];
|
|
vm_name = "test14";
|
|
in
|
|
pkgs.writers.writeBashBin "deploy-tf-proxmox.sh"
|
|
(withPackages [
|
|
pkgs.jq
|
|
pkgs.qemu
|
|
pkgs.nixos-generators
|
|
pkgs.httpie
|
|
(pkgs.callPackage ./run/tf-proxmox/tf.nix { inherit sources; })
|
|
])
|
|
''
|
|
set -xe
|
|
|
|
# bash ./infra/proxmox-remove.sh \
|
|
# --api-url "https://${proxmox-host}:8006/api2/json" \
|
|
# --username "${proxmox-user}" \
|
|
# --password "${proxmox-password}" \
|
|
# --node "${node-name}" \
|
|
# 7014
|
|
# # ^ hardcoded ID of test14
|
|
# # ${lib.concatStringsSep " " vm-names}
|
|
|
|
# TODO after install: $nix_host_keys
|
|
# cp $tmpdir/${vm_name}_host_key /mnt/etc/ssh/ssh_host_ed25519_key
|
|
# chmod 600 /mnt/etc/ssh/ssh_host_ed25519_key
|
|
# cp $tmpdir/${vm_name}_host_key.pub /mnt/etc/ssh/ssh_host_ed25519_key.pub
|
|
# chmod 644 /mnt/etc/ssh/ssh_host_ed25519_key.pub
|
|
|
|
qemu-img convert -f raw -O qcow2 -C ${(import nixos_conf).config.system.build.image}/monkey.raw /tmp/disk.qcow2
|
|
|
|
exit 1
|
|
|
|
# TF_VAR_image=/tmp/disk.qcow2 \
|
|
|
|
env ${
|
|
toString (
|
|
lib.mapAttrsToList (k: v: "TF_VAR_${k}=\"${toBash v}\"") (
|
|
lib.trace (lib.strings.toJSON environment) environment
|
|
)
|
|
)
|
|
} \
|
|
TF_VAR_image=/tmp/disk.qcow2 \
|
|
tf_env=${tf-env} bash ./deployment/run/tf-proxmox/run.sh
|
|
|
|
# env ${toString (lib.mapAttrsToList (k: v: "TF_VAR_${k}=\"${toBash v}\"") environment)} \
|
|
# tf_env=${tf-env} bash ./deployment/run/tf-proxmox/run.sh
|
|
'';
|
|
};
|
|
};
|
|
}
|
|
);
|
|
};
|
|
};
|
|
in
|
|
{
|
|
options = {
|
|
resources = mkOption {
|
|
description = "Collection of deployment resources that can be required by applications and policed by hosting providers";
|
|
type = attrsOf (
|
|
submodule (
|
|
{ ... }:
|
|
{
|
|
_class = "fediversity-resource";
|
|
options = {
|
|
description = mkOption {
|
|
description = "Description of the resource to help application module authors and hosting providers to work with it";
|
|
type = types.str;
|
|
};
|
|
request = mkOption {
|
|
description = "Options for declaring resource requirements by an application, a description of how the resource is consumed or accessed";
|
|
type = deferredModuleWith { staticModules = [ { _class = "fediversity-resource-request"; } ]; };
|
|
};
|
|
policy = mkOption {
|
|
description = "Options for configuring the resource policy for the hosting provider, a description of how the resource is made available";
|
|
type = deferredModuleWith {
|
|
staticModules = [
|
|
(policy: {
|
|
_class = "fediversity-resource-policy";
|
|
options.resource-type = mkOption {
|
|
description = "The type of resource this policy configures";
|
|
type = types.optionType;
|
|
};
|
|
# TODO(@fricklerhandwerk): we may want to make the function type explicit here: `application-resources -> resource-type`
|
|
# and then also rename this to be consistent with the application's resource mapping
|
|
options.apply = mkOption {
|
|
description = "Apply the policy to a request";
|
|
type = functionTo policy.config.resource-type;
|
|
};
|
|
})
|
|
];
|
|
};
|
|
};
|
|
};
|
|
}
|
|
)
|
|
);
|
|
};
|
|
applications = mkOption {
|
|
description = "Collection of Fediversity applications";
|
|
type = attrsOf (
|
|
submodule (application: {
|
|
_class = "fediversity-application";
|
|
options = {
|
|
description = mkOption {
|
|
description = "Description to be shown in the application overview";
|
|
type = types.str;
|
|
};
|
|
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 = application.config.config-mapping.function-type;
|
|
readOnly = true;
|
|
default = application.config.config-mapping.apply;
|
|
};
|
|
# TODO(@fricklerhandwerk): this needs a better name
|
|
config-mapping = mkOption {
|
|
description = "Function type for the mapping from application configuration to required resources";
|
|
type = functionType;
|
|
readOnly = true;
|
|
default = {
|
|
input-type = submodule application.config.module;
|
|
output-type = application-resources;
|
|
implementation = application.config.implementation;
|
|
};
|
|
};
|
|
};
|
|
})
|
|
);
|
|
};
|
|
environments = mkOption {
|
|
description = "Run-time environments for Fediversity applications to be deployed to";
|
|
type = attrsOf (
|
|
submodule (environment: {
|
|
_class = "fediversity-environment";
|
|
options = {
|
|
resources = mkOption {
|
|
description = ''
|
|
Resources made available by the hosting provider, and their policies.
|
|
|
|
Setting this is optional, but provides a place to declare that information for programmatic use in the resource mapping.
|
|
'';
|
|
# TODO: maybe transpose, and group the resources by type instead
|
|
type = attrsOf (
|
|
attrTag (
|
|
lib.mapAttrs (_name: resource: mkOption { type = submodule resource.policy; }) config.resources
|
|
)
|
|
);
|
|
};
|
|
implementation = mkOption {
|
|
description = "Mapping of resources required by applications to available resources; the result can be deployed";
|
|
type = environment.config.resource-mapping.function-type;
|
|
};
|
|
resource-mapping = mkOption {
|
|
description = "Function type for the mapping from resources to a deployment";
|
|
type = functionType;
|
|
readOnly = true;
|
|
default = {
|
|
input-type = submodule {
|
|
options = {
|
|
deployment-name = mkOption {
|
|
type = types.str;
|
|
};
|
|
required-resources = mkOption {
|
|
type = attrsOf application-resources;
|
|
};
|
|
};
|
|
};
|
|
output-type = deployment-type;
|
|
implementation = environment.config.implementation;
|
|
};
|
|
};
|
|
config-mapping = mkOption {
|
|
description = "Mapping from a configuration to a deployment";
|
|
type = functionType;
|
|
readOnly = true;
|
|
default = {
|
|
input-type = submodule {
|
|
options = {
|
|
deployment-name = mkOption {
|
|
type = types.str;
|
|
};
|
|
configuration = mkOption {
|
|
type = config.configuration;
|
|
};
|
|
};
|
|
};
|
|
output-type = deployment-type;
|
|
implementation =
|
|
{
|
|
deployment-name,
|
|
configuration,
|
|
}:
|
|
# TODO: check cfg.enable.true
|
|
let
|
|
required-resources = lib.mapAttrs (
|
|
name: application-settings: config.applications.${name}.resources application-settings
|
|
) configuration.applications;
|
|
in
|
|
environment.config.resource-mapping.apply { inherit required-resources deployment-name; };
|
|
};
|
|
};
|
|
# TODO(@fricklerhandwerk): maybe this should be a separate thing such as `fediversity-setup`,
|
|
# which makes explicit which applications and environments are available.
|
|
# then the deployments can simply be the result of the function application baked into this module.
|
|
deployment = mkOption {
|
|
description = "Generate a deployment from a configuration, by applying an environment's resource policies to the applications' resource mappings";
|
|
type = environment.config.config-mapping.function-type;
|
|
readOnly = true;
|
|
default = environment.config.config-mapping.apply;
|
|
};
|
|
};
|
|
})
|
|
);
|
|
};
|
|
configuration = mkOption {
|
|
description = "Configuration type declaring options to be set by operators";
|
|
type = optionType;
|
|
readOnly = true;
|
|
default = submodule {
|
|
options = {
|
|
enable = lib.mkEnableOption {
|
|
description = "your Fediversity configuration";
|
|
};
|
|
applications = lib.mapAttrs (
|
|
_name: application:
|
|
mkOption {
|
|
description = application.description;
|
|
type = submodule application.module;
|
|
default = { };
|
|
}
|
|
) config.applications;
|
|
};
|
|
};
|
|
};
|
|
};
|
|
}
|