grahamc/hydra - Change VU2OLHD246DFWL2WPFSKWPLXTN3WRL25TSRU4PJMJBNWDF35OFRAC

Move most of AddBuilds to hydra-eval-jobset

Having this stuff in a separate module is a remnant of the time when hydra-server could add builds to the queue directly. This is no longer the case.

Created by Eelco Dolstra on February 21, 2017

VU2OLHD246DFWL2WPFSKWPLXTN3WRL25TSRU4PJMJBNWDF35OFRAC

Dependencies

In channels

upstream

main

Change contents

Deletion in src/lib/Hydra/Controller/API.pm at line 8 [17.24]
B:BD[17.141] → [18.0:30]
```
use Hydra::Helper::AddBuilds;
```
Deletion in src/lib/Hydra/Controller/Admin.pm at line 8 [19.1]
B:BD[19.154] → [20.0:30]
```
use Hydra::Helper::AddBuilds;
```
Deletion in src/lib/Hydra/Controller/Build.pm at line 9 [21.1]
B:BD[21.156] → [22.0:30]
```
use Hydra::Helper::AddBuilds;
```
Deletion in src/lib/Hydra/Helper/AddBuilds.pm at line 7 [22.2663]
∅:D[23.1945] → [24.1290:1304]
B:BD[22.2735] → [24.1290:1304]
```
use IPC::Run;
```

Replacement in src/lib/Hydra/Helper/AddBuilds.pm at line 22 [22.2663]

B:BD[25.18] → [26.576:624]

B:BD[26.624] → [27.710:769]

    fetchInput evalJobs checkBuild inputsToArgs
    restartBuild getPrevJobsetEval updateDeclarativeJobset

[25.18]

[27.769]

    updateDeclarativeJobset

Deletion in src/lib/Hydra/Helper/AddBuilds.pm at line 25 [22.2663]

B:BD[22.3175] → [28.0:1]

∅:D[28.1] → [22.3175:3176]

B:BD[22.3175] → [22.3175:3176]

∅:D[28.3] → [22.3177:3502]

B:BD[22.3177] → [22.3177:3502]

B:BD[22.3502] → [14.0:82]

∅:D[29.68] → [22.3568:4413]

∅:D[30.70] → [22.3568:4413]

∅:D[14.82] → [22.3568:4413]

B:BD[22.3568] → [22.3568:4413]

∅:D[31.3727] → [32.262:265]

B:BD[22.8701] → [32.262:265]

B:BD[32.265] → [31.3728:3729]

∅:D[31.3729] → [32.265:287]

B:BD[32.265] → [32.265:287]

B:BD[32.287] → [33.165:218]

∅:D[33.218] → [22.8707:8708]

∅:D[32.347] → [22.8707:8708]

B:BD[22.8707] → [22.8707:8708]

B:BD[22.8708] → [34.110:129]

∅:D[34.129] → [22.8900:8901]

∅:D[31.3879] → [22.8900:8901]

B:BD[22.8900] → [22.8900:8901]

B:BD[22.8901] → [34.130:783]

∅:D[34.783] → [22.9287:9288]

∅:D[31.4242] → [22.9287:9288]

B:BD[22.9287] → [22.9287:9288]

B:BD[22.9288] → [4.0:87]

∅:D[4.87] → [22.9475:9476]

∅:D[35.87] → [22.9475:9476]

∅:D[36.126] → [22.9475:9476]

∅:D[31.4414] → [22.9475:9476]

B:BD[22.9475] → [22.9475:9476]

B:BD[22.9476] → [31.4415:4492]

∅:D[31.4492] → [22.9557:9558]

B:BD[22.9557] → [22.9557:9558]

B:BD[22.9558] → [31.4493:4593]

∅:D[31.4593] → [22.9666:9667]

B:BD[22.9666] → [22.9666:9667]

B:BD[22.9667] → [37.4477:4545]

∅:D[37.4545] → [31.4674:4741]

B:BD[31.4674] → [31.4674:4741]

B:BD[31.4741] → [38.0:49]

∅:D[38.49] → [39.222:223]

B:BD[31.4741] → [39.222:223]

B:BD[39.223] → [40.0:17]

∅:D[40.17] → [38.50:91]

B:BD[39.234] → [38.50:91]

∅:D[38.91] → [31.4823:4884]

∅:D[33.262] → [31.4823:4884]

∅:D[41.4807] → [31.4823:4884]

B:BD[31.4823] → [31.4823:4884]

B:BD[31.4884] → [38.92:134]

∅:D[38.175] → [31.4884:4895]

B:BD[31.4884] → [31.4884:4895]

B:BD[31.4895] → [9.0:94]

∅:D[42.50] → [40.111:138]

∅:D[9.94] → [40.111:138]

B:BD[40.111] → [40.111:138]

∅:D[40.138] → [43.134:136]

∅:D[31.4895] → [43.134:136]

B:BD[22.10008] → [43.134:136]

B:BD[43.136] → [31.4896:4897]

∅:D[31.4897] → [43.136:165]

B:BD[43.136] → [43.136:165]

B:BD[43.165] → [33.263:316]

∅:D[33.316] → [43.225:226]

B:BD[43.225] → [43.225:226]

B:BD[43.226] → [31.4898:5047]

∅:D[31.5047] → [43.387:388]

B:BD[43.387] → [43.387:388]

B:BD[43.388] → [31.5048:5182]

∅:D[31.5182] → [43.528:529]

B:BD[43.528] → [43.528:529]

B:BD[43.529] → [31.5183:5249]

B:BD[31.5249] → [2.0:80]

∅:D[2.80] → [31.5317:5323]

∅:D[41.4889] → [31.5317:5323]

B:BD[31.5317] → [31.5317:5323]


sub parseJobName {
    # Parse a job specification of the form `<project>:<jobset>:<job>
    # [attrs]'.  The project, jobset and attrs may be omitted.  The
    # attrs have the form `name = "value"'.
    my ($s) = @_;
    our $key;
    our %attrs = ();
    # hm, maybe I should stop programming Perl before it's too late...
    $s =~ / ^ (?: (?: ($projectNameRE) : )? ($jobsetNameRE) : )? ($jobNameRE) \s*
            (\[ \s* (
              ([\w]+) (?{ $key = $^N; }) \s* = \s* \"
              ([\w\-]+) (?{ $attrs{$key} = $^N; }) \"
            \s* )* \])? $
          /x
        or die "invalid job specifier `$s'";
    return ($1, $2, $3, \%attrs);
}
sub attrsToSQL {
    my ($attrs, $id) = @_;
    my $query = "1 = 1";
    foreach my $name (keys %{$attrs}) {
        my $value = $attrs->{$name};
        $name =~ /^[\w\-]+$/ or die;
        $value =~ /^[\w\-]+$/ or die;
        # !!! Yes, this is horribly injection-prone... (though
        # name/value are filtered above).  Should use SQL::Abstract,
        # but it can't deal with subqueries.  At least we should use
        # placeholders.
        $query .= " and exists (select 1 from buildinputs where build = $id and name = '$name' and value = '$value')";
    }
    return $query;
}
sub fetchInputBuild {
    my ($db, $project, $jobset, $name, $value) = @_;
    my $prevBuild;
    if ($value =~ /^\d+$/) {
        $prevBuild = $db->resultset('Builds')->find({ id => int($value) });
    } else {
        my ($projectName, $jobsetName, $jobName, $attrs) = parseJobName($value);
        $projectName ||= $project->name;
        $jobsetName ||= $jobset->name;
        # Pick the most recent successful build of the specified job.
        $prevBuild = $db->resultset('Builds')->search(
            { finished => 1, project => $projectName, jobset => $jobsetName
            , job => $jobName, buildStatus => 0 },
            { order_by => "me.id DESC", rows => 1
            , where => \ attrsToSQL($attrs, "me.id") })->single;
    }
    return () if !defined $prevBuild || !isValidPath(getMainOutput($prevBuild)->path);
    #print STDERR "input `", $name, "': using build ", $prevBuild->id, "\n";
    my $pkgNameRE = "(?:(?:[A-Za-z0-9]|(?:-[^0-9]))+)";
    my $versionRE = "(?:[A-Za-z0-9\.\-]+)";
    my $relName = ($prevBuild->releasename or $prevBuild->nixname);
    my $version = $2 if $relName =~ /^($pkgNameRE)-($versionRE)$/;
    my $mainOutput = getMainOutput($prevBuild);
    my $result =
        { storePath => $mainOutput->path
        , id => $prevBuild->id
        , version => $version
        , outputName => $mainOutput->name
        };
    if (isValidPath($prevBuild->drvpath)) {
        $result->{drvPath} = $prevBuild->drvpath;
    }
    return $result;
}
sub fetchInputSystemBuild {
    my ($db, $project, $jobset, $name, $value) = @_;
    my ($projectName, $jobsetName, $jobName, $attrs) = parseJobName($value);
    $projectName ||= $project->name;
    $jobsetName ||= $jobset->name;
    my @latestBuilds = $db->resultset('LatestSucceededForJob')
        ->search({}, {bind => [$projectName, $jobsetName, $jobName]});
    my @validBuilds = ();
    foreach my $build (@latestBuilds) {
        push(@validBuilds, $build) if isValidPath(getMainOutput($build)->path);
    }

Deletion in src/lib/Hydra/Helper/AddBuilds.pm at line 26 [22.2663]
∅:D[39.236] → [31.5332:5444]
B:BD[31.5332] → [31.5332:5444]
B:BD[31.5444] → [26.674:693]
∅:D[26.693] → [31.5466:5472]
B:BD[31.5466] → [31.5466:5472]
```
    if (scalar(@validBuilds) == 0) {
        print STDERR "input `", $name, "': no previous build available\n";
        return ();
    }
```

Deletion in src/lib/Hydra/Helper/AddBuilds.pm at line 27 [22.2663]

∅:D[39.238] → [31.5477:5498]

B:BD[31.5477] → [31.5477:5498]

B:BD[31.5498] → [39.239:240]

∅:D[39.240] → [31.5503:5654]

B:BD[31.5503] → [31.5503:5654]

B:BD[31.5654] → [39.241:242]

∅:D[39.242] → [37.4546:4618]

B:BD[43.714] → [37.4546:4618]

∅:D[37.4618] → [31.5739:5810]

B:BD[31.5739] → [31.5739:5810]

B:BD[31.5810] → [39.243:244]

∅:D[39.244] → [31.5827:5847]

B:BD[31.5827] → [31.5827:5847]

B:BD[31.5847] → [41.4890:4949]

∅:D[33.364] → [31.5927:6091]

∅:D[41.4949] → [31.5927:6091]

B:BD[31.5927] → [31.5927:6091]

B:BD[31.6091] → [39.245:266]

∅:D[39.266] → [31.6137:6139]

B:BD[31.6137] → [31.6137:6139]

B:BD[31.6139] → [44.923:1014]

∅:D[44.1014] → [45.0:1]

∅:D[46.3441] → [45.0:1]

B:BD[31.7419] → [45.0:1]

B:BD[45.1] → [44.1015:2932]

∅:D[44.2932] → [32.2204:2221]

B:BD[32.2204] → [32.2204:2221]

B:BD[32.2221] → [47.111:200]

∅:D[48.89] → [49.0:16]

∅:D[47.200] → [49.0:16]

∅:D[26.764] → [49.0:16]

B:BD[32.2281] → [49.0:16]

∅:D[49.16] → [32.2281:2282]

∅:D[33.622] → [32.2281:2282]

B:BD[32.2281] → [32.2281:2282]

B:BD[32.2282] → [26.765:867]

∅:D[49.333] → [43.1515:1555]

∅:D[26.867] → [43.1515:1555]

∅:D[33.919] → [43.1515:1555]

∅:D[31.8814] → [43.1515:1555]

B:BD[32.2591] → [43.1515:1555]

B:BD[43.1555] → [26.868:948]

B:BD[26.948] → [44.2933:3042]

∅:D[49.418] → [32.2591:2597]

∅:D[26.948] → [32.2591:2597]

∅:D[33.999] → [32.2591:2597]

∅:D[43.1632] → [32.2591:2597]

∅:D[44.3042] → [32.2591:2597]

∅:D[31.8899] → [32.2591:2597]

B:BD[32.2591] → [32.2591:2597]

B:BD[32.2597] → [50.36:86]

∅:D[50.86] → [22.10051:10086]

B:BD[22.10051] → [22.10051:10086]

B:BD[22.10086] → [26.949:988]

∅:D[26.988] → [39.312:318]

B:BD[49.781] → [39.312:318]

∅:D[39.318] → [22.10146:10257]

∅:D[51.2714] → [22.10146:10257]

B:BD[22.10146] → [22.10146:10257]

B:BD[22.10257] → [26.989:1028]

∅:D[26.1028] → [39.319:325]

B:BD[49.825] → [39.319:325]

∅:D[39.325] → [22.10317:10328]

∅:D[51.2725] → [22.10317:10328]

B:BD[22.10317] → [22.10317:10328]

B:BD[22.10328] → [26.1029:1095]

B:BD[26.1095] → [3.0:84]

∅:D[3.84] → [26.1160:1341]

B:BD[26.1160] → [26.1160:1341]

∅:D[26.1341] → [22.10391:10397]

∅:D[52.2968] → [22.10391:10397]

B:BD[22.10391] → [22.10391:10397]

B:BD[22.10397] → [33.1377:1378]

B:BD[33.1378] → [48.90:156]

B:BD[48.156] → [47.201:257]

∅:D[47.257] → [48.212:218]

B:BD[48.212] → [48.212:218]

∅:D[48.218] → [49.910:931]

∅:D[26.1382] → [49.910:931]

B:BD[49.910] → [49.910:931]

B:BD[49.931] → [53.633:740]

B:BD[53.740] → [54.2832:2973]

∅:D[54.2973] → [53.863:876]

B:BD[53.863] → [53.863:876]

B:BD[53.876] → [54.2974:3000]

∅:D[54.3000] → [53.899:925]

B:BD[53.899] → [53.899:925]

∅:D[53.925] → [24.1356:1358]

∅:D[49.931] → [24.1356:1358]

∅:D[33.1425] → [24.1356:1358]

B:BD[22.10397] → [24.1356:1358]

B:BD[24.1358] → [26.1383:1384]

∅:D[26.1384] → [24.1358:1359]

B:BD[24.1358] → [24.1358:1359]

B:BD[24.1359] → [53.926:1032]

B:BD[53.1032] → [54.3001:3570]

∅:D[54.3570] → [53.1552:1565]

B:BD[53.1552] → [53.1552:1565]

B:BD[53.1565] → [54.3571:3652]

B:BD[54.3652] → [7.0:57]

∅:D[7.57] → [55.52:133]

B:BD[55.52] → [55.52:133]

∅:D[55.133] → [26.1385:1474]

B:BD[54.3652] → [26.1385:1474]

∅:D[26.1474] → [54.3652:4114]

B:BD[54.3652] → [54.3652:4114]

B:BD[54.4114] → [38.176:278]

B:BD[38.278] → [8.0:108]

∅:D[8.108] → [54.4114:4132]

∅:D[38.367] → [54.4114:4132]

B:BD[54.4114] → [54.4114:4132]

∅:D[54.4132] → [53.2077:2105]

B:BD[53.2077] → [53.2077:2105]

B:BD[53.2105] → [41.4950:4951]

∅:D[53.2105] → [24.1359:1379]

∅:D[41.4951] → [24.1359:1379]

B:BD[24.1359] → [24.1359:1379]

B:BD[24.1379] → [53.2106:2143]

∅:D[53.2143] → [24.1405:1424]

B:BD[24.1405] → [24.1405:1424]

B:BD[24.1424] → [10.0:50]

∅:D[10.50] → [56.220:293]

B:BD[24.1469] → [56.220:293]

B:BD[56.293] → [39.361:412]

∅:D[39.412] → [56.345:411]

B:BD[56.345] → [56.345:411]

∅:D[56.411] → [24.1469:1521]

B:BD[24.1469] → [24.1469:1521]

B:BD[24.1521] → [5.0:269]

∅:D[5.269] → [57.213:257]

B:BD[57.213] → [57.213:257]

B:BD[57.257] → [5.270:452]

∅:D[5.452] → [57.404:449]

B:BD[57.404] → [57.404:449]

B:BD[57.449] → [5.453:988]

∅:D[57.851] → [24.2259:2295]

∅:D[5.988] → [24.2259:2295]

B:BD[24.2259] → [24.2259:2295]

B:BD[24.2296] → [28.19:20]

B:BD[58.450] → [58.450:451]

∅:D[59.1379] → [24.2474:2489]

B:BD[24.2474] → [24.2474:2489]

B:BD[24.2489] → [53.2322:2392]

∅:D[53.2392] → [24.2548:2609]

B:BD[24.2548] → [24.2548:2609]

B:BD[24.2609] → [14.83:155]

∅:D[14.155] → [52.3249:3346]

B:BD[52.3249] → [52.3249:3346]

∅:D[52.3346] → [24.2779:2913]

B:BD[24.2779] → [24.2779:2913]

B:BD[24.2913] → [39.413:414]

B:BD[39.414] → [53.2393:2483]

B:BD[53.2528] → [53.2528:2529]

B:BD[53.2529] → [60.0:379]

B:BD[60.379] → [15.0:76]

∅:D[15.76] → [23.2016:2107]

∅:D[60.455] → [23.2016:2107]

B:BD[52.3465] → [23.2016:2107]

B:BD[23.2107] → [6.13:86]

∅:D[6.86] → [23.2163:2180]

B:BD[23.2163] → [23.2163:2180]

∅:D[61.178] → [24.3181:3211]

∅:D[23.2180] → [24.3181:3211]

∅:D[52.3549] → [24.3181:3211]

B:BD[24.3181] → [24.3181:3211]

B:BD[24.3211] → [23.2181:2233]

B:BD[25.1513] → [62.90:94]

B:BD[62.94] → [63.0:137]

∅:D[63.137] → [62.216:240]

B:BD[62.216] → [62.216:240]

B:BD[62.240] → [63.138:224]

B:BD[63.224] → [39.423:478]

∅:D[39.478] → [63.280:327]

B:BD[63.280] → [63.280:327]

∅:D[63.327] → [62.372:394]

B:BD[62.372] → [62.372:394]

∅:D[62.394] → [64.2316:2319]

∅:D[25.1513] → [64.2316:2319]

B:BD[64.2316] → [64.2316:2319]

B:BD[64.2319] → [28.25:26]

∅:D[28.26] → [24.3432:3507]

∅:D[64.2319] → [24.3432:3507]

B:BD[24.3432] → [24.3432:3507]

B:BD[24.3507] → [65.1083:1198]

∅:D[66.248] → [41.7099:7100]

∅:D[65.1198] → [41.7099:7100]

B:BD[67.186] → [41.7099:7100]

B:BD[41.7100] → [23.2234:2292]

∅:D[23.2292] → [41.7157:7193]

B:BD[41.7157] → [41.7157:7193]

∅:D[67.186] → [24.3600:3601]

∅:D[62.494] → [24.3600:3601]

∅:D[41.7193] → [24.3600:3601]

B:BD[24.3600] → [24.3600:3601]

B:BD[24.3601] → [41.7194:7402]

B:BD[41.7402] → [23.2293:2362]

∅:D[23.2362] → [41.7478:7575]

B:BD[41.7478] → [41.7478:7575]

∅:D[41.7575] → [24.3724:3725]

B:BD[24.3724] → [24.3724:3725]

B:BD[24.3860] → [24.3860:3898]

B:BD[24.3898] → [65.1199:1272]

∅:D[65.1272] → [24.4090:4091]

B:BD[24.4090] → [24.4090:4091]

B:BD[24.4186] → [24.4186:4677]

B:BD[24.4677] → [41.7576:7803]

∅:D[41.7803] → [62.495:528]

B:BD[24.4892] → [62.495:528]

B:BD[62.528] → [41.7804:7933]

∅:D[41.7933] → [68.0:57]

B:BD[62.528] → [68.0:57]

B:BD[68.57] → [54.4133:4387]

B:BD[54.4387] → [65.1273:1368]

∅:D[65.1368] → [41.8023:8172]

B:BD[41.8023] → [41.8023:8172]

∅:D[68.391] → [62.663:701]

∅:D[54.4550] → [62.663:701]

∅:D[41.8172] → [62.663:701]

B:BD[62.663] → [62.663:701]

B:BD[62.701] → [69.0:93]

∅:D[69.93] → [70.0:124]

B:BD[62.793] → [70.0:124]

∅:D[70.124] → [62.842:880]

∅:D[65.1450] → [62.842:880]

B:BD[62.842] → [62.842:880]

∅:D[62.880] → [24.5165:5175]

B:BD[24.5165] → [24.5165:5175]

B:BD[24.5175] → [67.187:279]

B:BD[67.279] → [65.1451:1523]

∅:D[65.1523] → [67.345:374]

∅:D[41.8247] → [67.345:374]

B:BD[67.345] → [67.345:374]

B:BD[67.374] → [69.94:168]

∅:D[69.168] → [67.447:477]

B:BD[67.447] → [67.447:477]

B:BD[67.477] → [39.578:579]

∅:D[39.579] → [71.411:438]

B:BD[71.411] → [71.411:438]

B:BD[71.438] → [39.580:581]

B:BD[39.581] → [11.0:98]

∅:D[11.98] → [41.9004:9045]

B:BD[39.690] → [41.9004:9045]

∅:D[39.690] → [24.5211:5250]

∅:D[62.1383] → [24.5211:5250]

∅:D[41.9045] → [24.5211:5250]

B:BD[24.5211] → [24.5211:5250]

B:BD[24.5250] → [39.691:724]

B:BD[39.724] → [11.99:329]

∅:D[11.329] → [72.261:359]

B:BD[24.5581] → [72.261:359]

∅:D[72.359] → [24.5581:5662]

B:BD[24.5581] → [24.5581:5662]

B:BD[24.5696] → [24.5696:5741]

B:BD[24.5770] → [24.5770:5872]

B:BD[24.5872] → [23.2419:2478]

B:BD[23.2478] → [73.19661:19689]

B:BD[54.4638] → [74.0:29]

B:BD[74.29] → [12.80:131]

∅:D[12.131] → [24.5872:5888]

∅:D[62.1504] → [24.5872:5888]

∅:D[54.4664] → [24.5872:5888]

B:BD[24.5872] → [24.5872:5888]

B:BD[24.5888] → [41.9046:9047]

B:BD[41.9047] → [23.2479:2569]

∅:D[23.2569] → [41.9144:9178]

B:BD[41.9144] → [41.9144:9178]

∅:D[41.9178] → [24.5888:5889]

B:BD[24.5888] → [24.5888:5889]

B:BD[24.5889] → [70.125:233]

∅:D[70.233] → [65.1593:1667]

B:BD[65.1593] → [65.1593:1667]

∅:D[65.1667] → [39.725:726]

∅:D[41.9255] → [39.725:726]

B:BD[67.546] → [39.725:726]

B:BD[39.726] → [73.19690:19799]

∅:D[73.19799] → [24.6965:6996]

B:BD[24.6965] → [24.6965:6996]

∅:D[75.3068] → [76.459:460]

∅:D[41.9374] → [76.459:460]

B:BD[76.459] → [76.459:460]

∅:D[41.9432] → [76.588:589]

B:BD[76.588] → [76.588:589]

    my @inputs = ();
    foreach my $prevBuild (@validBuilds) {
        my $pkgNameRE = "(?:(?:[A-Za-z0-9]|(?:-[^0-9]))+)";
        my $versionRE = "(?:[A-Za-z0-9\.\-]+)";
        my $relName = ($prevBuild->releasename or $prevBuild->nixname);
        my $version = $2 if $relName =~ /^($pkgNameRE)-($versionRE)$/;
        my $input =
            { storePath => getMainOutput($prevBuild)->path
            , id => $prevBuild->id
            , version => $version
            , system => $prevBuild->system
            };
        push(@inputs, $input);
    }
    return @inputs;
}
sub fetchInputEval {
    my ($db, $project, $jobset, $name, $value) = @_;
    my $eval;
    if ($value =~ /^\d+$/) {
        $eval = $db->resultset('JobsetEvals')->find({ id => int($value) });
        die "evaluation $eval->{id} does not exist\n" unless defined $eval;
    } elsif ($value =~ /^($projectNameRE):($jobsetNameRE)$/) {
        my $jobset = $db->resultset('Jobsets')->find({ project => $1, name => $2 });
        die "jobset ‘$value’ does not exist\n" unless defined $jobset;
        $eval = getLatestFinishedEval($jobset);
        die "jobset ‘$value’ does not have a finished evaluation\n" unless defined $eval;
    } elsif ($value =~ /^($projectNameRE):($jobsetNameRE):($jobNameRE)$/) {
        $eval = $db->resultset('JobsetEvals')->find(
            { project => $1, jobset => $2, hasnewbuilds => 1 },
            { order_by => "id DESC", rows => 1
            , where =>
                \ [ # All builds in this jobset should be finished...
                    "not exists (select 1 from JobsetEvalMembers m join Builds b on m.build = b.id where m.eval = me.id and b.finished = 0) "
                    # ...and the specified build must have succeeded.
                    . "and exists (select 1 from JobsetEvalMembers m join Builds b on m.build = b.id where m.eval = me.id and b.job = ? and b.buildstatus = 0)"
                  , [ 'name', $3 ] ]
            });
        die "there is no successful build of ‘$value’ in a finished evaluation\n" unless defined $eval;
    } else {
        die;
    }
    my $jobs = {};
    foreach my $build ($eval->builds) {
        next unless $build->finished == 1 && $build->buildstatus == 0;
        # FIXME: Handle multiple outputs.
        my $out = $build->buildoutputs->find({ name => "out" });
        next unless defined $out;
        # FIXME: Should we fail if the path is not valid?
        next unless isValidPath($out->path);
        $jobs->{$build->get_column('job')} = $out->path;
    }
    return { jobs => $jobs };
}
sub fetchInput {
    my ($plugins, $db, $project, $jobset, $name, $type, $value, $emailresponsible) = @_;
    my @inputs;
    if ($type eq "build") {
        @inputs = fetchInputBuild($db, $project, $jobset, $name, $value);
    }
    elsif ($type eq "sysbuild") {
        @inputs = fetchInputSystemBuild($db, $project, $jobset, $name, $value);
    }
    elsif ($type eq "eval") {
        @inputs = fetchInputEval($db, $project, $jobset, $name, $value);
    }
    elsif ($type eq "string" || $type eq "nix") {
        die unless defined $value;
        @inputs = { value => $value };
    }
    elsif ($type eq "boolean") {
        die unless defined $value && ($value eq "true" || $value eq "false");
        @inputs = { value => $value };
    }
    else {
        my $found = 0;
        foreach my $plugin (@{$plugins}) {
            @inputs = $plugin->fetchInput($type, $name, $value, $project, $jobset);
            if (defined $inputs[0]) {
                $found = 1;
                last;
            }
        }
        die "input `$name' has unknown type `$type'." unless $found;
    }
    foreach my $input (@inputs) {
        $input->{type} = $type;
        $input->{emailresponsible} = $emailresponsible;
    }
    return @inputs;
}
sub booleanToString {
    my ($exprType, $value) = @_;
    my $result;
    if ($exprType eq "guile") {
        if ($value eq "true") {
            $result = "#t";
        } else {
            $result = "#f";
        }
        $result = $value;
    } else {
        $result = $value;
    }
    return $result;
}
sub buildInputToString {
    my ($exprType, $input) = @_;
    my $result;
    if ($exprType eq "guile") {
        $result = "'((file-name . \"" . ${input}->{storePath} . "\")" .
            (defined $input->{revision} ? "(revision . \"" . $input->{revision} . "\")" : "") .
            (defined $input->{revCount} ? "(revision-count . " . $input->{revCount} . ")" : "") .
            (defined $input->{gitTag} ? "(git-tag . \"" . $input->{gitTag} . "\")" : "") .
            (defined $input->{shortRev} ? "(short-revision . \"" . $input->{shortRev} . "\")" : "") .
            (defined $input->{version} ? "(version . \"" . $input->{version} . "\")" : "") .
            ")";
    } else {
        $result = "{ outPath = builtins.storePath " . $input->{storePath} . "" .
            "; inputType = \"" . $input->{type} . "\"" .
            (defined $input->{uri} ? "; uri = \"" . $input->{uri} . "\"" : "") .
            (defined $input->{revNumber} ? "; rev = " . $input->{revNumber} . "" : "") .
            (defined $input->{revision} ? "; rev = \"" . $input->{revision} . "\"" : "") .
            (defined $input->{revCount} ? "; revCount = " . $input->{revCount} . "" : "") .
            (defined $input->{gitTag} ? "; gitTag = \"" . $input->{gitTag} . "\"" : "") .
            (defined $input->{shortRev} ? "; shortRev = \"" . $input->{shortRev} . "\"" : "") .
            (defined $input->{version} ? "; version = \"" . $input->{version} . "\"" : "") .
            (defined $input->{outputName} ? "; outputName = \"" . $input->{outputName} . "\"" : "") .
            (defined $input->{drvPath} ? "; drvPath = builtins.storePath " . $input->{drvPath} . "" : "") .
            ";}";
    }
    return $result;
}
sub inputsToArgs {
    my ($inputInfo, $exprType) = @_;
    my @res = ();
    foreach my $input (sort keys %{$inputInfo}) {
        push @res, "-I", "$input=$inputInfo->{$input}->[0]->{storePath}"
            if scalar @{$inputInfo->{$input}} == 1
               && defined $inputInfo->{$input}->[0]->{storePath};
        foreach my $alt (@{$inputInfo->{$input}}) {
            if ($alt->{type} eq "string") {
                push @res, "--argstr", $input, $alt->{value};
            }
            elsif ($alt->{type} eq "boolean") {
                push @res, "--arg", $input, booleanToString($exprType, $alt->{value});
            }
            elsif ($alt->{type} eq "nix") {
                die "input type ‘nix’ only supported for Nix-based jobsets\n" unless $exprType eq "nix";
                push @res, "--arg", $input, $alt->{value};
            }
            elsif ($alt->{type} eq "eval") {
                die "input type ‘eval’ only supported for Nix-based jobsets\n" unless $exprType eq "nix";
                my $s = "{ ";
                # FIXME: escape $_.  But dots should not be escaped.
                $s .= "$_ = builtins.storePath ${\$alt->{jobs}->{$_}}; "
                    foreach keys %{$alt->{jobs}};
                $s .= "}";
                push @res, "--arg", $input, $s;
            }
            else {
                push @res, "--arg", $input, buildInputToString($exprType, $alt);
            }
        }
    }
    return @res;
}
sub evalJobs {
    my ($inputInfo, $exprType, $nixExprInputName, $nixExprPath) = @_;
    my $nixExprInput = $inputInfo->{$nixExprInputName}->[0]
        or die "cannot find the input containing the job expression\n";
    die "multiple alternatives for the input containing the Nix expression are not supported.\n"
        if scalar @{$inputInfo->{$nixExprInputName}} != 1;
    my $nixExprFullPath = $nixExprInput->{storePath} . "/" . $nixExprPath;
    my $evaluator = ($exprType eq "guile") ? "hydra-eval-guile-jobs" : "hydra-eval-jobs";
    my @cmd = ($evaluator, $nixExprFullPath, "--gc-roots-dir", getGCRootsDir, "-j", 1, inputsToArgs($inputInfo, $exprType));
    if (defined $ENV{'HYDRA_DEBUG'}) {
        sub escape {
            my $s = $_;
            $s =~ s/'/'\\''/g;
            return "'" . $s . "'";
        }
        my @escaped = map escape, @cmd;
        print STDERR "evaluator: @escaped\n";
    }
    (my $res, my $jobsJSON, my $stderr) = captureStdoutStderr(21600, @cmd);
    die "$evaluator returned " . ($res & 127 ? "signal $res" : "exit code " . ($res >> 8))
        . ":\n" . ($stderr ? decode("utf-8", $stderr) : "(no output)\n")
        if $res;
    print STDERR "$stderr";
    return (decode_json($jobsJSON), $nixExprInput);
}
# Return the most recent evaluation of the given jobset (that
# optionally had new builds), or undefined if no such evaluation
# exists.
sub getPrevJobsetEval {
    my ($db, $jobset, $hasNewBuilds) = @_;
    my ($prevEval) = $jobset->jobsetevals(
        ($hasNewBuilds ? { hasnewbuilds => 1 } : { }),
        { order_by => "id DESC", rows => 1 });
    return $prevEval;
}
# Check whether to add the build described by $buildInfo.
sub checkBuild {
    my ($db, $jobset, $inputInfo, $nixExprInput, $buildInfo, $buildMap, $prevEval, $jobOutPathMap, $plugins) = @_;
    my @outputNames = sort keys %{$buildInfo->{outputs}};
    die unless scalar @outputNames;
    # In various checks we can use an arbitrary output (the first)
    # rather than all outputs, since if one output is the same, the
    # others will be as well.
    my $firstOutputName = $outputNames[0];
    my $firstOutputPath = $buildInfo->{outputs}->{$firstOutputName};
    my $jobName = $buildInfo->{jobName} or die;
    my $drvPath = $buildInfo->{drvPath} or die;
    my $build;
    txn_do($db, sub {
        my $job = $jobset->jobs->update_or_create({ name => $jobName });
        # Don't add a build that has already been scheduled for this
        # job, or has been built but is still a "current" build for
        # this job.  Note that this means that if the sources of a job
        # are changed from A to B and then reverted to A, three builds
        # will be performed (though the last one will probably use the
        # cached result from the first).  This ensures that the builds
        # with the highest ID will always be the ones that we want in
        # the channels.  FIXME: Checking the output paths doesn't take
        # meta-attributes into account.  For instance, do we want a
        # new build to be scheduled if the meta.maintainers field is
        # changed?
        if (defined $prevEval) {
            # Only check one output: if it's the same, the other will be as well.
            my $firstOutput = $outputNames[0];
            my ($prevBuild) = $prevEval->builds->search(
                # The "project" and "jobset" constraints are
                # semantically unnecessary (because they're implied by
                # the eval), but they give a factor 1000 speedup on
                # the Nixpkgs jobset with PostgreSQL.
                { project => $jobset->project->name, jobset => $jobset->name, job => $jobName,
                  name => $firstOutputName, path => $firstOutputPath },
                { rows => 1, columns => ['id'], join => ['buildoutputs'] });
            if (defined $prevBuild) {
                #print STDERR "    already scheduled/built as build ", $prevBuild->id, "\n";
                $buildMap->{$prevBuild->id} = { id => $prevBuild->id, jobName => $jobName, new => 0, drvPath => $drvPath };
                return;
            }
        }
        # Prevent multiple builds with the same (job, outPath) from
        # being added.
        my $prev = $$jobOutPathMap{$jobName . "\t" . $firstOutputPath};
        if (defined $prev) {
            #print STDERR "    already scheduled as build ", $prev, "\n";
            return;
        }
        my $time = time();
        sub null {
            my ($s) = @_;
            return $s eq "" ? undef : $s;
        }
        # Add the build to the database.
        $build = $job->builds->create(
            { timestamp => $time
            , description => null($buildInfo->{description})
            , license => null($buildInfo->{license})
            , homepage => null($buildInfo->{homepage})
            , maintainers => null($buildInfo->{maintainers})
            , maxsilent => $buildInfo->{maxSilent}
            , timeout => $buildInfo->{timeout}
            , nixname => $buildInfo->{nixName}
            , drvpath => $drvPath
            , system => $buildInfo->{system}
            , nixexprinput => $jobset->nixexprinput
            , nixexprpath => $jobset->nixexprpath
            , priority => $buildInfo->{schedulingPriority}
            , finished => 0
            , iscurrent => 1
            , ischannel => $buildInfo->{isChannel}
            });
        $build->buildoutputs->create({ name => $_, path => $buildInfo->{outputs}->{$_} })
            foreach @outputNames;
        $buildMap->{$build->id} = { id => $build->id, jobName => $jobName, new => 1, drvPath => $drvPath };
        $$jobOutPathMap{$jobName . "\t" . $firstOutputPath} = $build->id;
        print STDERR "added build ${\$build->id} (${\$jobset->project->name}:${\$jobset->name}:$jobName)\n";
    });
    return $build;
};

Insertion in src/lib/Hydra/Helper/Nix.pm at line 13 [78.436]
[13.122]
[77.127]
```
use IPC::Run;
```
Replacement in src/script/hydra-eval-jobset at line 5 [81.1319]
∅:D[79.151] → [80.473:492]
B:BD[81.1363] → [80.473:492]
B:BD[80.492] → [26.19854:19873]
∅:D[26.19873] → [77.1746:1770]
B:BD[80.492] → [77.1746:1770]
```
use Hydra::Schema;
use Hydra::Plugin;
use Hydra::Helper::Nix;
```
[79.151]
[22.10916]
```
use Config::General;
use Data::Dump qw(dump);
use Digest::SHA qw(sha256_hex);
use Encode;
use File::Slurp;
```
Insertion in src/script/hydra-eval-jobset at line 11 [81.1319]
[22.10946]
[82.2430]
```
use Hydra::Helper::CatalystUtils;
```
Insertion in src/script/hydra-eval-jobset at line 13 [81.1319]
[82.2456]
[83.688]
```
use Hydra::Helper::Nix;
```
Replacement in src/script/hydra-eval-jobset at line 15 [81.1319]
∅:D[83.710] → [84.2013:2045]
B:BD[22.10946] → [84.2013:2045]
B:BD[85.396] → [85.396:417]
B:BD[85.417] → [43.2426:2451]
B:BD[43.2451] → [82.2457:2472]
```
use Digest::SHA qw(sha256_hex);
use Config::General;
use Data::Dump qw(dump);
use Try::Tiny;
```
[83.710]
[86.0]
```
use Hydra::Plugin;
use Hydra::Schema;
use JSON;
```
Insertion in src/script/hydra-eval-jobset at line 19 [81.1319]
[86.17]
[16.0]
```
use Nix::Store;
```
Replacement in src/script/hydra-eval-jobset at line 21 [81.1319]
∅:D[16.51] → [27.4394:4421]
B:BD[86.67] → [27.4394:4421]
```
use JSON;
use File::Slurp;
```
[16.51]
[85.418]
```
use Try::Tiny;
```

Insertion in src/script/hydra-eval-jobset at line 33 [81.1319]

[60.500]

[87.5400]


sub parseJobName {
    # Parse a job specification of the form `<project>:<jobset>:<job>
    # [attrs]'.  The project, jobset and attrs may be omitted.  The
    # attrs have the form `name = "value"'.
    my ($s) = @_;
    our $key;
    our %attrs = ();
    # hm, maybe I should stop programming Perl before it's too late...
    $s =~ / ^ (?: (?: ($projectNameRE) : )? ($jobsetNameRE) : )? ($jobNameRE) \s*
            (\[ \s* (
              ([\w]+) (?{ $key = $^N; }) \s* = \s* \"
              ([\w\-]+) (?{ $attrs{$key} = $^N; }) \"
            \s* )* \])? $
          /x
        or die "invalid job specifier `$s'";
    return ($1, $2, $3, \%attrs);
}
sub attrsToSQL {
    my ($attrs, $id) = @_;
    my $query = "1 = 1";
    foreach my $name (keys %{$attrs}) {
        my $value = $attrs->{$name};
        $name =~ /^[\w\-]+$/ or die;
        $value =~ /^[\w\-]+$/ or die;
        # !!! Yes, this is horribly injection-prone... (though
        # name/value are filtered above).  Should use SQL::Abstract,
        # but it can't deal with subqueries.  At least we should use
        # placeholders.
        $query .= " and exists (select 1 from buildinputs where build = $id and name = '$name' and value = '$value')";
    }
    return $query;
}
sub fetchInputBuild {
    my ($db, $project, $jobset, $name, $value) = @_;
    my $prevBuild;
    if ($value =~ /^\d+$/) {
        $prevBuild = $db->resultset('Builds')->find({ id => int($value) });
    } else {
        my ($projectName, $jobsetName, $jobName, $attrs) = parseJobName($value);
        $projectName ||= $project->name;
        $jobsetName ||= $jobset->name;
        # Pick the most recent successful build of the specified job.
        $prevBuild = $db->resultset('Builds')->search(
            { finished => 1, project => $projectName, jobset => $jobsetName
            , job => $jobName, buildStatus => 0 },
            { order_by => "me.id DESC", rows => 1
            , where => \ attrsToSQL($attrs, "me.id") })->single;
    }
    return () if !defined $prevBuild || !isValidPath(getMainOutput($prevBuild)->path);
    #print STDERR "input `", $name, "': using build ", $prevBuild->id, "\n";
    my $pkgNameRE = "(?:(?:[A-Za-z0-9]|(?:-[^0-9]))+)";
    my $versionRE = "(?:[A-Za-z0-9\.\-]+)";
    my $relName = ($prevBuild->releasename or $prevBuild->nixname);
    my $version = $2 if $relName =~ /^($pkgNameRE)-($versionRE)$/;
    my $mainOutput = getMainOutput($prevBuild);
    my $result =
        { storePath => $mainOutput->path
        , id => $prevBuild->id
        , version => $version
        , outputName => $mainOutput->name
        };
    if (isValidPath($prevBuild->drvpath)) {
        $result->{drvPath} = $prevBuild->drvpath;
    }
    return $result;
}
sub fetchInputSystemBuild {
    my ($db, $project, $jobset, $name, $value) = @_;
    my ($projectName, $jobsetName, $jobName, $attrs) = parseJobName($value);
    $projectName ||= $project->name;
    $jobsetName ||= $jobset->name;
    my @latestBuilds = $db->resultset('LatestSucceededForJob')
        ->search({}, {bind => [$projectName, $jobsetName, $jobName]});
    my @validBuilds = ();
    foreach my $build (@latestBuilds) {
        push(@validBuilds, $build) if isValidPath(getMainOutput($build)->path);
    }
    if (scalar(@validBuilds) == 0) {
        print STDERR "input `", $name, "': no previous build available\n";
        return ();
    }
    my @inputs = ();
    foreach my $prevBuild (@validBuilds) {
        my $pkgNameRE = "(?:(?:[A-Za-z0-9]|(?:-[^0-9]))+)";
        my $versionRE = "(?:[A-Za-z0-9\.\-]+)";
        my $relName = ($prevBuild->releasename or $prevBuild->nixname);
        my $version = $2 if $relName =~ /^($pkgNameRE)-($versionRE)$/;
        my $input =
            { storePath => getMainOutput($prevBuild)->path
            , id => $prevBuild->id
            , version => $version
            , system => $prevBuild->system
            };
        push(@inputs, $input);
    }
    return @inputs;
}
sub fetchInputEval {
    my ($db, $project, $jobset, $name, $value) = @_;
    my $eval;
    if ($value =~ /^\d+$/) {
        $eval = $db->resultset('JobsetEvals')->find({ id => int($value) });
        die "evaluation $eval->{id} does not exist\n" unless defined $eval;
    } elsif ($value =~ /^($projectNameRE):($jobsetNameRE)$/) {
        my $jobset = $db->resultset('Jobsets')->find({ project => $1, name => $2 });
        die "jobset ‘$value’ does not exist\n" unless defined $jobset;
        $eval = getLatestFinishedEval($jobset);
        die "jobset ‘$value’ does not have a finished evaluation\n" unless defined $eval;
    } elsif ($value =~ /^($projectNameRE):($jobsetNameRE):($jobNameRE)$/) {
        $eval = $db->resultset('JobsetEvals')->find(
            { project => $1, jobset => $2, hasnewbuilds => 1 },
            { order_by => "id DESC", rows => 1
            , where =>
                \ [ # All builds in this jobset should be finished...
                    "not exists (select 1 from JobsetEvalMembers m join Builds b on m.build = b.id where m.eval = me.id and b.finished = 0) "
                    # ...and the specified build must have succeeded.
                    . "and exists (select 1 from JobsetEvalMembers m join Builds b on m.build = b.id where m.eval = me.id and b.job = ? and b.buildstatus = 0)"
                  , [ 'name', $3 ] ]
            });
        die "there is no successful build of ‘$value’ in a finished evaluation\n" unless defined $eval;
    } else {
        die;
    }
    my $jobs = {};
    foreach my $build ($eval->builds) {
        next unless $build->finished == 1 && $build->buildstatus == 0;
        # FIXME: Handle multiple outputs.
        my $out = $build->buildoutputs->find({ name => "out" });
        next unless defined $out;
        # FIXME: Should we fail if the path is not valid?
        next unless isValidPath($out->path);
        $jobs->{$build->get_column('job')} = $out->path;
    }
    return { jobs => $jobs };
}
sub fetchInput {
    my ($plugins, $db, $project, $jobset, $name, $type, $value, $emailresponsible) = @_;
    my @inputs;
    if ($type eq "build") {
        @inputs = fetchInputBuild($db, $project, $jobset, $name, $value);
    }
    elsif ($type eq "sysbuild") {
        @inputs = fetchInputSystemBuild($db, $project, $jobset, $name, $value);
    }
    elsif ($type eq "eval") {
        @inputs = fetchInputEval($db, $project, $jobset, $name, $value);
    }
    elsif ($type eq "string" || $type eq "nix") {
        die unless defined $value;
        @inputs = { value => $value };
    }
    elsif ($type eq "boolean") {
        die unless defined $value && ($value eq "true" || $value eq "false");
        @inputs = { value => $value };
    }
    else {
        my $found = 0;
        foreach my $plugin (@{$plugins}) {
            @inputs = $plugin->fetchInput($type, $name, $value, $project, $jobset);
            if (defined $inputs[0]) {
                $found = 1;
                last;
            }
        }
        die "input `$name' has unknown type `$type'." unless $found;
    }
    foreach my $input (@inputs) {
        $input->{type} = $type;
        $input->{emailresponsible} = $emailresponsible;
    }
    return @inputs;
}
sub booleanToString {
    my ($exprType, $value) = @_;
    my $result;
    if ($exprType eq "guile") {
        if ($value eq "true") {
            $result = "#t";
        } else {
            $result = "#f";
        }
        $result = $value;
    } else {
        $result = $value;
    }
    return $result;
}
sub buildInputToString {
    my ($exprType, $input) = @_;
    my $result;
    if ($exprType eq "guile") {
        $result = "'((file-name . \"" . ${input}->{storePath} . "\")" .
            (defined $input->{revision} ? "(revision . \"" . $input->{revision} . "\")" : "") .
            (defined $input->{revCount} ? "(revision-count . " . $input->{revCount} . ")" : "") .
            (defined $input->{gitTag} ? "(git-tag . \"" . $input->{gitTag} . "\")" : "") .
            (defined $input->{shortRev} ? "(short-revision . \"" . $input->{shortRev} . "\")" : "") .
            (defined $input->{version} ? "(version . \"" . $input->{version} . "\")" : "") .
            ")";
    } else {
        $result = "{ outPath = builtins.storePath " . $input->{storePath} . "" .
            "; inputType = \"" . $input->{type} . "\"" .
            (defined $input->{uri} ? "; uri = \"" . $input->{uri} . "\"" : "") .
            (defined $input->{revNumber} ? "; rev = " . $input->{revNumber} . "" : "") .
            (defined $input->{revision} ? "; rev = \"" . $input->{revision} . "\"" : "") .
            (defined $input->{revCount} ? "; revCount = " . $input->{revCount} . "" : "") .
            (defined $input->{gitTag} ? "; gitTag = \"" . $input->{gitTag} . "\"" : "") .
            (defined $input->{shortRev} ? "; shortRev = \"" . $input->{shortRev} . "\"" : "") .
            (defined $input->{version} ? "; version = \"" . $input->{version} . "\"" : "") .
            (defined $input->{outputName} ? "; outputName = \"" . $input->{outputName} . "\"" : "") .
            (defined $input->{drvPath} ? "; drvPath = builtins.storePath " . $input->{drvPath} . "" : "") .
            ";}";
    }
    return $result;
}
sub inputsToArgs {
    my ($inputInfo, $exprType) = @_;
    my @res = ();
    foreach my $input (sort keys %{$inputInfo}) {
        push @res, "-I", "$input=$inputInfo->{$input}->[0]->{storePath}"
            if scalar @{$inputInfo->{$input}} == 1
               && defined $inputInfo->{$input}->[0]->{storePath};
        foreach my $alt (@{$inputInfo->{$input}}) {
            if ($alt->{type} eq "string") {
                push @res, "--argstr", $input, $alt->{value};
            }
            elsif ($alt->{type} eq "boolean") {
                push @res, "--arg", $input, booleanToString($exprType, $alt->{value});
            }
            elsif ($alt->{type} eq "nix") {
                die "input type ‘nix’ only supported for Nix-based jobsets\n" unless $exprType eq "nix";
                push @res, "--arg", $input, $alt->{value};
            }
            elsif ($alt->{type} eq "eval") {
                die "input type ‘eval’ only supported for Nix-based jobsets\n" unless $exprType eq "nix";
                my $s = "{ ";
                # FIXME: escape $_.  But dots should not be escaped.
                $s .= "$_ = builtins.storePath ${\$alt->{jobs}->{$_}}; "
                    foreach keys %{$alt->{jobs}};
                $s .= "}";
                push @res, "--arg", $input, $s;
            }
            else {
                push @res, "--arg", $input, buildInputToString($exprType, $alt);
            }
        }
    }
    return @res;
}

Insertion in src/script/hydra-eval-jobset at line 332 [81.1319]

[87.5401]

[81.1424]

sub evalJobs {
    my ($inputInfo, $exprType, $nixExprInputName, $nixExprPath) = @_;

Insertion in src/script/hydra-eval-jobset at line 335 [81.1319]

[81.1425]

[88.483]

    my $nixExprInput = $inputInfo->{$nixExprInputName}->[0]
        or die "cannot find the input containing the job expression\n";
    die "multiple alternatives for the input containing the Nix expression are not supported.\n"
        if scalar @{$inputInfo->{$nixExprInputName}} != 1;
    my $nixExprFullPath = $nixExprInput->{storePath} . "/" . $nixExprPath;
    my $evaluator = ($exprType eq "guile") ? "hydra-eval-guile-jobs" : "hydra-eval-jobs";
    my @cmd = ($evaluator, $nixExprFullPath, "--gc-roots-dir", getGCRootsDir, "-j", 1, inputsToArgs($inputInfo, $exprType));
    if (defined $ENV{'HYDRA_DEBUG'}) {
        sub escape {
            my $s = $_;
            $s =~ s/'/'\\''/g;
            return "'" . $s . "'";
        }
        my @escaped = map escape, @cmd;
        print STDERR "evaluator: @escaped\n";
    }
    (my $res, my $jobsJSON, my $stderr) = captureStdoutStderr(21600, @cmd);
    die "$evaluator returned " . ($res & 127 ? "signal $res" : "exit code " . ($res >> 8))
        . ":\n" . ($stderr ? decode("utf-8", $stderr) : "(no output)\n")
        if $res;
    print STDERR "$stderr";
    return (decode_json($jobsJSON), $nixExprInput);
}
# Return the most recent evaluation of the given jobset (that
# optionally had new builds), or undefined if no such evaluation
# exists.
sub getPrevJobsetEval {
    my ($db, $jobset, $hasNewBuilds) = @_;
    my ($prevEval) = $jobset->jobsetevals(
        ($hasNewBuilds ? { hasnewbuilds => 1 } : { }),
        { order_by => "id DESC", rows => 1 });
    return $prevEval;
}
# Check whether to add the build described by $buildInfo.
sub checkBuild {
    my ($db, $jobset, $inputInfo, $nixExprInput, $buildInfo, $buildMap, $prevEval, $jobOutPathMap, $plugins) = @_;
    my @outputNames = sort keys %{$buildInfo->{outputs}};
    die unless scalar @outputNames;
    # In various checks we can use an arbitrary output (the first)
    # rather than all outputs, since if one output is the same, the
    # others will be as well.
    my $firstOutputName = $outputNames[0];
    my $firstOutputPath = $buildInfo->{outputs}->{$firstOutputName};
    my $jobName = $buildInfo->{jobName} or die;
    my $drvPath = $buildInfo->{drvPath} or die;
    my $build;
    txn_do($db, sub {
        my $job = $jobset->jobs->update_or_create({ name => $jobName });
        # Don't add a build that has already been scheduled for this
        # job, or has been built but is still a "current" build for
        # this job.  Note that this means that if the sources of a job
        # are changed from A to B and then reverted to A, three builds
        # will be performed (though the last one will probably use the
        # cached result from the first).  This ensures that the builds
        # with the highest ID will always be the ones that we want in
        # the channels.  FIXME: Checking the output paths doesn't take
        # meta-attributes into account.  For instance, do we want a
        # new build to be scheduled if the meta.maintainers field is
        # changed?
        if (defined $prevEval) {
            # Only check one output: if it's the same, the other will be as well.
            my $firstOutput = $outputNames[0];
            my ($prevBuild) = $prevEval->builds->search(
                # The "project" and "jobset" constraints are
                # semantically unnecessary (because they're implied by
                # the eval), but they give a factor 1000 speedup on
                # the Nixpkgs jobset with PostgreSQL.
                { project => $jobset->project->name, jobset => $jobset->name, job => $jobName,
                  name => $firstOutputName, path => $firstOutputPath },
                { rows => 1, columns => ['id'], join => ['buildoutputs'] });
            if (defined $prevBuild) {
                #print STDERR "    already scheduled/built as build ", $prevBuild->id, "\n";
                $buildMap->{$prevBuild->id} = { id => $prevBuild->id, jobName => $jobName, new => 0, drvPath => $drvPath };
                return;
            }
        }
        # Prevent multiple builds with the same (job, outPath) from
        # being added.
        my $prev = $$jobOutPathMap{$jobName . "\t" . $firstOutputPath};
        if (defined $prev) {
            #print STDERR "    already scheduled as build ", $prev, "\n";
            return;
        }
        my $time = time();
        sub null {
            my ($s) = @_;
            return $s eq "" ? undef : $s;
        }
        # Add the build to the database.
        $build = $job->builds->create(
            { timestamp => $time
            , description => null($buildInfo->{description})
            , license => null($buildInfo->{license})
            , homepage => null($buildInfo->{homepage})
            , maintainers => null($buildInfo->{maintainers})
            , maxsilent => $buildInfo->{maxSilent}
            , timeout => $buildInfo->{timeout}
            , nixname => $buildInfo->{nixName}
            , drvpath => $drvPath
            , system => $buildInfo->{system}
            , nixexprinput => $jobset->nixexprinput
            , nixexprpath => $jobset->nixexprpath
            , priority => $buildInfo->{schedulingPriority}
            , finished => 0
            , iscurrent => 1
            , ischannel => $buildInfo->{isChannel}
            });
        $build->buildoutputs->create({ name => $_, path => $buildInfo->{outputs}->{$_} })
            foreach @outputNames;
        $buildMap->{$build->id} = { id => $build->id, jobName => $jobName, new => 1, drvPath => $drvPath };
        $$jobOutPathMap{$jobName . "\t" . $firstOutputPath} = $build->id;
        print STDERR "added build ${\$build->id} (${\$jobset->project->name}:${\$jobset->name}:$jobName)\n";
    });
    return $build;
};

Deletion in tests/Setup.pm at line 7 [91.518]
∅:D[89.22] → [90.208:238]
B:BD[90.208] → [90.208:238]
```
use Hydra::Helper::AddBuilds;
```
Deletion in tests/evaluation-tests.pl at line 4 [91.804]
∅:D[89.197] → [91.894:924]
B:BD[91.894] → [91.894:924]
```
use Hydra::Helper::AddBuilds;
```

Move most of AddBuilds to hydra-eval-jobset

Dependencies

In channels

Change contents

Deletion in src/lib/Hydra/Controller/API.pm at line 8 [17.24]

Deletion in src/lib/Hydra/Controller/Admin.pm at line 8 [19.1]

Deletion in src/lib/Hydra/Controller/Build.pm at line 9 [21.1]

Deletion in src/lib/Hydra/Helper/AddBuilds.pm at line 7 [22.2663]

Replacement in src/lib/Hydra/Helper/AddBuilds.pm at line 22 [22.2663]

Deletion in src/lib/Hydra/Helper/AddBuilds.pm at line 25 [22.2663]

Deletion in src/lib/Hydra/Helper/AddBuilds.pm at line 26 [22.2663]

Deletion in src/lib/Hydra/Helper/AddBuilds.pm at line 27 [22.2663]

Insertion in src/lib/Hydra/Helper/Nix.pm at line 13 [78.436]

Replacement in src/script/hydra-eval-jobset at line 5 [81.1319]

Insertion in src/script/hydra-eval-jobset at line 11 [81.1319]

Insertion in src/script/hydra-eval-jobset at line 13 [81.1319]

Replacement in src/script/hydra-eval-jobset at line 15 [81.1319]

Insertion in src/script/hydra-eval-jobset at line 19 [81.1319]

Replacement in src/script/hydra-eval-jobset at line 21 [81.1319]

Insertion in src/script/hydra-eval-jobset at line 33 [81.1319]

Insertion in src/script/hydra-eval-jobset at line 332 [81.1319]

Insertion in src/script/hydra-eval-jobset at line 335 [81.1319]

Deletion in tests/Setup.pm at line 7 [91.518]

Deletion in tests/evaluation-tests.pl at line 4 [91.804]