isle/default.nix

{
  buildSystem ? builtins.currentSystem,
  hostSystem ? buildSystem,
  pkgsNix ? (import ./nix/pkgs.nix),

  # We allow passing in the revision because nix flakes have their own mechanism
  # for determining the git revision, and they don't have the git repo present
  # to determine it off of the normal way.
  revision ? null,

  releaseName ? "dev",
  buildNumber ? "1",
}: let

  pkgs = pkgsNix.default {
    inherit buildSystem hostSystem;
  };

  pkgsNative = pkgsNix.default {
    inherit buildSystem;
    hostSystem = buildSystem;
  };

  garageNix = (import ./nix/garage);

in rec {

  revisionFile = if builtins.isNull revision
    then pkgsNative.stdenv.mkDerivation {
      name = "revision.txt";
      nativeBuildInputs = [ pkgsNative.git ];
      src = ./.git;
      phases = [ "installPhase" ];
      installPhase = ''
        git -c safe.directory='*' -C $src describe --tags > $out
      '';
    }
    else pkgsNative.writeText "revision.txt" revision;

  version = pkgs.stdenv.mkDerivation {
    name = "isle-version";

    inherit buildSystem hostSystem revisionFile;

    goVersion = pkgs.go.version;
    garageVersion = garageNix.version;
    nixpkgsVersion = pkgsNix.version;

    builder = builtins.toFile "builder.sh" ''
      source $stdenv/setup

      versionFile=version

      echo "Version:         $(cat $revisionFile)" >> "$versionFile"
      echo "Platform:        $hostSystem"          >> "$versionFile"
      echo "Go Version:      $goVersion"           >> "$versionFile"
      echo "Garage Version:  $garageVersion"       >> "$versionFile"
      echo "NixPkgs Version: $nixpkgsVersion"      >> "$versionFile"
      echo "Build Platform:  $buildSystem"         >> "$versionFile"

      mkdir -p "$out"
      cp "$versionFile" "$out"/version
    '';
  };

  entrypoint = {
    systemRoot ? null,
  }: (pkgs.buildGoModule {
    pname = "isle-entrypoint";
    version = builtins.readFile revisionFile;

    # If this seems pointless, that's because it is! buildGoModule doesn't like
    # it if the src derivation's name ends in "-go". So this mkDerivation here
    # only serves to give buildGoModule a src derivation with a name it likes.
    src = pkgs.runCommand "isle-go-src" {} ''cp -r "${./go}" "$out"'';

    vendorHash = "sha256-uq+UgoVKqMUE4hEVlMFQnZuyFOilUyZDmiy7ASrq338=";
    subPackages = [ "./cmd/entrypoint" ];
  }).overrideAttrs (prev: {
    ldflags = prev.ldflags ++
      (if builtins.isNull systemRoot
      then []
      else [ "-X main.systemRoot=${systemRoot}" ]);
  });

  dnsmasq = (pkgs.callPackage ./nix/dnsmasq.nix {
    stdenv = pkgs.pkgsStatic.stdenv;
  });

  nebula = pkgs.callPackage ./nix/nebula.nix {};

  garage = garageNix.package {
    inherit pkgsNix buildSystem hostSystem;
  };

  appDirBase = pkgs.runCommand "isle-AppDir-base" {} ''
    mkdir -p "$out"/usr/libexec/isle
    cp ${dnsmasq}/bin/* "$out"/usr/libexec/isle
    cp ${nebula}/bin/* "$out"/usr/libexec/isle
    cp ${garage}/bin/* "$out"/usr/libexec/isle
    cp ${pkgs.minio-client}/bin/* "$out"/usr/libexec/isle

    cp ${./AppDir}/* "$out"/

    mkdir -p "$out"/usr/share/isle
    cp ${version}/* "$out"/usr/share/isle
  '';

  appDir = { systemRoot ? null, }: pkgs.stdenv.mkDerivation {
    name = "isle-AppDir";

    src = appDirBase;
    entrypoint = entrypoint { inherit systemRoot; };

    builder = builtins.toFile "build.sh" ''
      source $stdenv/setup
      cp -rL "$src" "$out"
      chmod +w "$out" -R

      cd "$out"
      mkdir -p ./usr/bin
      cp $entrypoint/bin/entrypoint ./usr/bin/isle
      ln -s ./usr/bin/isle ./AppRun
    '';
  };

  devShell = pkgs.mkShell {
    buildInputs = [
      pkgs.go
      pkgs.golangci-lint
      pkgs.gopls
      (pkgs.callPackage ./nix/gowrap.nix {})
      pkgs.go-mockery
    ];
    shellHook = ''
      true # placeholder
    '';
  };

  testShell = pkgs.mkShell {
    APPDIR = appDirBase;
    buildInputs = [
      pkgs.go
    ];
  };

  appimagekit = pkgsNative.callPackage ./nix/appimagetool {
    inherit hostSystem;
  };

  build = rec {

    appImage = pkgs.stdenv.mkDerivation {
      name = "isle-AppImage";
      src = appDir {};
      inherit revisionFile;

      nativeBuildInputs = [ appimagekit ];

      builder = builtins.toFile "build.sh" ''
        source $stdenv/setup
        cp -rL "$src" isle.AppDir
        chmod +w isle.AppDir -R

        export VERSION=$(cat $revisionFile)
        mkdir -p "$out"/bin
        appimagetool ./isle.AppDir "$out"/bin/isle
      '';
    };

    archPkg = ((import ./dist/linux/arch) {
      inherit hostSystem releaseName buildNumber;
      pkgs = pkgsNative;
      appDir = appDir { systemRoot = "/"; };
    });

    debPkg = ((import ./dist/linux/deb) {
      inherit hostSystem releaseName buildNumber;
      pkgs = pkgsNative;
      appDir = appDir { systemRoot = "/"; };
    });
  };
}