core/pkgs/build-support/release/default.nix

{ lib, pkgs }:

let
  inherit (lib) optionalString;

  inherit (pkgs)
    autoconf automake checkinstall clang-analyzer cov-build
    enableGCOVInstrumentation lcov libtool makeGCOVReport runCommand stdenv
    vmTools xz;

in rec {

  sourceTarball = args:
    import ./source-tarball.nix
    ({ inherit lib stdenv autoconf automake libtool; } // args);

  makeSourceTarball = sourceTarball; # compatibility

  binaryTarball = args:
    import ./binary-tarball.nix ({ inherit lib stdenv; } // args);

  mvnBuild = args: import ./maven-build.nix ({ inherit lib stdenv; } // args);

  nixBuild = args: import ./nix-build.nix ({ inherit lib stdenv; } // args);

  coverageAnalysis = args:
    nixBuild ({
      inherit lcov enableGCOVInstrumentation makeGCOVReport;
      doCoverageAnalysis = true;
    } // args);

  clangAnalysis = args:
    nixBuild ({
      inherit clang-analyzer;
      doClangAnalysis = true;
    } // args);

  coverityAnalysis = args:
    nixBuild ({
      inherit cov-build xz;
      doCoverityAnalysis = true;
    } // args);

  rpmBuild = args: import ./rpm-build.nix ({ inherit lib vmTools; } // args);

  debBuild = args:
    import ./debian-build.nix
    ({ inherit lib stdenv vmTools checkinstall; } // args);

  aggregate = { name, constituents, meta ? { } }:
    pkgs.runCommand name {
      inherit constituents meta;
      preferLocalBuild = true;
      _hydraAggregate = true;
    } ''
      mkdir -p $out/nix-support
      touch $out/nix-support/hydra-build-products
      echo $constituents > $out/nix-support/hydra-aggregate-constituents

      # Propagate build failures.
      for i in $constituents; do
        if [ -e $i/nix-support/failed ]; then
          touch $out/nix-support/failed
        fi
      done
    '';

  /* Create a channel job which success depends on the success of all of
     its contituents. Channel jobs are a special type of jobs that are
     listed in the channel tab of Hydra and that can be suscribed.
     A tarball of the src attribute is distributed via the channel.

     - constituents: a list of derivations on which the channel success depends.
     - name: the channel name that will be used in the hydra interface.
     - src: should point to the root folder of the nix-expressions used by the
            channel, typically a folder containing a `default.nix`.

       channel {
         constituents = [ foo bar baz ];
         name = "my-channel";
         src = ./.;
       };
  */
  channel =
    { name, src, constituents ? [ ], meta ? { }, isNixOS ? true, ... }@args:
    stdenv.mkDerivation ({
      preferLocalBuild = true;
      _hydraAggregate = true;

      dontConfigure = true;
      dontBuild = true;

      patchPhase = optionalString isNixOS ''
        touch .update-on-nixos-rebuild
      '';

      installPhase = ''
        mkdir -p $out/{tarballs,nix-support}

        tar cJf "$out/tarballs/nixexprs.tar.xz" \
          --owner=0 --group=0 --mtime="1970-01-01 00:00:00 UTC" \
          --transform='s!^\.!${name}!' .

        echo "channel - $out/tarballs/nixexprs.tar.xz" > "$out/nix-support/hydra-build-products"
        echo $constituents > "$out/nix-support/hydra-aggregate-constituents"

        # Propagate build failures.
        for i in $constituents; do
          if [ -e "$i/nix-support/failed" ]; then
            touch "$out/nix-support/failed"
          fi
        done
      '';

      meta = meta // { isHydraChannel = true; };
    } // removeAttrs args [ "meta" ]);

}