flake.nix

{
  description = "hyper-linux-examples — runnable Linux applications for hyper-linux";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";

    # Publish these coordinated runtime tags before an examples release.
    # Local preparation uses the sibling overrides exposed by the Makefile.
    hyper-linux = {
      url = "github:zw3rk/hyper-linux/v0.3.0-rc2";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    hyper-linux-x11 = {
      url = "github:zw3rk/hyper-linux-x11/v0.1.0-rc2";
      inputs.nixpkgs.follows = "nixpkgs";
    };
  };

  outputs =
    {
      self,
      nixpkgs,
      hyper-linux,
      hyper-linux-x11,
    }:
    let
      inherit (nixpkgs) lib;
      linuxSystems = [
        "aarch64-linux"
        "x86_64-linux"
      ];

      packagesFor =
        system:
        let
          pkgs = nixpkgs.legacyPackages.${system};
          xmmsSet = import ./nix/xmms.nix { inherit pkgs; };
        in
        {
          glib12 = xmmsSet.glib12;
          gtk12 = xmmsSet.gtk12;
          xmms = xmmsSet.xmms;
          xmms-sysroot = xmmsSet.xmmsSysroot;
          default = xmmsSet.xmmsSysroot;
        };

      sysrootCheckFor =
        system:
        let
          pkgs = nixpkgs.legacyPackages.${system};
          xmmsSet = import ./nix/xmms.nix { inherit pkgs; };
        in
        {
          xmms-sysroot =
            pkgs.runCommand "xmms-sysroot-check"
              {
                nativeBuildInputs = [ pkgs.binutils ];
              }
              ''
                READELF=${pkgs.binutils}/bin/readelf \
                  ${pkgs.bash}/bin/bash \
                  ${./scripts/validate-sysroot.sh} ${xmmsSet.xmmsSysroot}
                mkdir -p $out
                echo ok > $out/result
              '';
        };

      darwinSystem = "aarch64-darwin";
      darwinPkgs = nixpkgs.legacyPackages.${darwinSystem};
      hl = hyper-linux.packages.${darwinSystem}.default;
      withAppkitX = hyper-linux-x11.packages.${darwinSystem}.with-appkit-x;
      demoMedia = darwinPkgs.callPackage ./nix/demo-media.nix { };

      xmmsHomeSeed = darwinPkgs.runCommand "xmms-home-seed" { } ''
        mkdir -p $out/.xmms
        cp ${./fixtures/xmms/config} $out/.xmms/config
      '';
      xmmsPrepare = darwinPkgs.writeShellApplication {
        name = "xmms-prepare";
        runtimeInputs = [
          darwinPkgs.coreutils
          darwinPkgs.flock
          darwinPkgs.gnugrep
          darwinPkgs.gnused
          darwinPkgs.python3
        ];
        text = ''
          export HL_XMMS_REMOTE=${./scripts/xmms_remote.py}
          export HL_FLOCK=${darwinPkgs.flock}/bin/flock
          export HL_XMMS_DEFAULT=/media/demo.m3u
          exec ${darwinPkgs.bash}/bin/bash ${./scripts/xmms-prepare.sh} "$@"
        '';
      };
      xmmsCleanup = darwinPkgs.writeShellApplication {
        name = "xmms-cleanup";
        runtimeInputs = [
          darwinPkgs.coreutils
          darwinPkgs.flock
        ];
        text = ''
          export HL_FLOCK=${darwinPkgs.flock}/bin/flock
          exec ${darwinPkgs.bash}/bin/bash ${./scripts/xmms-cleanup.sh} "$@"
        '';
      };
      xmmsReady = darwinPkgs.writeShellApplication {
        name = "xmms-await-ready";
        runtimeInputs = [
          darwinPkgs.coreutils
          darwinPkgs.gnused
        ];
        text = ''
          exec ${darwinPkgs.bash}/bin/bash ${./scripts/xmms-await-ready.sh} "$@"
        '';
      };
      xmmsCleanupRuntimeCheck = darwinPkgs.runCommand
        "xmms-cleanup-runtime-check" { } ''
          export HOME="$TMPDIR/home"
          mkdir -p "$HOME/.hl/instances/check/runs/check-run"
          ${darwinPkgs.coreutils}/bin/env -i HOME="$HOME" PATH=/usr/bin:/bin \
            ${xmmsCleanup}/bin/xmms-cleanup \
            "$HOME/.hl/instances/check" check-run
          test ! -d "$HOME/.hl/instances/check/runs/check-run"
          mkdir -p $out
          echo ok > $out/result
        '';

      mkHyperLinuxApp = import ./nix/mk-hyper-linux-app.nix {
        pkgs = darwinPkgs;
        inherit hl withAppkitX;
        source = self;
      };
      contractFactory = import ./nix/mk-hyper-linux-app.nix {
        pkgs = darwinPkgs;
        hl = "/hl";
        withAppkitX = "/with-appkit-x";
        source = self;
      };

      mkXmms =
        {
          name,
          x11Name,
          guestSystem,
          instanceId,
          appName,
        }:
        let
          sysroot = self.packages.${guestSystem}.xmms-sysroot;
        in
        mkHyperLinuxApp {
          inherit
            appName
            guestSystem
            instanceId
            name
            sysroot
            x11Name
            ;
          program = "${sysroot}/bin/xmms";
          binds = [ "${demoMedia}:/media:ro" ];
          homeBinds = [ "Music:/home/user/Music:ro" ];
          # XMMS publishes its control socket before it finishes processing
          # command-line playlists.  Let its prepare hook own the no-argument
          # demo default so playlist insertion cannot race itself.
          defaultArgs = [ ];
          guestCwd = "/media";
          homeSeed = xmmsHomeSeed;
          prepare = xmmsPrepare;
          ready = xmmsReady;
          cleanup = xmmsCleanup;
        };

      xmmsNative = mkXmms {
        name = "xmms";
        x11Name = "xmms-x11";
        guestSystem = "aarch64-linux";
        instanceId = "xmms-aarch64";
        appName = "XMMS";
      };
      xmmsX86_64 = mkXmms {
        name = "xmms-x86_64-linux";
        x11Name = "xmms-x11-x86_64-linux";
        guestSystem = "x86_64-linux";
        instanceId = "xmms-x86_64";
        appName = "XMMS x86_64";
      };

      xmmsRemote = darwinPkgs.writeShellApplication {
        name = "xmms-remote";
        runtimeInputs = [ darwinPkgs.python3 ];
        text = ''
          exec python3 ${./scripts/xmms_remote.py} "$@"
        '';
      };

      # Preserve `#xmms` as the normal app while allowing the convenient exact
      # attr path `#xmms.x86_64-linux` to fall through to packages.
      xmmsPackage = xmmsNative.appkitPackage.overrideAttrs (old: {
        passthru = (old.passthru or { }) // {
          x86_64-linux = xmmsX86_64.appkitPackage;
        };
      });

      factoryReadyFixture = darwinPkgs.writeShellApplication {
        name = "factory-ready-fixture";
        text = "exit 0";
      };
      factoryFixture = contractFactory {
        name = "factory-fixture";
        appName = "Factory fixture";
        guestSystem = "aarch64-linux";
        instanceId = "factory-fixture";
        sysroot = "/sysroot";
        program = "/sysroot/bin/true";
        ready = factoryReadyFixture;
      };
      invalidFactoryInstance = builtins.tryEval (
        (contractFactory {
          name = "invalid-factory-fixture";
          appName = "Invalid factory fixture";
          guestSystem = "aarch64-linux";
          instanceId = "../escape";
          sysroot = "/sysroot";
          program = "/sysroot/bin/true";
        }).guestRunner.drvPath
      );
      factoryContractCheck =
        assert !invalidFactoryInstance.success;
        darwinPkgs.runCommand "hyper-linux-app-factory-contract" { } ''
          guest_runner=${factoryFixture.guestRunner}/bin/factory-fixture-guest-run
          grep -Fq 'unset HL_APP_HOME_SEED HL_APP_PREPARE' "$guest_runner"
          grep -Fq -- '--ready ${darwinPkgs.lib.getExe factoryReadyFixture}' \
            ${factoryFixture.x11Package}/bin/factory-fixture-x11
          test '${xmmsPackage.x86_64-linux.meta.mainProgram}' = \
            xmms-x86_64-linux
          mkdir -p $out
          echo ok > $out/result
        '';

      sourceCheck =
        darwinPkgs.runCommand "hyper-linux-examples-source"
          {
            src = self;
            nativeBuildInputs = [
              darwinPkgs.bash
              darwinPkgs.flock
              darwinPkgs.python3
            ];
          }
          ''
            ${darwinPkgs.bash}/bin/bash $src/scripts/verify-source.sh $src
            mkdir -p $out
            echo ok > $out/result
          '';
    in
    {
      packages = (lib.genAttrs linuxSystems packagesFor) // {
        ${darwinSystem} = {
          xmms = xmmsPackage;
          xmms-x86_64-linux = xmmsX86_64.appkitPackage;
          xmms-x11 = xmmsNative.x11Package;
          xmms-x11-x86_64-linux = xmmsX86_64.x11Package;
          xmms-remote = xmmsRemote;
          demo-media = demoMedia;
          default = xmmsPackage;
        };
      };

      apps.${darwinSystem} = {
        xmms = xmmsNative.appkitApp;
        xmms-x86_64-linux = xmmsX86_64.appkitApp;
        xmms-x11 = xmmsNative.x11App;
        xmms-x11-x86_64-linux = xmmsX86_64.x11App;
        xmms-remote = {
          type = "app";
          program = "${xmmsRemote}/bin/xmms-remote";
          meta.description = "Control a running XMMS guest instance";
        };
        default = self.apps.${darwinSystem}.xmms;
      };

      hydraJobs = lib.genAttrs linuxSystems (system: removeAttrs self.packages.${system} [ "default" ]);

      checks = (lib.genAttrs linuxSystems sysrootCheckFor) // {
        ${darwinSystem} = {
          demo-media =
            darwinPkgs.runCommand "soundhelix-demo-media-check"
              {
                nativeBuildInputs = [
                  darwinPkgs.coreutils
                  darwinPkgs.findutils
                ];
              }
              ''
                media=${demoMedia}
                test "$(find "$media" -maxdepth 1 -type f -name 'SoundHelix-Song-*.mp3' | wc -l | tr -d ' ')" = 17

                expected=$TMPDIR/expected.m3u
                {
                  echo '#EXTM3U'
                  for index in $(seq 1 17); do
                    echo "#EXTINF:-1,SoundHelix Song $index"
                    echo "SoundHelix-Song-$index.mp3"
                  done
                } > "$expected"
                cmp "$expected" "$media/demo.m3u"

                while IFS= read -r entry; do
                  case "$entry" in
                    ""|'#'*) continue ;;
                  esac
                  test -s "$media/$entry"
                done < "$media/demo.m3u"

                mkdir -p $out
                echo ok > $out/result
              '';

          media-sha256 =
            darwinPkgs.runCommand "xmms-media-sha256"
              {
                src = ./fixtures/xmms/media;
              }
              ''
                cd $src
                ${darwinPkgs.coreutils}/bin/sha256sum -c smoke-440-660.wav.sha256
                mkdir -p $out
                echo ok > $out/result
              '';

          app-factory-contract = factoryContractCheck;
          source = sourceCheck;
          xmms-cleanup-runtime = xmmsCleanupRuntimeCheck;
          xmms = xmmsPackage;
          xmms-x86_64-linux = xmmsX86_64.appkitPackage;
          xmms-x11 = xmmsNative.x11Package;
          xmms-x11-x86_64-linux = xmmsX86_64.x11Package;
          xmms-remote = xmmsRemote;
        };
      };

      devShells.${darwinSystem}.default = darwinPkgs.mkShell {
        name = "hyper-linux-examples";
        packages = [
          darwinPkgs.actionlint
          darwinPkgs.flock
          darwinPkgs.coreutils
          darwinPkgs.gnumake
          darwinPkgs.python3
          darwinPkgs.shellcheck
        ];
      };

      lib.${darwinSystem} = {
        inherit mkHyperLinuxApp;
      };
    };
}