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
e5a052243b
haskell.nix/ci.nix

87 lines
4.2 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;
Update ghc 8.4.4 based tools to ghc 8.6.5 (#618) Although the default ghc used by haskell.nix is ghc 8.6.5 many of the tools used in haskell.nix are still built with the boot compiler ghc 8.4.4. These include * haskell-nix.cabal-install * haskell-nix.alex * haskell-nix.happy This change updates those to ghc 8.6.5 and includes materializations for the new versions. When cabal-install is built it is careful to disable materialization checks on the version of itself used during the build to avoid infinite recursion. There was a version of nix-tools built with the boot ghc which was only used when `checkMaterialization = true`. It was used for the boot versions of alex, happy and hscolour. These have been update to use the default (ghc 8.6.5) version of nix-tools and checkMaterialization is forced off when they are being used to build ghc. This means the materialization will only be checked for these when they are built independently (they are included in the test set via haskellNixRoots). Three new arguments are added to `default.nix`: * `defaultCompilerNixName` if not specified "ghc865" is used * `checkMaterialization` makes it easier to switch on materialization checks * `system` defaults to `builtins.currentSystem` This change also moves the work needed for hydra eval to the eval system using a new `evalPackages` feature. This includes: * Fetching from git with `fetchgit` * Building scripts with `runCommand` and `writeTextFile` * `git ls-files` in `cleanGit` * running `cabal v2-configure` * copying materialized files (we are not sure why this is necessary but if we do not `cp -r` the files nix will not load them on hydra) Reduce size of `make-config-files.nix` strings by around 80%. These are unlikely to be the cause of hydra eval time memory issues in the GB range, but were still quite large (around 10MB for the `cabal-simple` test case). There was issue causing excessive builds of the `git` package when cross compiling. Gory details are a comment in `lib/defaults.nix` but in short if you use `git` you need an extra `.buildPackages` one is not enough because it depends on `gdb` and that will be different in `buildPackages` compared to `buildPackages.buildPackages`. Adds missing materialization files for ghc 8.4.4 (only needed when `checkMaterialization` is on because of other materialiazations, but good to have).
2020-05-21 02:31:26 +03:00
inherit (import ./default.nix { checkMaterialization = false; }) sources nixpkgsArgs;
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 = {
Expose our nixpkgs pins by restructuring default.nix (#514) * Remove unused (and broken) test files * Make default.nix expose pinned nixpkgs Also make `nixpkgs/default.nix` just an attribute set of sources. This is simpler, and consistent with what e.g. `niv` does. * Add backwards compatibility shim, and version argument to allow evolution in future * Fix some missed things * Fix and improve quickstart
2020-03-31 04:12:40 +03:00
"R1909" = "nixpkgs-1909";
Update nixpkgs pins to include 20.03 (#557) * Update nixpkgs pins to include 20.03, wobble - Add 20.03 - Remove 19.03 (and old 18.09 file) - Update 19.09 to latest - Update github pin to 20.03 - Remove workarounds for 19.03 * Mark openssl as allowedInsecure * Force python3 for mkdocs
2020-04-28 17:49:36 +03:00
"R2003" = "nixpkgs-2003";
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;
Update nixpkgs pins to include 20.03 (#557) * Update nixpkgs pins to include 20.03, wobble - Add 20.03 - Remove 19.03 (and old 18.09 file) - Update 19.09 to latest - Update github pin to 20.03 - Remove workarounds for 19.03 * Mark openssl as allowedInsecure * Force python3 for mkdocs
2020-04-28 17:49:36 +03:00
in lib.optionalAttrs (system == "x86_64-linux") {
# Windows cross compilation is currently broken on macOS
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 (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
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:
Expose our nixpkgs pins by restructuring default.nix (#514) * Remove unused (and broken) test files * Make default.nix expose pinned nixpkgs Also make `nixpkgs/default.nix` just an attribute set of sources. This is simpler, and consistent with what e.g. `niv` does. * Add backwards compatibility shim, and version argument to allow evolution in future * Fix some missed things * Fix and improve quickstart
2020-03-31 04:12:40 +03:00
let pinnedNixpkgsSrc = sources.${nixpkgs-pin};
# We need this for generic nixpkgs stuff at the right version
genericPkgs = import pinnedNixpkgsSrc {};
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
in dimension "System" (systems genericPkgs) (systemName: system:
Expose our nixpkgs pins by restructuring default.nix (#514) * Remove unused (and broken) test files * Make default.nix expose pinned nixpkgs Also make `nixpkgs/default.nix` just an attribute set of sources. This is simpler, and consistent with what e.g. `niv` does. * Add backwards compatibility shim, and version argument to allow evolution in future * Fix some missed things * Fix and improve quickstart
2020-03-31 04:12:40 +03:00
let pkgs = import pinnedNixpkgsSrc (nixpkgsArgs // { inherit system; });
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
build = import ./build.nix { inherit pkgs ifdLevel; };
platformFilter = platformFilterGeneric pkgs system;
remove creation of relative links in package db (#569) Changing from absolute links to relative links increases the length of the parameters passed during linking by half. For things that have many dependencies, this results in linking failing with an "argument list too long" error. Fixes #562 This change also updates the CI configuration files to help make it easier for CI to cope with this sort of change. Co-authored-by: Richard Wallace <richard.wallace@simspace.com>
2020-05-01 07:49:22 +03:00
compilers = {
inherit (pkgs.haskell-nix.compiler) ghc865 ghc883;
};
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?
remove creation of relative links in package db (#569) Changing from absolute links to relative links increases the length of the parameters passed during linking by half. For things that have many dependencies, this results in linking failing with an "argument list too long" error. Fixes #562 This change also updates the CI configuration files to help make it easier for CI to cope with this sort of change. Co-authored-by: Richard Wallace <richard.wallace@simspace.com>
2020-05-01 07:49:22 +03:00
native = pkgs.recurseIntoAttrs ({
Make it easier to access executable components (#565) This overlay helps accessing common executable components. Typically we want to make these available in a nix-shell created with shellFor. In most cases the package name will be the same as the executable, but we have a `toolPackageName` mapping to help when it is not. ``` # To get a single tool: haskell-nix.tool "cabal" "3.2.0.0" # This does the same thing as: (haskell-nix.hackage-package { name = "cabal-install" version = "3.2.0.0" }).components.exes.cabal # To get an attr set containing multiple tools: haskell-nix.tools { cabal = "3.2.0.0"; hlint = "2.2.11"; } # To add tools to a shell: shellFor { tools = { cabal = "3.2.0.0"; hlint = "2.2.11"; }; } ``` When used in shellFor the tools will be compiled with the same version of ghc used in the shell (the build ghc in the case of cross compilation). Instead of a version string we can use an attr set containing arguments that will be passed to `cabalProject`. For instance to specify the ghc used to compile. Use: ``` haskell-nix.tool "cabal" { version = "3.2.0.0"; ghc = haskell-nix.compiler.ghc883; } ```
2020-04-29 10:10:14 +03:00
inherit (build) tests tools maintainer-scripts maintainer-script-cache;
remove creation of relative links in package db (#569) Changing from absolute links to relative links increases the length of the parameters passed during linking by half. For things that have many dependencies, this results in linking failing with an "argument list too long" error. Fixes #562 This change also updates the CI configuration files to help make it easier for CI to cope with this sort of change. Co-authored-by: Richard Wallace <richard.wallace@simspace.com>
2020-05-01 07:49:22 +03:00
ghc = pkgs.recurseIntoAttrs compilers;
} // pkgs.lib.optionalAttrs (ifdLevel >= 1) {
iserv-proxy = pkgs.recurseIntoAttrs (
pkgs.lib.mapAttrs (ghcName: _:
pkgs.ghc-extra-packages."${ghcName}".iserv-proxy.components.exes.iserv-proxy
) compilers);
} // pkgs.lib.optionalAttrs (ifdLevel >= 2) {
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;
remove creation of relative links in package db (#569) Changing from absolute links to relative links increases the length of the parameters passed during linking by half. For things that have many dependencies, this results in linking failing with an "argument list too long" error. Fixes #562 This change also updates the CI configuration files to help make it easier for CI to cope with this sort of change. Co-authored-by: Richard Wallace <richard.wallace@simspace.com>
2020-05-01 07:49:22 +03:00
});
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
Expose our nixpkgs pins by restructuring default.nix (#514) * Remove unused (and broken) test files * Make default.nix expose pinned nixpkgs Also make `nixpkgs/default.nix` just an attribute set of sources. This is simpler, and consistent with what e.g. `niv` does. * Add backwards compatibility shim, and version argument to allow evolution in future * Fix some missed things * Fix and improve quickstart
2020-03-31 04:12:40 +03:00
let pkgs = import pinnedNixpkgsSrc (nixpkgsArgs // { inherit system crossSystem; });
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
build = import ./build.nix { inherit pkgs ifdLevel; };
remove creation of relative links in package db (#569) Changing from absolute links to relative links increases the length of the parameters passed during linking by half. For things that have many dependencies, this results in linking failing with an "argument list too long" error. Fixes #562 This change also updates the CI configuration files to help make it easier for CI to cope with this sort of change. Co-authored-by: Richard Wallace <richard.wallace@simspace.com>
2020-05-01 07:49:22 +03:00
in pkgs.recurseIntoAttrs (pkgs.lib.optionalAttrs (ifdLevel >= 1) {
ghc = pkgs.recurseIntoAttrs compilers;
Make it easier to access executable components (#565) This overlay helps accessing common executable components. Typically we want to make these available in a nix-shell created with shellFor. In most cases the package name will be the same as the executable, but we have a `toolPackageName` mapping to help when it is not. ``` # To get a single tool: haskell-nix.tool "cabal" "3.2.0.0" # This does the same thing as: (haskell-nix.hackage-package { name = "cabal-install" version = "3.2.0.0" }).components.exes.cabal # To get an attr set containing multiple tools: haskell-nix.tools { cabal = "3.2.0.0"; hlint = "2.2.11"; } # To add tools to a shell: shellFor { tools = { cabal = "3.2.0.0"; hlint = "2.2.11"; }; } ``` When used in shellFor the tools will be compiled with the same version of ghc used in the shell (the build ghc in the case of cross compilation). Instead of a version string we can use an attr set containing arguments that will be passed to `cabalProject`. For instance to specify the ghc used to compile. Use: ``` haskell-nix.tool "cabal" { version = "3.2.0.0"; ghc = haskell-nix.compiler.ghc883; } ```
2020-04-29 10:10:14 +03:00
# TODO: look into making tools work when cross compiling
# inherit (build) tools;
remove creation of relative links in package db (#569) Changing from absolute links to relative links increases the length of the parameters passed during linking by half. For things that have many dependencies, this results in linking failing with an "argument list too long" error. Fixes #562 This change also updates the CI configuration files to help make it easier for CI to cope with this sort of change. Co-authored-by: Richard Wallace <richard.wallace@simspace.com>
2020-05-01 07:49:22 +03:00
} // pkgs.lib.optionalAttrs (ifdLevel >= 2) {
remote-iserv = pkgs.recurseIntoAttrs (
pkgs.lib.mapAttrs (ghcName: _:
pkgs.ghc-extra-packages."${ghcName}".remote-iserv.components.exes.remote-iserv
) compilers);
iserv-proxy = pkgs.recurseIntoAttrs (
pkgs.lib.mapAttrs (ghcName: _:
pkgs.ghc-extra-packages."${ghcName}".iserv-proxy.components.exes.iserv-proxy
) compilers);
} // pkgs.lib.optionalAttrs (ifdLevel >= 3) {
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
}
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
remove creation of relative links in package db (#569) Changing from absolute links to relative links increases the length of the parameters passed during linking by half. For things that have many dependencies, this results in linking failing with an "argument list too long" error. Fixes #562 This change also updates the CI configuration files to help make it easier for CI to cope with this sort of change. Co-authored-by: Richard Wallace <richard.wallace@simspace.com>
2020-05-01 07:49:22 +03:00
pkgs.lib.optionalAttrs (crossSystemName != "aarch64-multiplatform") {
inherit (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