← Back to branch summary

~ubuntu-branches/ubuntu/trusty/coccinelle/trusty

« back to all changes in this revision

Viewing changes to release.nix

  • Committer: Package Import Robot
  • Author(s): Євгеній Мещеряков
  • Date: 2012-08-19 20:40:52 UTC
  • mfrom: (7.2.8 experimental)
  • Revision ID: package-import@ubuntu.com-20120819204052-8cujknwy6cn8a6h6
Tags: 1.0.0~rc15.deb-1
* New upstream RC 
  - Do not build-depend on libsexplib-camlp4-dev and libextlib-ocaml-dev
    anymore

Show diffs side-by-side

added added

removed removed

Lines of Context:
release.nix
1
1
# Hydra build file for coccinelle
2
2
 
3
 
{ nixpkgs ? /etc/nixos/nixpkgs
 
3
{ nixpkgs ? "/etc/nixos/nixpkgs"
4
4
, cocciSrc ? { outPath = ./.; revCount = 1234; gitTag = "abcdef"; }
5
5
, testsSrc ? { outPath = ../big-tests; rev = 1234; }
6
6
, officialRelease ? false
7
 
, performRegress ? false
 
7
, performRegress ? true
8
8
}:
9
9
 
10
10
 
47
47
      postDist = ''
48
48
        export HOME=$PREVHOME  # restore the home directory
49
49
 
50
 
        ensureDir "$out/tarballs"
 
50
        mkdir -p "$out/tarballs"
51
51
 
52
52
        # rename the tarball to give it a version-specific name
53
53
        cp coccinelle-*.tar.gz "$out/tarballs/coccinelle-${version}${versionSuffix}.tar.gz"
56
56
 
57
57
 
58
58
  #
 
59
  # Helper functions for building configurations
 
60
  #
 
61
 
 
62
  selOcamlDefault = orig: orig.ocamlPackages;
 
63
  selOcaml400 = orig: orig.ocamlPackages_4_00_0;
 
64
  selOcaml312 = orig: orig.ocamlPackages_3_12_1;
 
65
  selOcaml311 = orig: orig.ocamlPackages_3_11_2;
 
66
  selOcaml310 = orig: orig.ocamlPackages_3_10_0;
 
67
 
 
68
  selCommonOcamlPkgs = ocamlPackages: with ocamlPackages; [
 
69
    findlib menhir ocaml_sexplib
 
70
  ];
 
71
 
 
72
  selMinimalOcamlPkgs = ocamlPackages: with ocamlPackages; [
 
73
    findlib menhir
 
74
  ];
 
75
 
 
76
  selAllOcamlPkgs = ocamlPackages: with ocamlPackages; [
 
77
    findlib menhir ocaml_sexplib ocaml_pcre pycaml
 
78
  ];
 
79
 
 
80
  selCommonInputs = pkgs: [ pkgs.pkgconfig pkgs.pcre ];
 
81
 
 
82
  selDefaultShell = pkgs: pkgs.stdenv.shell;
 
83
 
 
84
  selPythonNone = pkgs: [];
 
85
  selPythonDefault = pkgs: [ pkgs.python ];
 
86
  selPython2 = pkgs: [ pkgs.python27 ];
 
87
  selPython3 = pkgs: [ pkgs.python3 ];
 
88
 
 
89
  # creates a configuration for a given python version
 
90
  mkCfgPython = f: pkgs: with (f pkgs); {
 
91
    inherit name pythons flags;
 
92
 
 
93
    ocamls = selCommonOcamlPkgs pkgs.ocamlPackages ++ [ pkgs.ocamlPackages.pycaml ];
 
94
    selOcaml = selOcamlDefault;
 
95
    extras = selCommonInputs pkgs;
 
96
    shell = selDefaultShell pkgs;
 
97
    extraAttrs = { };
 
98
  };
 
99
 
 
100
  # creates a configuration for a given ocaml version
 
101
  mkCfgOcaml = { name, selOcaml, flags }: pkgs: {
 
102
      inherit flags selOcaml;
 
103
 
 
104
    name = "ocaml-${name}";
 
105
    pythons = selPythonDefault pkgs;
 
106
    ocamls = selMinimalOcamlPkgs pkgs.ocamlPackages;
 
107
    extras = selCommonInputs pkgs;
 
108
    shell = selDefaultShell pkgs;
 
109
    extraAttrs = { };
 
110
  };
 
111
 
 
112
  # creates a default configuration with additional flags
 
113
  mkCfgDefault = { name, flags, extra ? {} }: pkgs: {
 
114
    inherit name flags;
 
115
    pythons = selPythonDefault pkgs;
 
116
    ocamls = selAllOcamlPkgs pkgs.ocamlPackages;
 
117
    selOcaml = selOcamlDefault;
 
118
    extras = selCommonInputs pkgs;
 
119
    shell = selDefaultShell pkgs;
 
120
    extraAttrs = extra;
 
121
  };
 
122
 
 
123
  # creates a minimal configuration with additional flags
 
124
  mkCfgMinimal = { name, flags }: pkgs: {
 
125
    inherit name flags;
 
126
    pythons = [];
 
127
    ocamls = [];
 
128
    selOcaml = selOcamlDefault;
 
129
    extras = [];
 
130
    shell = selDefaultShell pkgs;
 
131
    extraAttrs = { };
 
132
  };
 
133
 
 
134
  # creates a configuration for the given ocaml packages
 
135
  mkCfgPackage = { name, ocamls, flags }: pkgs: {
 
136
    inherit name flags;
 
137
    pythons = selPythonDefault pkgs;
 
138
    ocamls = selMinimalOcamlPkgs pkgs.ocamlPackages ++ ocamls pkgs.ocamlPackages;
 
139
    selOcaml = selOcamlDefault;
 
140
    extras = selCommonInputs pkgs;
 
141
    shell = selDefaultShell pkgs;
 
142
    extraAttrs = { };
 
143
  };
 
144
 
 
145
  # build the project using the given shell
 
146
  # it takes a minimal configuration, but then with all the
 
147
  # libraries that trigger features of coccinelle to be enabled.
 
148
  mkCfgShell = { name, selShell }: pkgs: {
 
149
    inherit name;
 
150
    pythons = selPythonDefault pkgs;
 
151
    ocamls = selMinimalOcamlPkgs pkgs.ocamlPackages;
 
152
    selOcaml = selOcamlDefault;
 
153
    flags = [];
 
154
    extras = [ pkgs.pcre ];
 
155
    shell = selShell pkgs;
 
156
    extraAttrs = { };
 
157
  };
 
158
 
 
159
  # creates a configuration with multiple ocaml versions: this gives
 
160
  # conflicts. This is just a test to see whether our build system is
 
161
  # not too much confused in this case. It seems at least that ocamlfind
 
162
  # cannot be used in this setting.
 
163
  mkCfgManyOcaml =
 
164
    let
 
165
      selOcaml = pkgs: ocamlPkgSel: with (ocamlPkgSel pkgs); ocaml;
 
166
      selPkgs = pkgs: ocamlPkgSel: with (ocamlPkgSel pkgs); [ menhir ];
 
167
    in sels: pkgs: {
 
168
      name = "many-ocaml";
 
169
      pythons = [];
 
170
      ocamls = pkgs.lib.concatMap (selPkgs pkgs) sels;
 
171
      selOcaml = selOcamlDefault;
 
172
      flags = [];
 
173
      extras = selCommonInputs pkgs ++ map (selOcaml pkgs) sels;
 
174
      shell = selDefaultShell pkgs;
 
175
      extraAttrs = { };
 
176
    };
 
177
 
 
178
 
 
179
  #
 
180
  # Configurations
 
181
  #
 
182
 
 
183
  defaultCfg = mkCfgDefault { name = "default"; flags = []; };
 
184
  debugCfg = mkCfgDefault { name = "debug"; flags = [ "--enable-release=no" ]; };
 
185
  wrappersCfg = mkCfgDefault { name = "wrappers"; flags = [ "--enable-python" "--enable-ocaml" "--without-pkg-config" "--without-ocamlfind" ]; };
 
186
  manyOcamlCfg = mkCfgManyOcaml [ selOcaml400 selOcaml312 selOcaml311 selOcaml310 ];
 
187
 
 
188
  minimalCfgs = map mkCfgMinimal [
 
189
    { name = "minimal"; flags = []; }
 
190
    { name = "noocamlscripting"; flags = [ "--disable-ocaml" ]; }
 
191
  ];
 
192
 
 
193
  # Several configurations testing different python versions.
 
194
  # We exlicitly pass the "--enable-python" flag so that the
 
195
  # build should fail if no suitable python can be detected.
 
196
  pythonCfgs = 
 
197
    map mkCfgPython [
 
198
      ( _ : { name = "no-python"; pythons = []; flags = []; })
 
199
 
 
200
      (pkgs: {
 
201
        name = "python2-local";
 
202
        pythons = selPython2 pkgs;
 
203
        flags = [ "--enable-python" "--disable-pycaml" ];
 
204
      })
 
205
 
 
206
      (pkgs: {
 
207
        name = "python3-local";
 
208
        pythons = selPython3 pkgs;
 
209
        flags = [ "--enable-python" "--disable-pycaml" ];
 
210
      })
 
211
 
 
212
      (pkgs: {
 
213
        name = "python3-global";
 
214
        pythons = selPython3 pkgs;
 
215
        flags = [ "--enable-python" ];
 
216
      })
 
217
 
 
218
      (pkgs: {
 
219
        name = "python-nopkgconfig";
 
220
        pythons = selPython2 pkgs;
 
221
        flags = [ "--enable-python" "--without-pkg-config" ];
 
222
      })
 
223
 
 
224
#  disabled because this combination does not work in NixOS
 
225
#      (pkgs: {
 
226
#        name = "many-pythons";
 
227
#        pythons = selPython3 pkgs ++ selPython2 pkgs;
 
228
#        flags = [ "--with-python=python3" ];
 
229
#      })
 
230
    ];
 
231
 
 
232
  # Several configurations testing different OCaml versions.
 
233
  # These versions ship with minimal global packages in order
 
234
  # to thest the bundled packages with these ocaml versions.
 
235
  ocamlCfgs = map mkCfgOcaml [
 
236
    { name = "400nat"; selOcaml = selOcaml400; flags = [ "--enable-release=yes" ]; }
 
237
    { name = "400byt"; selOcaml = selOcaml400; flags = []; }
 
238
    { name = "312"; selOcaml = selOcaml312; flags = []; }
 
239
    { name = "311"; selOcaml = selOcaml311; flags = [ "--enable-release=yes" ]; }
 
240
    { name = "310"; selOcaml = selOcaml310; flags = []; }
 
241
  ];
 
242
 
 
243
  # Several configurations testing different available
 
244
  # ocaml packages.
 
245
  pkgCfgs = map mkCfgPackage [
 
246
    { name = "pcre"; ocamls = ps: [ ps.ocaml_pcre ]; flags = [ "--enable-pcre-syntax" ]; }
 
247
    { name = "sexplib"; ocamls = ps: [ ps.ocaml_sexplib ]; flags = [ "--enable-sexplib" ]; }
 
248
    { name = "pycaml"; ocamls = ps: [ ps.pycaml ]; flags = [ "--enable-pycaml" ]; }
 
249
  ];
 
250
 
 
251
  shellCfgs = map mkCfgShell [
 
252
    { name = "bash"; selShell = pkgs: "${pkgs.bash}/bin/bash"; }
 
253
    { name = "dash"; selShell = pkgs: "${pkgs.dash}/bin/dash"; }
 
254
    { name = "zsh"; selShell = pkgs: "${pkgs.zsh}/bin/zsh"; }
 
255
 
 
256
    # the configure script is not compatible with tcsh
 
257
    # { name = "tcsh"; selShell = pkgs: "${pkgs.tcsh}/bin/tcsh"; }
 
258
  ];
 
259
 
 
260
  altCfgs =
 
261
    [ debugCfg manyOcamlCfg ]
 
262
    ++ minimalCfgs
 
263
    ++ ocamlCfgs ++ pythonCfgs
 
264
    ++ pkgCfgs ++ shellCfgs;
 
265
 
 
266
 
 
267
  #
59
268
  # Builds for specific configurations
60
269
  #
61
270
 
64
273
 
65
274
  # mkConfiguration is a function that takes the nix package collection of the build
66
275
  # (called 'pkgs') and results in a record containing:
67
 
  #  name of the configuration, python packages, ocaml packages selection function
68
 
  #  (which takes the original 'pkgs' as parameter), and ocaml packages. The selection
69
 
  #  function is used by 'mkConfiguration' to determine the appropriate ocamlPackages
70
 
  #  field in 'pkgs'.
 
276
  # name of the configuration, python packages, ocaml packages selection function
 
277
  # (which takes the original 'pkgs' as parameter), and ocaml packages. The selection
 
278
  # function is used by 'mkConfiguration' to determine the appropriate ocamlPackages
 
279
  # field in 'pkgs'.
71
280
  mkBuild = mkConfiguration: { system ? builtins.currentSystem }:
72
281
    let pkgs = import nixpkgs {
73
282
          inherit system;
76
285
          };
77
286
        };
78
287
        cfg = mkConfiguration pkgs;
79
 
    in with pkgs; releaseTools.nixBuild {
 
288
        flags = [ "--enable-release=world" ] ++ cfg.flags;
 
289
    in with pkgs; releaseTools.nixBuild ({
 
290
      inherit (cfg) shell;
80
291
      name = "cocci-build-${cfg.name}";
81
292
      src = tarball;
82
 
      buildInputs = [ pkgconfig pcre ncurses ocamlPackages.ocaml ] ++ cfg.ocamls ++ cfg.pythons;
83
 
      configureFlagsArray = cfg.flags ++ [ "--enable-release=world" ];
 
293
      enableParallelBuilding = true;
 
294
      buildInputs = cfg.extras ++ [ ncurses ocamlPackages.ocaml ] ++ cfg.ocamls ++ cfg.pythons;
 
295
      configureFlags = pkgs.lib.concatStringsSep " " flags; # hmm, flags are now not allowed to contain spaces
 
296
      doCheck = true;
 
297
      
84
298
      buildPhase = ''
85
299
        mkdir -p "$out/nix-support/"
86
300
        touch "$out/nix-support/make.log"
88
302
 
89
303
        make all 2> >(tee -a "$out/nix-support/make.log" >&2)
90
304
      '';
91
 
    };
 
305
 
 
306
      # changes the shell in some of the scripts to the configured one
 
307
      prePatch = ''
 
308
        echo "patching the shell in scripts to: ${cfg.shell}"
 
309
        for script in configure scripts/spatch.sh.in scripts/genversion.sh \
 
310
          setup/fake-subst.sh setup/fake-menhir.sh setup/fake-pdflatex.sh; do
 
311
          substituteInPlace $script --replace '#! /bin/sh' '#! ${cfg.shell}'
 
312
        done
 
313
      '';
 
314
    } // cfg.extraAttrs);
92
315
 
93
316
  build = mkBuild defaultCfg;
94
 
  defaultCfg = pkgs: with pkgs; {
95
 
    name = "default";
96
 
    pythons = [ python3 ];
97
 
    ocamls = with ocamlPackages; [
98
 
      findlib menhir ocaml_sexplib ocaml_extlib ocaml_pcre pycaml
99
 
    ];
100
 
    flags = [];
101
 
    selOcaml = orig: orig.ocamlPackages;
 
317
  altBuilds = map mkBuild altCfgs;
 
318
  allBuilds = [ build ] ++ altBuilds;
 
319
 
 
320
  # compile with ocaml profiling turned on and then running the
 
321
  # test suite to collect results.
 
322
  profileCfg = mkCfgDefault {
 
323
    name = "profiling";
 
324
    flags = [ "--enable-release=profile" ];
 
325
    extra = {
 
326
      installPhase = ''
 
327
        mkdir -p "$out/nix-support"
 
328
        cp ocamlprof.dump "$out/ocamlprof.dump"
 
329
        echo "file binary $out/ocamlprof.dump" >> "$out/nix-support/hydra-build-products"
 
330
      '';
 
331
    };
102
332
  };
103
 
 
104
 
 
105
 
  /*
106
 
  # selects which version of ocaml and ocamlPackages to use in nixpkgs.
107
 
  selOcaml312 = pkgs:
108
 
    { ocaml = pkgs.ocaml_3_12_1;
109
 
      ocamlPackages = pkgs.ocamlPackages_3_12_1;
110
 
    };
111
 
  selOcaml310 = pkgs:
112
 
    { ocaml = pkgs.ocaml_3_10_0;
113
 
      ocamlPackages = pkgs.ocamlPackages_3_10_0;
114
 
    };
115
 
 
116
 
  # builds an environment with the ocaml packages needed to build coccinelle
117
 
  # the mkList function selects which additional packages to include
118
 
  mkOcamlEnv = mkList: pkgs:
119
 
    pkgs.buildEnv {
120
 
      name = "cocci-ocamlenv";
121
 
      paths = with pkgs.ocamlPackages; [ pkgs.ocaml findlib menhir ] ++ mkList pkgs.ocamlPackages;
122
 
    };
123
 
 
124
 
  # selections of ocaml libraries
125
 
  libs_full = mkOcamlEnv (libs: with libs; [ ocaml_pcre ocaml_sexplib ocaml_extlib pycaml ]);
126
 
  libs_rse  = mkOcamlEnv (libs: with libs; [ ocaml_pcre ocaml_sexplib ocaml_extlib ]);
127
 
  libs_se   = mkOcamlEnv (libs: with libs; [ ocaml_sexplib ocaml_extlib ]);
128
 
  libs_null = mkOcamlEnv (libs: []);
129
 
 
130
 
  # different configurations of coccinelle builds based on different ocamls/available libraries
131
 
  build = mkBuild { name = "coccinelle"; ocamlVer = selOcaml312; mkEnv = libs_full; inclPython = true; };
132
 
  build_rse = mkBuild { name = "coccinelle_config1"; ocamlVer = selOcaml312; mkEnv = libs_rse; inclPython = true; };
133
 
  build_se = mkBuild { name = "coccinelle_config2"; ocamlVer = selOcaml312; mkEnv = libs_se; inclPython = true; };
134
 
  build_null_12 = mkBuild { name = "coccinelle_config3"; ocamlVer = selOcaml312; mkEnv = libs_null; inclPython = true; };
135
 
  # build_null_10 = mkBuild { name = "coccinelle_config4"; ocamlVer = selOcaml310; mkEnv = libs_null; inclPython = true; };
136
 
  build_null_12_np = mkBuild { name = "coccinelle_config5"; ocamlVer = selOcaml312; mkEnv = libs_null; inclPython = false; };
137
 
  # build_null_10_np = mkBuild { name = "coccinelle_config6"; ocamlVer = selOcaml310; mkEnv = libs_null; inclPython = false; };
138
 
  build_rse_np = mkBuild { name = "coccinelle_config7"; ocamlVer = selOcaml312; mkEnv = libs_rse; inclPython = false; };
139
 
  */
 
333
  profile = mkBuild profileCfg {};
140
334
 
141
335
 
142
336
  #
185
379
      phases = [ "runPhase" ];
186
380
 
187
381
      runPhase = ''
188
 
        ensureDir "$out"
189
 
        ensureDir "$out/nix-support"
 
382
        mkdir -p "$out"
 
383
        mkdir -p "$out/nix-support"
190
384
        touch "$TMPDIR/result.log"
191
385
        exec > >(tee -a "$TMPDIR/result.log") 2> >(tee -a "$TMPDIR/result.log" >&2)
192
386
        runHook execPhase
201
395
      };
202
396
    } // args // { inherit name; });
203
397
 
204
 
  mkReport = inputs: mkTask (pkgs: _: with pkgs; {
205
 
    name = "report";
206
 
    builds = map (i: i {}) inputs;
207
 
 
208
 
    execPhase = ''
209
 
      echo "collecting logs"
210
 
      for build in $builds; do
211
 
        echo "$build/nix-support/make.log"
212
 
        cat "$build/nix-support/make.log"
213
 
      done
214
 
 
215
 
      echo "grepping OCaml warnings"
216
 
      if grep -2 "Warning " "$TMPDIR/result.log"
217
 
      then
218
 
        echo "found warnings!"
219
 
        false
220
 
      else
221
 
        echo "there are apparently no significant warnings"
222
 
      fi
223
 
    '';
224
 
 
225
 
    meta = {
226
 
      description = "Analysis of the coccinelle build reports";
227
 
      schedulingPriority = 5;
228
 
    };
229
 
  });
230
 
 
231
 
  report = mkReport [ build ];
232
 
  # build_rse build_se build_null_12 build_null_12_np build_rse_np
 
398
  mkReport = inputs: mkTask (pkgs: _: with pkgs;
 
399
    let builds = map (i: i { inherit (pkgs.stdenv) system; }) inputs; in {
 
400
      name = "report";
 
401
 
 
402
      execPhase = ''
 
403
        echo "collecting logs"
 
404
        for build in ${lib.concatStringsSep " " builds}; do
 
405
          echo "log: $build/nix-support/make.log"
 
406
          cat "$build/nix-support/make.log"
 
407
        done
 
408
 
 
409
        echo "grepping OCaml warnings"
 
410
        if grep -2 "Warning " "$TMPDIR/result.log"
 
411
        then
 
412
          echo "found warnings!"
 
413
          false
 
414
        else
 
415
          echo "there are apparently no significant warnings"
 
416
        fi
 
417
      '';
 
418
 
 
419
      meta = {
 
420
        description = "Analysis of the coccinelle build reports";
 
421
        schedulingPriority = 5;
 
422
      };
 
423
    });
 
424
 
 
425
  report = mkReport allBuilds;
233
426
 
234
427
 
235
428
  #
252
445
        # as this directory contains large
253
446
        # files, we'll create links to the
254
447
        # individual files.
255
 
        ensureDir "$TMPDIR/tests"
 
448
        mkdir -p "$TMPDIR/tests"
256
449
        cp -rs ${testsSrc}/* "$TMPDIR/tests/"
257
450
        chmod -R u+w "$TMPDIR/tests/"
258
451
        cd "$TMPDIR/tests"
259
452
 
260
453
        # initialize essential environment variables
261
454
        # for the makefile
 
455
        export COCCINELLE_HOME=${coccinelle}/share/coccinelle
262
456
        export COCCIDIR=$TMPDIR
263
457
        export SPATCH=${coccinelle}/bin/spatch.opt
264
458
        export ISO=${coccinelle}/share/coccinelle/standard.iso
265
459
        export DEFS=${coccinelle}/share/coccinelle/standard.h
266
460
 
267
 
        # generate the test outcomes
268
 
        make -e all
 
461
        # generate the test outcomes using a parallel build
 
462
        make -e all -j$NIX_BUILD_CORES -l$NIX_BUILD_CORES
269
463
 
270
464
        # collect the results
271
465
        # note: the tarball is likely to contain useless
272
 
        # symbolic links to files in the nix store. So be it.
 
466
        # symbolic links to files in the nix store. We therefore
 
467
        # delete these symlinks. As a result, you should be able
 
468
        # to unpack the tarball in the tests directory.
 
469
        find "$TMPDIR/tests" -depth -type l -delete
273
470
        cd "$TMPDIR"
274
471
        tar -czf "$out/results.tar.gz" ./tests
275
472
        echo "file binary-dist $out/results.tar.gz" >> "$out/nix-support/hydra-build-products"
294
491
        # as this directory contains large
295
492
        # files, we'll create links to the
296
493
        # individual files.
297
 
        ensureDir "$TMPDIR/tests"
 
494
        mkdir -p "$TMPDIR/tests"
298
495
        cp -rs ${testsSrc}/* "$TMPDIR/tests/"
299
496
        chmod -R u+w "$TMPDIR/tests/"
300
497
 
317
514
      };
318
515
    });
319
516
 
320
 
  regress = assert performRegress; mkRegress build;
 
517
  regress = mkRegress build;
321
518
  test = checkRegress regress;
322
519
 
323
520
 
334
531
      buildInputs = with ocamlPackages; [
335
532
        pkgconfig ncurses texLiveFull
336
533
        ocaml findlib menhir
337
 
        python
 
534
        python pcre patchelf
338
535
      ];
339
 
      configureFlagsArray = [ "--enable-release=world" ];
340
 
      
 
536
      configureFlagsArray = [ "--enable-release" ];
 
537
 
341
538
      buildPhase = ''
 
539
        export TARGETDIR="$TMPDIR/dists"
 
540
        mkdir -p $TARGETDIR
342
541
        export HOME=$TMPDIR
343
 
        make prerelease GIT=echo
344
 
        make release GIT=echo
345
 
        make package
 
542
        make prerelease GIT=echo TMP=$TARGETDIR
 
543
        make release GIT=echo TMP=$TARGETDIR
 
544
        make package TMP=$TARGETDIR
346
545
      '';
347
546
 
348
547
      installPhase = ''
349
548
        mkdir -p "$out/nix-support/"
350
549
        echo "cocci-dist-${version}" > "$out/nix-support/hydra-release-name"
351
 
        cp $TMP/*.tgz "$out/"
 
550
        cp $TMPDIR/dists/*.tgz "$out/"
352
551
        for file in $out/*.tgz; do
353
552
          echo "file binary-dist $file" >> $out/nix-support/hydra-build-products
354
553
        done
365
564
  basicAttrs = {
366
565
    inherit tarball;
367
566
    inherit build;
368
 
# build_rse build_se build_null_12 build_null_12_np build_rse_np;
369
567
    inherit report;
370
568
    inherit dist;
 
569
    inherit profile;
371
570
  };
372
571
 
373
 
  testAttrs = {
 
572
  # artificial dependency on report to ensure that we are not going through
 
573
  # an expensive regression test when there is already something wrong with
 
574
  # the build process.
 
575
  reportFirst = x : if report == null then x else x;
 
576
  testAttrs = reportFirst {
374
577
    inherit regress;
375
578
    inherit test;
376
579
  };