ilyakooo0/haskell.nix
1
0
Fork 0
mirror of https://github.com/ilyakooo0/haskell.nix.git synced 2024-09-19 02:47:34 +03:00
Code Issues Projects Releases Wiki Activity
b4823ea2db
haskell.nix/ci.nix

65 lines
3.3 KiB
Nix
Raw Normal View History

CI: share between ci.nix and release.nix (#504) * Define release.nix in terms of ci.nix Beef up ci.nix to handle the same things as release.nix, then implement the one in terms of the other. * Fix infinite loop in evaluating release.nix with high ifdLevel * Add tests to cross-compile * Remove obsolete fix * Do generic platform filtering * Undefined variable * Extract ci-lib.nix * More undefined variables * Use filterAttrsOnlyRecursive to avoid forcing all the drv attributes * Set ifdLevel 0 to see if it fixes hydra eval * Turn off tests on aarch64 cross * Ifd level 1 * Ifd level 2 * Ifd level 3 * Maybe it's required that's too big? Co-authored-by: Hamish Mackenzie <Hamish.Mackenzie@iohk.io>
2020-03-25 14:20:58 +03:00
# 'supportedSystems' restricts the set of systems that we will evaluate for. Useful when you're evaluting
# on a machine with e.g. no way to build the Darwin IFDs you need!
{ supportedSystems ? [ "x86_64-linux" "x86_64-darwin" ]
, ifdLevel ? 3
# Whether or not we are evaluating in restricted mode. This is true in Hydra, but not in Hercules.
, restrictEval ? false }:
Overlays (#261) The Overlays branch This is a major reorganization in how haskell.nix is used, and marks our 1.0 release. The branch doesn't build due to numerous issues that we believe to be with the CI and not this branch. We expect only very minor adjustments prior to calling this the official 1.0 release. * Move iohk-nix patches into haskell.nix This moves the customizations we did in iohk-nix into haskell.nix via overlays and config. Add bootPkgs logic this moves the nuking of bootPkgs where it belongs. This should eventually still be removed and replaced by a proper solution, that doesn't require the nuking of bootPkgs. Allow us to bootstrap binary ghcs and a cabal-install With this we can do the following: ``` $ nix repl compiler/old-ghc-nix nix-repl> :b (let pkgs = import <nixpkgs> {}; in with import ./. {}; import ./compiler/bootstrap/cabal-install.nix { inherit (pkgs) fetchurl stdenv zlib; inherit hackage ; ghc = ghc844; src = pkgs.fetchurl { url = "https://github.com/haskell/cabal/archive/Cabal-v3.0.0.0-rc3.tar.gz"; sha256 = "1zl2mgg8307ykq3v8nmafc6zdhhj1cw7w8ffpap16dsm6 5lbnx33"; }; }) ``` which wile it may look daunting, will allow us to bootstrap a cabal-install with a ghc. From that point onwards, we should be able to build any hackage package via haskell.nix. Pass through cabal-install version Better threading of arguments. Add bootstrap overlay Allow alex + happy to be built This still has a wart: we need nix-tools, and for that we use the ghc865 from nixpkgs. Ideally we'd build nix-tools against a specific ghc, but then we'd need a build expression for that. Make ghcjs work Building something like this: ``` nix build '(with import ./. { nixpkgs = ../nixpkgs; nixpkgsArgs = { crossSystem = { config = "js-unknown-ghcjs"; }; }; }; (haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; })).components.exes.hello' ``` will now work. Assuming `nixpkgs` has been appropriately patched to support the `js-unknown-ghcjs` triple. Also: this will need an additional `Cabal` patch, to make `Cabal` understand what it needs to do with: `dist/build/hello/hello: copyFile: does not exist (No such file or directory)` It needs to learn that `dist/build/hello/hello.jsexe` is what it wants to copy and that that is a directory. Luckily we do have some code in Cabal already that does this for `.exe` on windows. Build `js-unknown-ghcjs` packages with haskell.nix Using the following expression: ``` with import ./. { nixpkgs = ../nixpkgs; nixpkgsArgs = { crossSystem = { config = "js-unknown-ghcjs"; }; }; }; let Cabal = buildPackages.haskell-nix.hackage-package { name = "Cabal"; version = "2.4.1.0"; modules = [ { packages.Cabal.patches = [ ./Cabal-install-folder.diff ]; } ]; }; in (haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; modules = [ ({config, ... }:{ packages.hello.package.setup-depends = [ Cabal ]; }) ];}).components.exes.hello ``` in a `test.nix` file. And running ``` nix build -f ./test.nix ``` on it, will produce ``` ./result ├── bin │ └── hello.jsexe │ ├── all.js │ ├── all.js.externs │ ├── index.html │ ├── lib.js │ ├── manifest.webapp │ ├── out.frefs.js │ ├── out.frefs.json │ ├── out.js │ ├── out.stats │ ├── rts.js │ └── runmain.js └── share └── doc └── x86_64-linux-ghc-8.6.5 └── hello-1.0.0.2 └── LICENSE 6 directories, 12 files ```
2019-10-21 15:07:58 +03:00
let
CI: share between ci.nix and release.nix (#504) * Define release.nix in terms of ci.nix Beef up ci.nix to handle the same things as release.nix, then implement the one in terms of the other. * Fix infinite loop in evaluating release.nix with high ifdLevel * Add tests to cross-compile * Remove obsolete fix * Do generic platform filtering * Undefined variable * Extract ci-lib.nix * More undefined variables * Use filterAttrsOnlyRecursive to avoid forcing all the drv attributes * Set ifdLevel 0 to see if it fixes hydra eval * Turn off tests on aarch64 cross * Ifd level 1 * Ifd level 2 * Ifd level 3 * Maybe it's required that's too big? Co-authored-by: Hamish Mackenzie <Hamish.Mackenzie@iohk.io>
2020-03-25 14:20:58 +03:00
inherit (import ./ci-lib.nix) dimension platformFilterGeneric filterAttrsOnlyRecursive;
Overlays (#261) The Overlays branch This is a major reorganization in how haskell.nix is used, and marks our 1.0 release. The branch doesn't build due to numerous issues that we believe to be with the CI and not this branch. We expect only very minor adjustments prior to calling this the official 1.0 release. * Move iohk-nix patches into haskell.nix This moves the customizations we did in iohk-nix into haskell.nix via overlays and config. Add bootPkgs logic this moves the nuking of bootPkgs where it belongs. This should eventually still be removed and replaced by a proper solution, that doesn't require the nuking of bootPkgs. Allow us to bootstrap binary ghcs and a cabal-install With this we can do the following: ``` $ nix repl compiler/old-ghc-nix nix-repl> :b (let pkgs = import <nixpkgs> {}; in with import ./. {}; import ./compiler/bootstrap/cabal-install.nix { inherit (pkgs) fetchurl stdenv zlib; inherit hackage ; ghc = ghc844; src = pkgs.fetchurl { url = "https://github.com/haskell/cabal/archive/Cabal-v3.0.0.0-rc3.tar.gz"; sha256 = "1zl2mgg8307ykq3v8nmafc6zdhhj1cw7w8ffpap16dsm6 5lbnx33"; }; }) ``` which wile it may look daunting, will allow us to bootstrap a cabal-install with a ghc. From that point onwards, we should be able to build any hackage package via haskell.nix. Pass through cabal-install version Better threading of arguments. Add bootstrap overlay Allow alex + happy to be built This still has a wart: we need nix-tools, and for that we use the ghc865 from nixpkgs. Ideally we'd build nix-tools against a specific ghc, but then we'd need a build expression for that. Make ghcjs work Building something like this: ``` nix build '(with import ./. { nixpkgs = ../nixpkgs; nixpkgsArgs = { crossSystem = { config = "js-unknown-ghcjs"; }; }; }; (haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; })).components.exes.hello' ``` will now work. Assuming `nixpkgs` has been appropriately patched to support the `js-unknown-ghcjs` triple. Also: this will need an additional `Cabal` patch, to make `Cabal` understand what it needs to do with: `dist/build/hello/hello: copyFile: does not exist (No such file or directory)` It needs to learn that `dist/build/hello/hello.jsexe` is what it wants to copy and that that is a directory. Luckily we do have some code in Cabal already that does this for `.exe` on windows. Build `js-unknown-ghcjs` packages with haskell.nix Using the following expression: ``` with import ./. { nixpkgs = ../nixpkgs; nixpkgsArgs = { crossSystem = { config = "js-unknown-ghcjs"; }; }; }; let Cabal = buildPackages.haskell-nix.hackage-package { name = "Cabal"; version = "2.4.1.0"; modules = [ { packages.Cabal.patches = [ ./Cabal-install-folder.diff ]; } ]; }; in (haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; modules = [ ({config, ... }:{ packages.hello.package.setup-depends = [ Cabal ]; }) ];}).components.exes.hello ``` in a `test.nix` file. And running ``` nix build -f ./test.nix ``` on it, will produce ``` ./result ├── bin │ └── hello.jsexe │ ├── all.js │ ├── all.js.externs │ ├── index.html │ ├── lib.js │ ├── manifest.webapp │ ├── out.frefs.js │ ├── out.frefs.json │ ├── out.js │ ├── out.stats │ ├── rts.js │ └── runmain.js └── share └── doc └── x86_64-linux-ghc-8.6.5 └── hello-1.0.0.2 └── LICENSE 6 directories, 12 files ```
2019-10-21 15:07:58 +03:00
nixpkgsVersions = {
CI: share between ci.nix and release.nix (#504) * Define release.nix in terms of ci.nix Beef up ci.nix to handle the same things as release.nix, then implement the one in terms of the other. * Fix infinite loop in evaluating release.nix with high ifdLevel * Add tests to cross-compile * Remove obsolete fix * Do generic platform filtering * Undefined variable * Extract ci-lib.nix * More undefined variables * Use filterAttrsOnlyRecursive to avoid forcing all the drv attributes * Set ifdLevel 0 to see if it fixes hydra eval * Turn off tests on aarch64 cross * Ifd level 1 * Ifd level 2 * Ifd level 3 * Maybe it's required that's too big? Co-authored-by: Hamish Mackenzie <Hamish.Mackenzie@iohk.io>
2020-03-25 14:20:58 +03:00
"R1903" = "release-19.03";
"R1909" = "release-19.09";
Overlays (#261) The Overlays branch This is a major reorganization in how haskell.nix is used, and marks our 1.0 release. The branch doesn't build due to numerous issues that we believe to be with the CI and not this branch. We expect only very minor adjustments prior to calling this the official 1.0 release. * Move iohk-nix patches into haskell.nix This moves the customizations we did in iohk-nix into haskell.nix via overlays and config. Add bootPkgs logic this moves the nuking of bootPkgs where it belongs. This should eventually still be removed and replaced by a proper solution, that doesn't require the nuking of bootPkgs. Allow us to bootstrap binary ghcs and a cabal-install With this we can do the following: ``` $ nix repl compiler/old-ghc-nix nix-repl> :b (let pkgs = import <nixpkgs> {}; in with import ./. {}; import ./compiler/bootstrap/cabal-install.nix { inherit (pkgs) fetchurl stdenv zlib; inherit hackage ; ghc = ghc844; src = pkgs.fetchurl { url = "https://github.com/haskell/cabal/archive/Cabal-v3.0.0.0-rc3.tar.gz"; sha256 = "1zl2mgg8307ykq3v8nmafc6zdhhj1cw7w8ffpap16dsm6 5lbnx33"; }; }) ``` which wile it may look daunting, will allow us to bootstrap a cabal-install with a ghc. From that point onwards, we should be able to build any hackage package via haskell.nix. Pass through cabal-install version Better threading of arguments. Add bootstrap overlay Allow alex + happy to be built This still has a wart: we need nix-tools, and for that we use the ghc865 from nixpkgs. Ideally we'd build nix-tools against a specific ghc, but then we'd need a build expression for that. Make ghcjs work Building something like this: ``` nix build '(with import ./. { nixpkgs = ../nixpkgs; nixpkgsArgs = { crossSystem = { config = "js-unknown-ghcjs"; }; }; }; (haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; })).components.exes.hello' ``` will now work. Assuming `nixpkgs` has been appropriately patched to support the `js-unknown-ghcjs` triple. Also: this will need an additional `Cabal` patch, to make `Cabal` understand what it needs to do with: `dist/build/hello/hello: copyFile: does not exist (No such file or directory)` It needs to learn that `dist/build/hello/hello.jsexe` is what it wants to copy and that that is a directory. Luckily we do have some code in Cabal already that does this for `.exe` on windows. Build `js-unknown-ghcjs` packages with haskell.nix Using the following expression: ``` with import ./. { nixpkgs = ../nixpkgs; nixpkgsArgs = { crossSystem = { config = "js-unknown-ghcjs"; }; }; }; let Cabal = buildPackages.haskell-nix.hackage-package { name = "Cabal"; version = "2.4.1.0"; modules = [ { packages.Cabal.patches = [ ./Cabal-install-folder.diff ]; } ]; }; in (haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; modules = [ ({config, ... }:{ packages.hello.package.setup-depends = [ Cabal ]; }) ];}).components.exes.hello ``` in a `test.nix` file. And running ``` nix build -f ./test.nix ``` on it, will produce ``` ./result ├── bin │ └── hello.jsexe │ ├── all.js │ ├── all.js.externs │ ├── index.html │ ├── lib.js │ ├── manifest.webapp │ ├── out.frefs.js │ ├── out.frefs.json │ ├── out.js │ ├── out.stats │ ├── rts.js │ └── runmain.js └── share └── doc └── x86_64-linux-ghc-8.6.5 └── hello-1.0.0.2 └── LICENSE 6 directories, 12 files ```
2019-10-21 15:07:58 +03:00
};
CI: share between ci.nix and release.nix (#504) * Define release.nix in terms of ci.nix Beef up ci.nix to handle the same things as release.nix, then implement the one in terms of the other. * Fix infinite loop in evaluating release.nix with high ifdLevel * Add tests to cross-compile * Remove obsolete fix * Do generic platform filtering * Undefined variable * Extract ci-lib.nix * More undefined variables * Use filterAttrsOnlyRecursive to avoid forcing all the drv attributes * Set ifdLevel 0 to see if it fixes hydra eval * Turn off tests on aarch64 cross * Ifd level 1 * Ifd level 2 * Ifd level 3 * Maybe it's required that's too big? Co-authored-by: Hamish Mackenzie <Hamish.Mackenzie@iohk.io>
2020-03-25 14:20:58 +03:00
systems = nixpkgs: nixpkgs.lib.filterAttrs (_: v: builtins.elem v supportedSystems) {
# I wanted to take these from 'lib.systems.examples', but apparently there isn't one for linux!
linux = "x86_64-linux";
darwin = "x86_64-darwin";
Tidy ci.nix using dimension (#500) I recently came across this rather nice way of structuring build matrices for ci.nix. I think it makes the haskell.nix ci.nix a lot clearer!
2020-03-20 10:52:34 +03:00
};
CI: share between ci.nix and release.nix (#504) * Define release.nix in terms of ci.nix Beef up ci.nix to handle the same things as release.nix, then implement the one in terms of the other. * Fix infinite loop in evaluating release.nix with high ifdLevel * Add tests to cross-compile * Remove obsolete fix * Do generic platform filtering * Undefined variable * Extract ci-lib.nix * More undefined variables * Use filterAttrsOnlyRecursive to avoid forcing all the drv attributes * Set ifdLevel 0 to see if it fixes hydra eval * Turn off tests on aarch64 cross * Ifd level 1 * Ifd level 2 * Ifd level 3 * Maybe it's required that's too big? Co-authored-by: Hamish Mackenzie <Hamish.Mackenzie@iohk.io>
2020-03-25 14:20:58 +03:00
crossSystems = nixpkgsName: nixpkgs: system:
# 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;
in lib.optionalAttrs (system == "x86_64-linux" || nixpkgsName == "R1903") {
# Windows cross compilation is currently broken on macOS for nixpkgs 19.09 (works on 19.03)
inherit (lib.systems.examples) mingwW64;
} // lib.optionalAttrs (system == "x86_64-linux") {
# Musl cross only works on linux
# aarch64 cross only works on linux
inherit (lib.systems.examples) musl64 aarch64-multiplatform;
Tidy ci.nix using dimension (#500) I recently came across this rather nice way of structuring build matrices for ci.nix. I think it makes the haskell.nix ci.nix a lot clearer!
2020-03-20 10:52:34 +03:00
};
Overlays (#261) The Overlays branch This is a major reorganization in how haskell.nix is used, and marks our 1.0 release. The branch doesn't build due to numerous issues that we believe to be with the CI and not this branch. We expect only very minor adjustments prior to calling this the official 1.0 release. * Move iohk-nix patches into haskell.nix This moves the customizations we did in iohk-nix into haskell.nix via overlays and config. Add bootPkgs logic this moves the nuking of bootPkgs where it belongs. This should eventually still be removed and replaced by a proper solution, that doesn't require the nuking of bootPkgs. Allow us to bootstrap binary ghcs and a cabal-install With this we can do the following: ``` $ nix repl compiler/old-ghc-nix nix-repl> :b (let pkgs = import <nixpkgs> {}; in with import ./. {}; import ./compiler/bootstrap/cabal-install.nix { inherit (pkgs) fetchurl stdenv zlib; inherit hackage ; ghc = ghc844; src = pkgs.fetchurl { url = "https://github.com/haskell/cabal/archive/Cabal-v3.0.0.0-rc3.tar.gz"; sha256 = "1zl2mgg8307ykq3v8nmafc6zdhhj1cw7w8ffpap16dsm6 5lbnx33"; }; }) ``` which wile it may look daunting, will allow us to bootstrap a cabal-install with a ghc. From that point onwards, we should be able to build any hackage package via haskell.nix. Pass through cabal-install version Better threading of arguments. Add bootstrap overlay Allow alex + happy to be built This still has a wart: we need nix-tools, and for that we use the ghc865 from nixpkgs. Ideally we'd build nix-tools against a specific ghc, but then we'd need a build expression for that. Make ghcjs work Building something like this: ``` nix build '(with import ./. { nixpkgs = ../nixpkgs; nixpkgsArgs = { crossSystem = { config = "js-unknown-ghcjs"; }; }; }; (haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; })).components.exes.hello' ``` will now work. Assuming `nixpkgs` has been appropriately patched to support the `js-unknown-ghcjs` triple. Also: this will need an additional `Cabal` patch, to make `Cabal` understand what it needs to do with: `dist/build/hello/hello: copyFile: does not exist (No such file or directory)` It needs to learn that `dist/build/hello/hello.jsexe` is what it wants to copy and that that is a directory. Luckily we do have some code in Cabal already that does this for `.exe` on windows. Build `js-unknown-ghcjs` packages with haskell.nix Using the following expression: ``` with import ./. { nixpkgs = ../nixpkgs; nixpkgsArgs = { crossSystem = { config = "js-unknown-ghcjs"; }; }; }; let Cabal = buildPackages.haskell-nix.hackage-package { name = "Cabal"; version = "2.4.1.0"; modules = [ { packages.Cabal.patches = [ ./Cabal-install-folder.diff ]; } ]; }; in (haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; modules = [ ({config, ... }:{ packages.hello.package.setup-depends = [ Cabal ]; }) ];}).components.exes.hello ``` in a `test.nix` file. And running ``` nix build -f ./test.nix ``` on it, will produce ``` ./result ├── bin │ └── hello.jsexe │ ├── all.js │ ├── all.js.externs │ ├── index.html │ ├── lib.js │ ├── manifest.webapp │ ├── out.frefs.js │ ├── out.frefs.json │ ├── out.js │ ├── out.stats │ ├── rts.js │ └── runmain.js └── share └── doc └── x86_64-linux-ghc-8.6.5 └── hello-1.0.0.2 └── LICENSE 6 directories, 12 files ```
2019-10-21 15:07:58 +03:00
haskellNixArgs = import ./.;
in
CI: share between ci.nix and release.nix (#504) * Define release.nix in terms of ci.nix Beef up ci.nix to handle the same things as release.nix, then implement the one in terms of the other. * Fix infinite loop in evaluating release.nix with high ifdLevel * Add tests to cross-compile * Remove obsolete fix * Do generic platform filtering * Undefined variable * Extract ci-lib.nix * More undefined variables * Use filterAttrsOnlyRecursive to avoid forcing all the drv attributes * Set ifdLevel 0 to see if it fixes hydra eval * Turn off tests on aarch64 cross * Ifd level 1 * Ifd level 2 * Ifd level 3 * Maybe it's required that's too big? Co-authored-by: Hamish Mackenzie <Hamish.Mackenzie@iohk.io>
2020-03-25 14:20:58 +03:00
dimension "Nixpkgs version" nixpkgsVersions (nixpkgsName: nixpkgs-pin:
# We need this for generic nixpkgs stuff at the right version
let genericPkgs = import ./nixpkgs { inherit nixpkgs-pin; };
in dimension "System" (systems genericPkgs) (systemName: system:
let pkgs = import ./nixpkgs (haskellNixArgs // { inherit nixpkgs-pin system; });
build = import ./build.nix { inherit pkgs ifdLevel; };
platformFilter = platformFilterGeneric pkgs system;
Get the hackage index tarball at runtime, not eval time (#512) * Get the hackage index tarball at runtime, not eval time * Get rid of special case for update-hackage Fixes #507.
2020-03-25 15:26:31 +03:00
in filterAttrsOnlyRecursive (_: v: platformFilter v) {
CI: share between ci.nix and release.nix (#504) * Define release.nix in terms of ci.nix Beef up ci.nix to handle the same things as release.nix, then implement the one in terms of the other. * Fix infinite loop in evaluating release.nix with high ifdLevel * Add tests to cross-compile * Remove obsolete fix * Do generic platform filtering * Undefined variable * Extract ci-lib.nix * More undefined variables * Use filterAttrsOnlyRecursive to avoid forcing all the drv attributes * Set ifdLevel 0 to see if it fixes hydra eval * Turn off tests on aarch64 cross * Ifd level 1 * Ifd level 2 * Ifd level 3 * Maybe it's required that's too big? Co-authored-by: Hamish Mackenzie <Hamish.Mackenzie@iohk.io>
2020-03-25 14:20:58 +03:00
# Native builds
# TODO: can we merge this into the general case by picking an appropriate "cross system" to mean native?
native = pkgs.recurseIntoAttrs {
inherit (build) tests maintainer-scripts maintainer-script-cache;
hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; }).components.exes.hello;
iserv-proxy = pkgs.ghc-extra-packages.ghc865.iserv-proxy.components.exes.iserv-proxy;
ghc = pkgs.recurseIntoAttrs pkgs.haskell-nix.compiler;
};
Tidy ci.nix using dimension (#500) I recently came across this rather nice way of structuring build matrices for ci.nix. I think it makes the haskell.nix ci.nix a lot clearer!
2020-03-20 10:52:34 +03:00
}
//
CI: share between ci.nix and release.nix (#504) * Define release.nix in terms of ci.nix Beef up ci.nix to handle the same things as release.nix, then implement the one in terms of the other. * Fix infinite loop in evaluating release.nix with high ifdLevel * Add tests to cross-compile * Remove obsolete fix * Do generic platform filtering * Undefined variable * Extract ci-lib.nix * More undefined variables * Use filterAttrsOnlyRecursive to avoid forcing all the drv attributes * Set ifdLevel 0 to see if it fixes hydra eval * Turn off tests on aarch64 cross * Ifd level 1 * Ifd level 2 * Ifd level 3 * Maybe it's required that's too big? Co-authored-by: Hamish Mackenzie <Hamish.Mackenzie@iohk.io>
2020-03-25 14:20:58 +03:00
dimension "Cross system" (crossSystems nixpkgsName genericPkgs system) (crossSystemName: crossSystem:
Tidy ci.nix using dimension (#500) I recently came across this rather nice way of structuring build matrices for ci.nix. I think it makes the haskell.nix ci.nix a lot clearer!
2020-03-20 10:52:34 +03:00
# Cross builds
CI: share between ci.nix and release.nix (#504) * Define release.nix in terms of ci.nix Beef up ci.nix to handle the same things as release.nix, then implement the one in terms of the other. * Fix infinite loop in evaluating release.nix with high ifdLevel * Add tests to cross-compile * Remove obsolete fix * Do generic platform filtering * Undefined variable * Extract ci-lib.nix * More undefined variables * Use filterAttrsOnlyRecursive to avoid forcing all the drv attributes * Set ifdLevel 0 to see if it fixes hydra eval * Turn off tests on aarch64 cross * Ifd level 1 * Ifd level 2 * Ifd level 3 * Maybe it's required that's too big? Co-authored-by: Hamish Mackenzie <Hamish.Mackenzie@iohk.io>
2020-03-25 14:20:58 +03:00
let pkgs = import ./nixpkgs (haskellNixArgs // { inherit nixpkgs-pin system crossSystem; });
build = import ./build.nix { inherit pkgs ifdLevel; };
Tidy ci.nix using dimension (#500) I recently came across this rather nice way of structuring build matrices for ci.nix. I think it makes the haskell.nix ci.nix a lot clearer!
2020-03-20 10:52:34 +03:00
in pkgs.recurseIntoAttrs {
CI: share between ci.nix and release.nix (#504) * Define release.nix in terms of ci.nix Beef up ci.nix to handle the same things as release.nix, then implement the one in terms of the other. * Fix infinite loop in evaluating release.nix with high ifdLevel * Add tests to cross-compile * Remove obsolete fix * Do generic platform filtering * Undefined variable * Extract ci-lib.nix * More undefined variables * Use filterAttrsOnlyRecursive to avoid forcing all the drv attributes * Set ifdLevel 0 to see if it fixes hydra eval * Turn off tests on aarch64 cross * Ifd level 1 * Ifd level 2 * Ifd level 3 * Maybe it's required that's too big? Co-authored-by: Hamish Mackenzie <Hamish.Mackenzie@iohk.io>
2020-03-25 14:20:58 +03:00
hello = (pkgs.haskell-nix.hackage-package { name = "hello"; version = "1.0.0.2"; }).components.exes.hello;
Tidy ci.nix using dimension (#500) I recently came across this rather nice way of structuring build matrices for ci.nix. I think it makes the haskell.nix ci.nix a lot clearer!
2020-03-20 10:52:34 +03:00
iserv-proxy = pkgs.ghc-extra-packages.ghc865.iserv-proxy.components.exes.iserv-proxy;
remote-iserv = pkgs.ghc-extra-packages.ghc865.remote-iserv.components.exes.remote-iserv;
}
CI: share between ci.nix and release.nix (#504) * Define release.nix in terms of ci.nix Beef up ci.nix to handle the same things as release.nix, then implement the one in terms of the other. * Fix infinite loop in evaluating release.nix with high ifdLevel * Add tests to cross-compile * Remove obsolete fix * Do generic platform filtering * Undefined variable * Extract ci-lib.nix * More undefined variables * Use filterAttrsOnlyRecursive to avoid forcing all the drv attributes * Set ifdLevel 0 to see if it fixes hydra eval * Turn off tests on aarch64 cross * Ifd level 1 * Ifd level 2 * Ifd level 3 * Maybe it's required that's too big? Co-authored-by: Hamish Mackenzie <Hamish.Mackenzie@iohk.io>
2020-03-25 14:20:58 +03:00
//
# Tests are broken on aarch64 cross https://github.com/input-output-hk/haskell.nix/issues/513
pkgs.lib.optionalAttrs (crossSystemName != "aarch64-multiplatform") build.tests
Tidy ci.nix using dimension (#500) I recently came across this rather nice way of structuring build matrices for ci.nix. I think it makes the haskell.nix ci.nix a lot clearer!
2020-03-20 10:52:34 +03:00
)
)
)
Reference in New Issue Copy Permalink