Try #1761:

Author: iohk-bors[bot]

.buildkite/pipeline.yml

@@ -152,7 +152,7 @@ steps:
 
   - label: 'Check that evaluation of hydra jobs works without using remote builders'
     command:
-      - nix-instantiate release.nix -A required-unstable-ghc8107-x86_64-darwin-native --show-trace --builders ''
+      - nix-instantiate release.nix -A x86_64-darwin.required-unstable-ghc8107-native --show-trace --builders ''
     agents:
       system: x86_64-linux
 

build.nix

@@ -2,9 +2,6 @@
 #
 # It is separate from default.nix because that file is the public API
 # of Haskell.nix, which shouldn't have tests, etc.
-let
-  haskellNix = (import ./default.nix {});
-in
 { nixpkgs ? haskellNix.sources.nixpkgs-unstable
 , nixpkgsArgs ? haskellNix.nixpkgsArgs
 , pkgs ? import nixpkgs nixpkgsArgs
@@ -13,6 +10,7 @@ in
 , pkgsForHydra ? import nixpkgsForHydra (nixpkgsArgs // { inherit (pkgs) system; })
 , ifdLevel ? 1000
 , compiler-nix-name ? throw "No `compiler-nix-name` passed to build.nix"
+, haskellNix ? (import ./default.nix {})
 }:
 
 let

ci-lib.nix

@@ -1,6 +1,6 @@
 {
   # Generic nixpkgs, use *only* for lib functions that are stable across versions
-  pkgs ? (import ./. {}).pkgs,
+  pkgs, # ? (import ./. {}).pkgs,
   lib ? pkgs.lib
 }: rec {
   inherit (import ./dimension.nix) dimension;

ci.nix

@@ -1,19 +1,20 @@
 # 'supportedSystems' restricts the set of systems that we will evaluate for. Useful when you're evaluating
 # on a machine with e.g. no way to build the Darwin IFDs you need!
-{ supportedSystems ? [ "x86_64-linux" "x86_64-darwin" ]
-, ifdLevel ? 3
+{ ifdLevel ? 3
 # Whether or not we are evaluating in restricted mode. This is true in Hydra, but not in Hercules.
 , restrictEval ? false
 , checkMaterialization ? false
-, pkgs ? (import ./. {}).pkgs }:
+, compat
+, system
+, pkgs ? (compat { inherit system; }).pkgs }:
  let
   inherit (import ./ci-lib.nix { inherit pkgs; }) dimension platformFilterGeneric filterAttrsOnlyRecursive;
   inherit (pkgs.haskell-nix) sources;
   nixpkgsVersions = {
     "R2205" = "nixpkgs-2205";
     "unstable" = "nixpkgs-unstable";
   };
-  haskellNix = import ./default.nix { inherit checkMaterialization; };
+  haskellNix = compat { inherit checkMaterialization system; };
   nixpkgsArgs = haskellNix.nixpkgsArgs // {
     # Needed for dwarf tests
     config = haskellNix.nixpkgsArgs.config // {
@@ -52,8 +53,8 @@
         # aarch64-linux requires ghc 8.8.4
         (v != "aarch64-linux" || (
            !__elem compiler-nix-name ["ghc865" "ghc8104" "ghc810420210212" "ghc8105" "ghc8106" "ghc901" "ghc921" "ghc922"]
-        ))) supportedSystems) (v: v);
-  crossSystems = nixpkgsName: nixpkgs: compiler-nix-name: system:
+        ))) [ system ]) (v: v);
+  crossSystems = nixpkgsName: nixpkgs: compiler-nix-name:
     # We need to use the actual nixpkgs version we're working with here, since the values
     # of 'lib.systems.examples' are not understood between all versions
     let lib = nixpkgs.lib;
@@ -76,9 +77,8 @@ dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:
   let pinnedNixpkgsSrc = sources.${nixpkgs-pin};
       evalPackages = import pinnedNixpkgsSrc nixpkgsArgs;
   in dimension "GHC version" (compilerNixNames nixpkgsName evalPackages) (compiler-nix-name: {runTests}:
-    dimension "System" (systems nixpkgsName evalPackages compiler-nix-name) (systemName: system:
       let pkgs = import pinnedNixpkgsSrc (nixpkgsArgs // { inherit system; });
-          build = import ./build.nix { inherit pkgs evalPackages ifdLevel compiler-nix-name; };
+          build = import ./build.nix { inherit pkgs evalPackages ifdLevel compiler-nix-name haskellNix; };
           platformFilter = platformFilterGeneric pkgs system;
       in filterAttrsOnlyRecursive (_: v: platformFilter v && !(isDisabled v)) ({
         # Native builds
@@ -95,10 +95,10 @@ dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:
         });
       }
       //
-      dimension "Cross system" (crossSystems nixpkgsName evalPackages compiler-nix-name system) (crossSystemName: crossSystem:
+      dimension "Cross system" (crossSystems nixpkgsName evalPackages compiler-nix-name) (crossSystemName: crossSystem:
         # Cross builds
         let pkgs = import pinnedNixpkgsSrc (nixpkgsArgs // { inherit system crossSystem; });
-            build = import ./build.nix { inherit pkgs evalPackages ifdLevel compiler-nix-name; };
+            build = import ./build.nix { inherit pkgs evalPackages ifdLevel compiler-nix-name haskellNix; };
         in pkgs.recurseIntoAttrs (pkgs.lib.optionalAttrs (ifdLevel >= 1) ({
             roots = pkgs.haskell-nix.roots' compiler-nix-name ifdLevel;
             ghc = pkgs.buildPackages.haskell-nix.compiler."${compiler-nix-name}";
@@ -119,4 +119,3 @@ dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:
       ))
     )
   )
-)

flake.nix

@@ -134,6 +134,37 @@
 
       packages = ((self.internal.compat { inherit system; }).hix).apps;
 
+      ciJobs =
+        let
+          inherit (legacyPackages) lib;
+          inherit (import ./ci-lib.nix { pkgs = legacyPackagesUnstable; }) stripAttrsForHydra filterDerivations;
+          ci = import ./ci.nix { inherit (self.internal) compat; inherit system; };
+          allJobs = stripAttrsForHydra (filterDerivations ci);
+          names = x: lib.filter (n: n != "recurseForDerivations" && n != "meta")
+              (builtins.attrNames x);
+          requiredJobs =
+            builtins.listToAttrs (
+              lib.concatMap (nixpkgsVer:
+                let nixpkgsJobs = allJobs.${nixpkgsVer};
+                in lib.concatMap (compiler-nix-name:
+                  let ghcJobs = nixpkgsJobs.${compiler-nix-name};
+                  in (
+                    builtins.map (crossPlatform: {
+                      name = "required-${nixpkgsVer}-${compiler-nix-name}-${crossPlatform}";
+                      value = legacyPackages.releaseTools.aggregate {
+                        name = "haskell.nix-${nixpkgsVer}-${compiler-nix-name}-${crossPlatform}";
+                        meta.description = "All ${nixpkgsVer} ${compiler-nix-name} ${crossPlatform} jobs";
+                        constituents = lib.collect (d: lib.isDerivation d) ghcJobs.${crossPlatform};
+                      };
+                   }) (names ghcJobs))
+                ) (names nixpkgsJobs)
+              ) (names allJobs));
+        in {
+          latest = allJobs.unstable.ghc8107.native or {};
+        } // requiredJobs;
+
+      hydraJobs = ciJobs;
+
       devShells = with self.legacyPackages.${system}; {
         default =
           mkShell {

release.nix

@@ -1,70 +1,19 @@
-# 'supportedSystems' restricts the set of systems that we will evaluate for. Useful when you're evaluating
-# on a machine with e.g. no way to build the Darwin IFDs you need!
-{ supportedSystems ? [ "x86_64-linux" "x86_64-darwin" ]
-, ifdLevel ? 3
-, include ? (compiler-nix-name: true)
-, checkMaterialization ? false }:
+# TODO remove this file when we no longer need to build with the
+# non flake hydra configuration.
+{
+  supportedSystems ? ["x86_64-linux" "x86_64-darwin"],
+}: let
+  defaultNix = import ./. {};
 
-let
-  traceNames = prefix: builtins.mapAttrs (n: v:
-    if builtins.isAttrs v
-      then if v ? type && v.type == "derivation"
-        then __trace (prefix + n) v
-        else traceNames (prefix + n + ".") v
-      else v);
-  inherit (import ./ci-lib.nix { pkgs = genericPkgs; }) stripAttrsForHydra filterDerivations;
-  genericPkgs = (import ./. {}).pkgs;
-  lib = genericPkgs.lib;
-  ci = import ./ci.nix { inherit supportedSystems ifdLevel checkMaterialization; restrictEval = true; };
-  allJobs = stripAttrsForHydra (filterDerivations ci);
-  latestJobs = lib.optionalAttrs (include "ghc8107") {
-    # All the jobs are included in the `requiredJobs`, but the ones
-    # added here will also included without aggregation, making it easier
-    # to find a failing test.  Keep in mind though that adding too many
-    # of these will slow down eval times.
-    x86_64-linux = allJobs.unstable.ghc8107.x86_64-linux.native or {};
-    x86_64-darwin = allJobs.unstable.ghc8107.x86_64-darwin.native or {};
-  };
-  names = x: lib.filter (n: n != "recurseForDerivations" && n != "meta")
-    (builtins.attrNames x);
-  requiredJobs =
-    builtins.listToAttrs (
-      lib.concatMap (nixpkgsVer:
-        let nixpkgsJobs = allJobs.${nixpkgsVer};
-        in lib.concatMap (compiler-nix-name:
-          let ghcJobs = nixpkgsJobs.${compiler-nix-name};
-          in lib.optionals (include compiler-nix-name) (builtins.concatMap (platform:
-            let platformJobs = ghcJobs.${platform};
-            in builtins.map (crossPlatform: {
-              name = "required-${nixpkgsVer}-${compiler-nix-name}-${platform}-${crossPlatform}";
-              value = genericPkgs.releaseTools.aggregate {
-                name = "haskell.nix-${nixpkgsVer}-${compiler-nix-name}-${platform}-${crossPlatform}";
-                meta.description = "All ${nixpkgsVer} ${compiler-nix-name} ${platform} ${crossPlatform} jobs";
-                constituents = lib.collect (d: lib.isDerivation d) platformJobs.${crossPlatform};
-              };
-           }) (names platformJobs)
-         ) (names ghcJobs))
-        ) (names nixpkgsJobs)
-      ) (names allJobs));
-in traceNames "job " (latestJobs // requiredJobs // {
-    windows-secp256k1 =
-      let
-        pkgs = (import ./. {}).pkgs-unstable; 
-        makeBinDist = drv: pkgs.runCommand drv.name {
-          nativeBuildInputs = [ pkgs.zip ];
-        } ''
-          mkdir -p $out/nix-support
-          cp -r ${drv}/* .
-          chmod -R +w .
-          zip -r $out/${drv.name}.zip .
-          echo "file binary-dist $out/${drv.name}.zip" > $out/nix-support/hydra-build-products
-       '';
-      in makeBinDist pkgs.pkgsCross.mingwW64.secp256k1;
-    required = genericPkgs.releaseTools.aggregate {
-      name = "haskell.nix-required";
-      meta.description = "All jobs required to pass CI";
-      # Using the names here requires https://github.com/NixOS/hydra/issues/715
-      constituents = builtins.attrNames requiredJobs;
-    };
- })
+  inherit (defaultNix) pkgs;
+  inherit (pkgs) lib;
+
+  jobs = lib.getAttrs supportedSystems defaultNix.ciJobs;
 
+  required = defaultNix.pkgs.releaseTools.aggregate {
+    name = "github-required";
+    meta.description = "All jobs required to pass CI";
+    constituents = lib.collect lib.isDerivation jobs;
+  };
+in
+  jobs // { inherit required; }