nixpkgs/pkgs/top-level/release-lib.nix

{ supportedSystems
, packageSet ? (import ../..)
, scrubJobs ? true
, # Attributes passed to nixpkgs. Don't build packages marked as unfree.
  nixpkgsArgs ? { config = { allowUnfree = false; inHydra = true; }; }
}:

let
  lib = import ../../lib;
in with lib;

rec {

  pkgs = packageSet (lib.recursiveUpdate { system = "x86_64-linux"; config.allowUnsupportedSystem = true; } nixpkgsArgs);
  inherit lib;


  hydraJob' = if scrubJobs then hydraJob else id;


  /* !!! Hack: poor man's memoisation function.  Necessary to prevent
     Nixpkgs from being evaluated again and again for every
     job/platform pair. */
  mkPkgsFor = crossSystem: let
    packageSet' = args: packageSet (args // { inherit crossSystem; } // nixpkgsArgs);

    pkgs_x86_64_linux = packageSet' { system = "x86_64-linux"; };
    pkgs_i686_linux = packageSet' { system = "i686-linux"; };
    pkgs_aarch64_linux = packageSet' { system = "aarch64-linux"; };
    pkgs_aarch64_darwin = packageSet' { system = "aarch64-darwin"; };
    pkgs_armv6l_linux = packageSet' { system = "armv6l-linux"; };
    pkgs_armv7l_linux = packageSet' { system = "armv7l-linux"; };
    pkgs_x86_64_darwin = packageSet' { system = "x86_64-darwin"; };
    pkgs_x86_64_freebsd = packageSet' { system = "x86_64-freebsd"; };
    pkgs_i686_freebsd = packageSet' { system = "i686-freebsd"; };
    pkgs_i686_cygwin = packageSet' { system = "i686-cygwin"; };
    pkgs_x86_64_cygwin = packageSet' { system = "x86_64-cygwin"; };

    in system:
      if system == "x86_64-linux" then pkgs_x86_64_linux
      else if system == "i686-linux" then pkgs_i686_linux
      else if system == "aarch64-linux" then pkgs_aarch64_linux
      else if system == "aarch64-darwin" then pkgs_aarch64_darwin
      else if system == "armv6l-linux" then pkgs_armv6l_linux
      else if system == "armv7l-linux" then pkgs_armv7l_linux
      else if system == "x86_64-darwin" then pkgs_x86_64_darwin
      else if system == "x86_64-freebsd" then pkgs_x86_64_freebsd
      else if system == "i686-freebsd" then pkgs_i686_freebsd
      else if system == "i686-cygwin" then pkgs_i686_cygwin
      else if system == "x86_64-cygwin" then pkgs_x86_64_cygwin
      else abort "unsupported system type: ${system}";

  pkgsFor = pkgsForCross null;


  # More poor man's memoisation
  pkgsForCross = let
    examplesByConfig = lib.flip lib.mapAttrs'
      lib.systems.examples
      (_: crossSystem: nameValuePair crossSystem.config {
        inherit crossSystem;
        pkgsFor = mkPkgsFor crossSystem;
      });
    native = mkPkgsFor null;
  in crossSystem: let
    candidate = examplesByConfig.${crossSystem.config} or null;
  in if crossSystem == null
      then native
    else if candidate != null && lib.matchAttrs crossSystem candidate.crossSystem
      then candidate.pkgsFor
    else mkPkgsFor crossSystem; # uncached fallback


  # Given a list of 'meta.platforms'-style patterns, return the sublist of
  # `supportedSystems` containing systems that matches at least one of the given
  # patterns.
  #
  # This is written in a funny way so that we only elaborate the systems once.
  supportedMatches = let
      supportedPlatforms = map
        (system: lib.systems.elaborate { inherit system; })
        supportedSystems;
    in metaPatterns: let
      anyMatch = platform:
        lib.any (lib.meta.platformMatch platform) metaPatterns;
      matchingPlatforms = lib.filter anyMatch supportedPlatforms;
    in map ({ system, ...}: system) matchingPlatforms;


  assertTrue = bool:
    if bool
    then pkgs.runCommand "evaluated-to-true" {} "touch $out"
    else pkgs.runCommand "evaluated-to-false" {} "false";


  /* The working or failing mails for cross builds will be sent only to
     the following maintainers, as most package maintainers will not be
     interested in the result of cross building a package. */
  crossMaintainers = [ maintainers.viric ];


  # Generate attributes for all supported systems.
  forAllSystems = genAttrs supportedSystems;


  # Generate attributes for all sytems matching at least one of the given
  # patterns
  forMatchingSystems = metaPatterns: genAttrs (supportedMatches metaPatterns);


  /* Build a package on the given set of platforms.  The function `f'
     is called for each supported platform with Nixpkgs for that
     platform as an argument .  We return an attribute set containing
     a derivation for each supported platform, i.e. ‘{ x86_64-linux =
     f pkgs_x86_64_linux; i686-linux = f pkgs_i686_linux; ... }’. */
  testOn = testOnCross null;


  /* Similar to the testOn function, but with an additional
     'crossSystem' parameter for packageSet', defining the target
     platform for cross builds. */
  testOnCross = crossSystem: metaPatterns: f: forMatchingSystems metaPatterns
    (system: hydraJob' (f (pkgsForCross crossSystem system)));


  /* Given a nested set where the leaf nodes are lists of platforms,
     map each leaf node to `testOn [platforms...] (pkgs:
     pkgs.<attrPath>)'. */
  mapTestOn = _mapTestOnHelper id null;


  _mapTestOnHelper = f: crossSystem: mapAttrsRecursive
    (path: metaPatterns: testOnCross crossSystem metaPatterns
      (pkgs: f (getAttrFromPath path pkgs)));


  /* Similar to the testOn function, but with an additional 'crossSystem'
   * parameter for packageSet', defining the target platform for cross builds,
   * and triggering the build of the host derivation. */
  mapTestOnCross = _mapTestOnHelper
    (addMetaAttrs { maintainers = crossMaintainers; });


  /* Recursively map a (nested) set of derivations to an isomorphic
     set of meta.platforms values. */
  packagePlatforms = mapAttrs (name: value:
      if isDerivation value then
        value.meta.hydraPlatforms
          or (value.meta.platforms or [ "x86_64-linux" ])
      else if value.recurseForDerivations or false || value.recurseForRelease or false then
        packagePlatforms value
      else
        []
    );


  /* Common platform groups on which to test packages. */
  inherit (platforms) unix linux darwin cygwin all mesaPlatforms;

}