[DDW-1223] Switch from Cicero to Hydra, cleaning up flake.nix a bit

Author: michalrus

.buildkite/pipeline.yml

@@ -36,7 +36,7 @@ steps:
       system: x86_64-linux
 
   - label: 'daedalus-x86_64-windows'
-    command: 'nix </dev/null run --no-accept-flake-config -L .#packages.x86_64-windows.buildkitePipeline'
+    command: 'nix </dev/null run --no-accept-flake-config -L .#packages.x86_64-linux.buildkitePipeline-x86_64-windows'
     agents:
       queue: lace
       system: x86_64-linux

README.md

@@ -230,25 +230,25 @@ It is possible to build, and run just the Daedalus package, that would be bundle
 
 Build:
 
-    nix build -L .#package.mainnet
+    nix build -L .#daedalus-mainnet
 
 Run:
 
-    nix run -L .#package.mainnet
+    nix run -L .#daedalus-mainnet
 
 ### macOS (Intel, and Apple Silicon)
 
 Build:
 
-    nix build -L .#package.mainnet
+    nix build -L .#daedalus-mainnet
 
 Run:
 
-    nix run -L .#package.mainnet
+    nix run -L .#daedalus-mainnet
 
 If you want to run an Intel build from an Apple Silicon machine:
 
-    nix run -L .#packages.x86_64-darwin.package.mainnet
+    nix run -L .#packages.x86_64-darwin.daedalus-mainnet
 
 ## Installers
 
@@ -260,26 +260,26 @@ These commands require [Nix](https://nixos.org/nix/), optionally configured with
 
 Run this from a Linux machine:
 
-    nix build -L .#installer.mainnet
+    nix build -L .#installer-mainnet
 
 The result can be found at `result/daedalus-*.bin`.
 
 ### Windows
 
 Run this from a Linux machine (cross-building):
 
-    nix build -L .#packages.x86_64-windows.installer.mainnet
+    nix build -L .#installer-mainnet-x86_64-windows
 
 The result will can be found at `result/daedalus-*.exe`.
 
 ### macOS (Intel, and Apple Silicon)
 
 Run this from a macOS machine:
 
-    nix build -L .#installer.mainnet
+    nix build -L .#installer-mainnet
 
 If you want to build an Intel version from an Apple Silicon machine:
 
-    nix build -L .#packages.x86_64-darwin.installer.mainnet
+    nix build -L .#packages.x86_64-darwin.installer-mainnet
 
 The result can be found at `result/daedalus-*.pkg`.

flake.nix

@@ -16,41 +16,47 @@
   };
 
   outputs = inputs: let
-    sourceLib = import ./nix/source-lib.nix { inherit inputs; };
-    inherit (sourceLib) forEachCluster;
+    supportedSystems = ["x86_64-linux" "x86_64-darwin" "aarch64-darwin"];
+    inherit (inputs.nixpkgs) lib;
   in {
+    internal = import ./nix/internal.nix { inherit inputs; };
 
-    packages = __mapAttrs (targetSystem: definition: rec {
-      internal = forEachCluster (cluster: import definition { inherit inputs cluster targetSystem; });
-      package = __mapAttrs (_: a: a.package) internal;
-      installer = __mapAttrs (_: a: a.unsignedInstaller) internal;
-      default = package.mainnet;
-      makeSignedInstaller = __mapAttrs (_: a: a.makeSignedInstaller) internal;
-      buildkitePipeline = import ./nix/buildkite-pipeline.nix { inherit inputs targetSystem; };
-    }) {
-      x86_64-linux = ./nix/x86_64-linux.nix;
-      x86_64-windows = ./nix/x86_64-windows.nix;
-      x86_64-darwin = ./nix/any-darwin.nix;
-      aarch64-darwin = ./nix/any-darwin.nix;
-    };
+    packages = lib.genAttrs supportedSystems (buildSystem:
+      import ./nix/packages.nix { inherit inputs buildSystem; }
+    );
+
+    defaultPackage = __mapAttrs (_: a: a.default) inputs.self.packages;
 
-    devShells = sourceLib.forEach [ "x86_64-linux" "x86_64-darwin" "aarch64-darwin" ] (system:
-      let all = forEachCluster (cluster: import ./nix/old-shell.nix { inherit inputs system cluster; });
+    devShells = lib.genAttrs supportedSystems (
+      system: let
+        all = lib.genAttrs inputs.self.internal.installerClusters (
+          cluster: import ./nix/internal/old-shell.nix { inherit inputs system cluster; }
+        );
       in all // { default = all.mainnet; }
     );
 
-    # Compatibility with older Nix:
-    defaultPackage = __mapAttrs (_: a: a.default) inputs.self.outputs.packages;
-    devShell = __mapAttrs (_: a: a.default) inputs.self.outputs.devShells;
+    devShell = __mapAttrs (_: a: a.default) inputs.self.devShells;
 
-  }
-  // (import ./nix/cicero.nix {inherit inputs;});
+    hydraJobs = {
+      installer = lib.genAttrs (supportedSystems ++ ["x86_64-windows"]) (
+        targetSystem: lib.genAttrs inputs.self.internal.installerClusters (
+          cluster: inputs.self.internal.${targetSystem}.${cluster}.unsignedInstaller
+        )
+      );
+      devshell = lib.genAttrs supportedSystems (system: inputs.self.devShells.${system}.default);
+      required = inputs.nixpkgs.legacyPackages.x86_64-linux.releaseTools.aggregate {
+        name = "github-required";
+        meta.description = "All jobs required to pass CI";
+        constituents =
+          lib.collect lib.isDerivation inputs.self.hydraJobs.installer
+          ++ lib.collect lib.isDerivation inputs.self.hydraJobs.devshell;
+      };
+    };
+  };
 
-  # --- Flake Local Nix Configuration ----------------------------
   nixConfig = {
     extra-substituters = ["https://cache.iog.io"];
     extra-trusted-public-keys = ["hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ="];
     allow-import-from-derivation = "true";
   };
-  # --------------------------------------------------------------
 }

installer-clusters-available.cfg

@@ -0,0 +1,15 @@
+{ inputs }:
+
+let
+  inherit (inputs.nixpkgs) lib;
+  inherit (import ./internal/source-lib.nix { inherit inputs; }) installerClusters;
+in
+
+(__mapAttrs (targetSystem: src: lib.genAttrs installerClusters (cluster: import src {
+  inherit inputs targetSystem cluster;
+})) {
+  x86_64-linux = ./internal/x86_64-linux.nix;
+  x86_64-windows = ./internal/x86_64-windows.nix;
+  x86_64-darwin = ./internal/any-darwin.nix;
+  aarch64-darwin = ./internal/any-darwin.nix;
+}) // { inherit installerClusters; }

nix/cicero.nix

@@ -249,7 +249,7 @@ in rec {
         --install-location /Applications \
         ${lib.escapeShellArg (installerName + ".phase1.pkg")}
       rm -r "$workDir/$appName"
-      /usr/bin/productbuild --product ${../installers/data/plist} \
+      /usr/bin/productbuild --product ${../../installers/data/plist} \
         --package *.phase1.pkg \
         ${lib.escapeShellArg (installerName + ".phase2.pkg")}
       rm *.phase1.pkg

nix/internal.nix

@@ -2,13 +2,20 @@
 
 let
 
-  inherit (inputs.self.outputs.packages.${targetSystem}.internal.mainnet.oldCode.pkgs)
-    lib writeShellScriptBin;
-  inherit (import ./source-lib.nix { inherit inputs; }) installerClusters;
+  buildSystem = {
+    x86_64-windows = "x86_64-linux";
+  }.${targetSystem} or targetSystem;
+
+  targetSuffix = if buildSystem == targetSystem then "" else "-${targetSystem}";
+
+  pkgs = inputs.nixpkgs.legacyPackages.${buildSystem};
+
+  inherit (pkgs) lib;
+  inherit (inputs.self.internal) installerClusters;
 
 in
 
-writeShellScriptBin "buildkite-pipeline" ''
+pkgs.writeShellScriptBin "buildkite-pipeline" ''
   set -o errexit
   set -o pipefail
 
@@ -61,15 +68,15 @@ writeShellScriptBin "buildkite-pipeline" ''
 
     (
       set -x
-      nix build --no-accept-flake-config -L --out-link "$result" .#packages.${targetSystem}.installer.${cluster}
+      nix build --no-accept-flake-config -L --out-link "$result" .#packages.${buildSystem}.installer-${cluster}${targetSuffix}
     ) 2>&1 | cat
 
     echo "Built: $(readlink "$result")"
 
     if [ -n "''${BUILDKITE_JOB_ID:-}" ]; then
       ${if targetSystem == "x86_64-darwin" || targetSystem == "aarch64-darwin" then ''
         echo '~~~ Signing installer for cluster ‘${cluster}’'
-        nix run -L .#packages.${targetSystem}.makeSignedInstaller.${cluster} | tee make-installer.log
+        nix run -L .#packages.${buildSystem}.makeSignedInstaller-${cluster}${targetSuffix} | tee make-installer.log
         rm "$result"
         mkdir -p "$result"
         mv $(tail -n 1 make-installer.log) "$result"/