dotfiles/terranix/modules/consul_agent.nix

{ config, pkgs, lib, tflib, ... }:
let
  cfg = config.prefab.consulAgent;
  inherit (lib)
    mkOption
    types
    mapAttrsToList
    fix
    optionalString
    optionalAttrs
    singleton
    mkMerge
    flip
    ;
  inherit (tflib)
    tf;

  submoduleOptions = {
    datacenter = mkOption {
      description = ''
      '';
      type = types.str;
    };

    replicationDatacenters = mkOption {
      description = ''
      '';
      type = with types; listOf str;
    };

    encryptionKey = mkOption {
      description = ''
        DO NOT hardcode the secret in Nix, generate it with Terraform
        and let Terraform substitute it.
      '';
      type = types.str;
    };

    anonymousToken = mkOption {
      description = ''
        DO NOT hardcode the secret in Nix, generate it with Terraform
        and let Terraform substitute it.
      '';
      type = types.submodule {
        options.secret = mkOption {
          description = '''';
          type = types.str;
        };

        options.accessor = mkOption {
          description = '''';
          type = types.str;
        };
      };
    };

    paths = {
      encryptionKey = mkOption {
        description = ''
        '';
        type = types.str;
      };
      agentToken = mkOption {
        description = ''
        '';
        type = types.str;
      };
      replicationToken = mkOption {
        description = ''
        '';
        type = with types; nullOr str;
        default = null;
      };
      anonymousToken = mkOption {
        description = ''
        '';
        type = types.str;
      };
    };

    vaultKvMount = mkOption {
      description = ''
      '';
      type = types.str;
    };
  };
in
{
  options.prefab.consulAgent = mkOption {
    description = ''
    '';
    type = with types; attrsOf (submodule { options = submoduleOptions; });
    default = {};
  };

  config.resource = mkMerge
    (flip mapAttrsToList cfg (hostname: value:
      fix (self: {
        "consul_acl_policy"."${hostname}_agent" = {
          name = "${hostname}-consul-agent";
          rules = ''
            node "${hostname}" {
              policy = "write"
            }
            agent "${hostname}" {
              policy = "write"
            }
            service_prefix "" {
              policy = "write"
            }
          '';
        };

        "consul_acl_token"."${hostname}_consul_agent" = {
          description = "Consul agent token on ${hostname}";
          node_identities = singleton {
            node_name = hostname;
            datacenter = value.datacenter;
          };
          local = false;
        };

        "vault_kv_secret_v2"."${hostname}_consul_encryption_key" = {
          mount = value.vaultKvMount;
          name = value.paths.encryptionKey;
          delete_all_versions = true;
          data_json = builtins.toJSON {
            key = value.encryptionKey;
          };
        };

        "vault_kv_secret_v2"."${hostname}_consul_anonymous_token" = {
          mount = value.vaultKvMount;
          name = value.paths.anonymousToken;
          delete_all_versions = true;
          data_json = builtins.toJSON {
            secret = value.anonymousToken.secret;
            accessor = value.anonymousToken.accessor;
          };
        };

        "vault_kv_secret_v2"."${hostname}_consul_agent" = {
          mount = value.vaultKvMount;
          name = value.paths.agentToken;
          delete_all_versions = true;
          data_json = builtins.toJSON {
            secret = tf "data.consul_acl_token_secret_id.${hostname}_consul_agent.secret_id";
            accessor = tf "consul_acl_token.${hostname}_consul_agent.id";
          };
        };

        "vault_policy"."${hostname}_consul" = {
          name = "${hostname}_consul_agent";

          policy = ''
            path "${value.vaultKvMount}/data/${value.paths.encryptionKey}" {
              capabilities = ["read"]
            }

            path "${value.vaultKvMount}/data/${value.paths.agentToken}" {
              capabilities = ["read"]
            }

            ${optionalString (value.paths.replicationToken != null) ''
              path "${value.vaultKvMount}/data/${value.paths.replicationToken}" {
                capabilities = ["read"]
              }
            ''}

            path "${value.vaultKvMount}/data/${value.paths.anonymousToken}" {
              capabilities = ["read"]
            }
          '';
        };
      })) ++
    (flip mapAttrsToList cfg (hostname: value:
      (optionalAttrs (value.paths.replicationToken != null) {
        "consul_acl_policy"."${hostname}_replication" = {
          name = "${hostname}_consul_replication";
          datacenters = value.replicationDatacenters;
          rules = ''
            acl = "write"

            operator = "write"

            service_prefix "" {
              policy = "read"
              intentions = "read"
            }
          '';
        };

        "consul_acl_token"."${hostname}_consul_replication" = {
          description = "Consul replication token on ${hostname}";
          policies = [
            (tf "consul_acl_policy.${hostname}_replication.name")
          ];
          local = false;
        };

        "vault_kv_secret_v2"."${hostname}_consul_replication" = {
          mount = value.vaultKvMount;
          name = value.paths.replicationToken;
          delete_all_versions = true;
          data_json = builtins.toJSON {
            secret = tf "data.consul_acl_token_secret_id.${hostname}_consul_replication.secret_id";
            accessor = tf "consul_acl_token.${hostname}_consul_replication.id";
          };
        };
      })
    )));

  config.data = mkMerge
    (flip mapAttrsToList cfg (hostname: value:
      {
        "consul_acl_token_secret_id"."${hostname}_consul_agent" = {
          accessor_id = tf "consul_acl_token.${hostname}_consul_agent.id";
        };
      }
    ) ++
    flip mapAttrsToList cfg (hostname: value:
      (optionalAttrs (value.paths.replicationToken != null) {
        "consul_acl_token_secret_id"."${hostname}_consul_replication" = {
          accessor_id = tf "consul_acl_token.${hostname}_consul_replication.id";
        };
      })
    ));
}