syndicate-flake/flake.nix

{
  description = "Syndicate utilities";

  inputs = {
    rust = {
      url = "github:oxalica/rust-overlay";
      inputs.nixpkgs.follows = "nixpkgs";
    };
  };

  outputs = { self, nixpkgs, rust }:
    let inherit (self) lib;
    in {
      lib = nixpkgs.lib.extend (import ./lib.nix);

      overlays.default = final: prev:
        let rust' = (prev.extend rust.overlay).rust-bin.nightly.latest.default;
        in {
          lib = prev.lib.extend (import ./lib.nix);

          acpi_actor = final.nimPackages.callPackage ./packages/acpi_actor { };

          fontconfig_actor =
            final.nimPackages.callPackage ./packages/fontconfig_actor { };

          libnotify_actor =
            final.nimPackages.callPackage ./packages/libnotify_actor { };

          nimPackages = prev.nimPackages.overrideScope' (final': prev': {
            noiseprotocol = final'.callPackage ./packages/nim/noiseprotocol { };

            preserves = prev'.preserves.overrideAttrs (f: p: {
              version = "20230801";
              src = prev.fetchFromGitea {
                domain = "git.syndicate-lang.org";
                owner = "ehmry";
                repo = "preserves-nim";
                rev = f.version;
                sha256 = "sha256-60QsbXMYYfEWvXQAXu7XSpvg2J9YaGKDkDrfclcK6pc=";
              };
            });

            syndicate = prev'.syndicate.overrideAttrs (f: p: {
              version = "20230801";
              src = prev.fetchFromGitea {
                domain = "git.syndicate-lang.org";
                owner = "ehmry";
                repo = "syndicate-nim";
                rev = f.version;
                hash = "sha256-/mZGWVdQ5FtZf2snPIjTG2tNFVzxQmxvkKuLCAGARYs=";
              };
            });

            syndicate_utils =
              final'.callPackage ./packages/syndicate_utils-nim { };
            syndicated-open = final'.callPackage ./packages/syndicated-open { };
            xdg_open_ng =
              builtins.trace "xdg_open_ng has been renamed to syndicated-open"
              final'.syndicated-open;
          });

          nix_actor = final.nimPackages.callPackage ./packages/nix_actor { };

          noise-c = final.callPackage ./packages/noise-c { };

          python3Packages = prev.python3Packages.overrideScope (final': prev': {
            preserves = final'.callPackage ./packages/preserves-py { };
            syndicate = final'.callPackage ./packages/syndicate-py { };
            synit-daemons = final'.callPackage ./packages/synit-daemons { };
          });

          preserves-tools =
            final.callPackage ./packages/preserves-tools { rust = rust'; };

          sqlite_actor =
            final.nimPackages.callPackage ./packages/sqlite_actor { };

          squeak = final.callPackage ./packages/squeak { };
          squeaker = final.python3Packages.callPackage ./packages/squeaker { };

          syndicate-server =
            final.callPackage ./packages/syndicate-server { rust = rust'; };

          synit-pid1 =
            final.callPackage ./packages/synit-pid1 { rust = rust'; };

          xapian_actor =
            final.nimPackages.callPackage ./packages/xapian_actor { };
        };

      legacyPackages =
        lib.pipe { inherit (nixpkgs.legacyPackages) x86_64-linux; } [
          (self.lib.mapAttrs (system: pkgs: pkgs.extend self.overlays.default))
        ];

      packages = lib.pipe self.legacyPackages [
        (self.lib.mapAttrs (system: pkgs:
          with pkgs; {
            inherit fontconfig_actor libnotify_actor noise-c preserves-tools
              squeak squeaker syndicate-server;
            inherit (nimPackages) syndicate_utils xdg_open_ng;
            preserves-nim = nimPackages.preserves;
            preserves-py = python3Packages.preserves;
            syndicate-nim = nimPackages.syndicate;
            syndicate-py = python3Packages.syndicate;
          }))
      ];

      nixosModules = {
        default = self.nixosModules.syndicate-server;

        syndicate-server =
          # A little hack to apply our overlay to this module only.
          { config, lib, pkgs, ... }:
          (import ./nixos/syndicate-server.nix) {
            inherit config lib;
            pkgs = pkgs.extend self.overlays.default;
          };

        synit = import ./nixos/modules/synit;

      };

      devShells = self.lib.mapAttrs (system: pkgs:
        with pkgs; {
          default =
            mkShell { packages = builtins.attrValues self.packages.${system}; };
        }) self.legacyPackages;

      checks = lib.pipe { inherit (self.legacyPackages) x86_64-linux; } [
        (self.lib.mapAttrs (system: pkgs':
          with import (nixpkgs + "/nixos/lib/testing-python.nix") {
            inherit system;
            pkgs = pkgs';
          }; {
            simple = simpleTest {
              name = "http";
              nodes.machine = { config, pkgs, ... }: {
                imports = [ self.nixosModules.syndicate-server ];

                nixpkgs.pkgs = pkgs';

                services.syndicate.tty1 = {
                  enable = true;
                  user = "loser";
                  config = [ ];
                };
                users.users.loser.isNormalUser = true;
              };
              testScript = ''
                machine.wait_for_job("syndicate-tty1")
              '';
            };

            synit = simpleTest {
              name = "synit";
              nodes.machine = { config, lib, utils, ... }: {
                imports = [ self.nixosModules.synit ];
                boot.initrd.verbose = true;
                boot.initrd.kernelModules =
                  [ "virtio_blk" "ext4" "9p" "9pnet_virtio" "overlay" ];
                environment.etc."syndicate/services/test-gateway.pr".text = ''
                  <require-service <relay-listener <tcp "192.168.1.1" 9001> $gatekeeper>>
                  <bind <ref { oid: "syndicate" key: #x"" }> $config #f>
                '';
                nixpkgs.pkgs = pkgs';
                synit.logProgram = "${pkgs.busybox}/bin/cat";
              };
              testScript = ''
                start_all()
                machine.wait_for_open_port(9001)
              '';
            };

          }))
      ];
    };
}