grahamc/hydra - Change 3XTHEUMP2ZOMPQWE3S5QWHIHCEJNEXGDPQB3JUVZFPS3RFMY455QC

* Implemented the clone feature.

Created by Eelco Dolstra on October 26, 2009

3XTHEUMP2ZOMPQWE3S5QWHIHCEJNEXGDPQB3JUVZFPS3RFMY455QC

Dependencies

In channels

upstream

main

Change contents

Replacement in src/lib/Hydra/Controller/Build.pm at line 407 [5.1]

B:BD[3.32] → [3.32:124]

    my ($nixExprPath, $nixExprInput) = Hydra::Controller::Jobset::nixExprPathFromParams $c;

[3.32]

[6.409]

    my ($nixExprPath, $nixExprInputName) = Hydra::Controller::Jobset::nixExprPathFromParams $c;

Insertion in src/lib/Hydra/Controller/Build.pm at line 412 [5.1]
[3.258]
[3.258]
```
    my $inputInfo = {};
```

Replacement in src/lib/Hydra/Controller/Build.pm at line 422 [5.1]

B:BD[3.656] → [3.656:680]

            fetchInput(

[3.656]

[3.680]

            # !!! fetchInput can take a long time, which might cause
            # the current HTTP request to time out.  So maybe this
            # should be done asynchronously.  But then error reporting
            # becomes harder.
            my $info = fetchInput(

Insertion in src/lib/Hydra/Controller/Build.pm at line 429 [5.1]

[3.800]

            push @{$$inputInfo{$inputName}}, $info if defined $info;

Replacement in src/lib/Hydra/Controller/Build.pm at line 434 [5.1]

∅:D[3.847] → [6.410:471]

B:BD[6.410] → [6.410:471]

    $c->flash->{buildMsg} = "Build XXX added to the queue.";

[3.847]

[6.471]

    my ($jobs, $nixExprInput) = evalJobs($inputInfo, $nixExprInputName, $nixExprPath);
    my $job;
    foreach my $j (@{$jobs->{job}}) {
        print STDERR $j->{jobName}, "\n";
        if ($j->{jobName} eq $jobName) {
            error($c, "Nix expression returned multiple builds for job $jobName.")
                if $job;
            $job = $j;
        }
    }
    error($c, "Nix expression did not return a job named $jobName.") unless $job;
    my %currentBuilds;
    my $newBuild = checkBuild(
        $c->model('DB'), $build->project, $build->jobset,
        $inputInfo, $nixExprInput, $job, \%currentBuilds);
    error($c, "This build has already been performed.") unless $newBuild;
    
    $c->flash->{buildMsg} = "Build " . $newBuild->id . " added to the queue.";

Insertion in src/lib/Hydra/Helper/AddBuilds.pm at line 4 [3.2663]
[3.2711]
[3.2711]
```
use feature 'switch';
use XML::Simple;
```
Insertion in src/lib/Hydra/Helper/AddBuilds.pm at line 7 [3.2663]
[3.2735]
[3.2735]
```
use IPC::Run;
```
Replacement in src/lib/Hydra/Helper/AddBuilds.pm at line 11 [3.2663]
B:BD[3.2785] → [3.2785:2815]
```
our @EXPORT = qw(fetchInput);
```
[3.2785]
[3.2815]
```
our @EXPORT = qw(fetchInput evalJobs checkBuild);
```

Insertion in src/lib/Hydra/Helper/AddBuilds.pm at line 229 [3.2663]

[3.10397]

}
sub inputsToArgs {
    my ($inputInfo) = @_;
    my @res = ();
    foreach my $input (keys %{$inputInfo}) {
        foreach my $alt (@{$inputInfo->{$input}}) {
            given ($alt->{type}) {
                when ("string") {
                    push @res, "--argstr", $input, $alt->{value};
                }
                when ("boolean") {
                    push @res, "--arg", $input, $alt->{value};
                }
                when (["svn", "path", "build"]) {
                    push @res, "--arg", $input, (
                        "{ outPath = builtins.storePath " . $alt->{storePath} . "" .
                        (defined $alt->{revision} ? "; rev = \"" . $alt->{revision} . "\"" : "") .
                        (defined $alt->{version} ? "; version = \"" . $alt->{version} . "\"" : "") .
                        ";}"
                    );
                }
            }
        }
    }
    return @res;
}
sub captureStdoutStderr {
    my $stdin = ""; my $stdout; my $stderr;
    my $res = IPC::Run::run(\@_, \$stdin, \$stdout, \$stderr);
    return ($res, $stdout, $stderr);

Insertion in src/lib/Hydra/Helper/AddBuilds.pm at line 266 [3.2663]

[3.10399]


    
sub evalJobs {
    my ($inputInfo, $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 $res, my $jobsXml, my $stderr) = captureStdoutStderr(
        "hydra_eval_jobs", $nixExprFullPath, "--gc-roots-dir", getGCRootsDir,
        inputsToArgs($inputInfo));
    die "Cannot evaluate the Nix expression containing the jobs:\n$stderr" unless $res;
    print STDERR "$stderr";
    my $jobs = XMLin(
        $jobsXml,
        ForceArray => ['error', 'job', 'arg'],
        KeyAttr => [],
        SuppressEmpty => '')
        or die "cannot parse XML output";
    return ($jobs, $nixExprInput);
}
# Check whether to add the build described by $buildInfo.
sub checkBuild {
    my ($db, $project, $jobset, $inputInfo, $nixExprInput, $buildInfo, $currentBuilds) = @_;
    my $jobName = $buildInfo->{jobName};
    my $drvPath = $buildInfo->{drvPath};
    my $outPath = $buildInfo->{outPath};
    my $priority = 100;
    $priority = int($buildInfo->{schedulingPriority})
        if $buildInfo->{schedulingPriority} =~ /^\d+$/;
    my $build;
    txn_do($db, sub {
        # Update the last evaluation time in the database.
        my $job = $jobset->jobs->update_or_create(
            { name => $jobName
            , lastevaltime => time
            });
        $job->update({firstevaltime => time})
            unless defined $job->firstevaltime;
        # 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.
        # !!! Checking $outPath 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?
        my @previousBuilds = $job->builds->search({outPath => $outPath, isCurrent => 1});
        if (scalar(@previousBuilds) > 0) {
            print STDERR "already scheduled/built\n";
            $currentBuilds->{$_->id} = 1 foreach @previousBuilds;
            return;
        }
        
        # Nope, so add it.
        $build = $job->builds->create(
            { finished => 0
            , timestamp => time()
            , description => $buildInfo->{description}
            , longdescription => $buildInfo->{longDescription}
            , license => $buildInfo->{license}
            , homepage => $buildInfo->{homepage}
            , maintainers => $buildInfo->{maintainers}
            , nixname => $buildInfo->{nixName}
            , drvpath => $drvPath
            , outpath => $outPath
            , system => $buildInfo->{system}
            , iscurrent => 1
            , nixexprinput => $jobset->nixexprinput
            , nixexprpath => $jobset->nixexprpath
            });
        print STDERR "added to queue as build ", $build->id, "\n";
        
        $currentBuilds->{$build->id} = 1;
        
        $build->create_related('buildschedulinginfo',
            { priority => $priority
            , busy => 0
            , locker => ""
            });
        my %inputs;
        $inputs{$jobset->nixexprinput} = $nixExprInput;
        foreach my $arg (@{$buildInfo->{arg}}) {
            $inputs{$arg->{name}} = $inputInfo->{$arg->{name}}->[$arg->{altnr}]
                || die "invalid input";
        }
        foreach my $name (keys %inputs) {
            my $input = $inputs{$name};
            $build->buildinputs_builds->create(
                { name => $name
                , type => $input->{type}
                , uri => $input->{uri}
                , revision => $input->{revision}
                , value => $input->{value}
                , dependency => $input->{id}
                , path => $input->{storePath} || "" # !!! temporary hack
                , sha256hash => $input->{sha256hash}
                });
        }
    });
    return $build;
};

Deletion in src/script/hydra_scheduler.pl at line 5 [8.1319]
∅:D[7.289] → [8.1346:1363]
B:BD[8.1346] → [8.1346:1363]
```
use XML::Simple;
```
Deletion in src/script/hydra_scheduler.pl at line 8 [8.1319]
∅:D[9.1770] → [10.1980:1994]
∅:D[3.10946] → [10.1980:1994]
B:BD[11.492] → [10.1980:1994]
```
use IPC::Run;
```

Deletion in src/script/hydra_scheduler.pl at line 14 [8.1319]

B:BD[8.1425] → [8.1425:1426]

B:BD[10.1996] → [10.1996:2168]


sub captureStdoutStderr {
    my $stdin = ""; my $stdout; my $stderr;
    my $res = IPC::Run::run(\@_, \$stdin, \$stdout, \$stderr);
    return ($res, $stdout, $stderr);
}

Deletion in src/script/hydra_scheduler.pl at line 15 [8.1319]
B:BD[12.6685] → [10.2169:2174]
```
    
```
Deletion in src/script/hydra_scheduler.pl at line 24 [8.1319]
∅:D[7.740] → [13.382:383]
B:BD[13.382] → [13.382:383]
∅:D[10.2878] → [13.698:699]
B:BD[13.698] → [13.698:699]
B:BD[13.699] → [4.0:163]
∅:D[14.66] → [13.805:806]
∅:D[4.163] → [13.805:806]
∅:D[7.807] → [13.805:806]
∅:D[15.3560] → [13.805:806]
B:BD[13.805] → [13.805:806]
B:BD[13.806] → [4.164:287]
∅:D[4.287] → [13.1084:1085]
B:BD[13.1084] → [13.1084:1085]
B:BD[13.1085] → [16.0:24]
B:BD[16.24] → [4.288:398]
∅:D[4.398] → [16.224:225]
∅:D[7.977] → [16.224:225]
B:BD[16.224] → [16.224:225]
B:BD[16.225] → [17.1393:1415]
B:BD[17.1415] → [18.76:135]
B:BD[18.135] → [4.399:450]
∅:D[4.450] → [19.5255:5286]
B:BD[19.5255] → [19.5255:5286]
B:BD[19.5312] → [19.5312:5363]
```
# Check whether to add the build described by $buildInfo.
sub checkBuild {
    my ($project, $jobset, $inputInfo, $nixExprInput, $buildInfo, $currentBuilds) = @_;
    my $jobName = $buildInfo->{jobName};
    my $drvPath = $buildInfo->{drvPath};
    my $outPath = $buildInfo->{outPath};
    my $priority = 100;
    $priority = int($buildInfo->{schedulingPriority})
        if $buildInfo->{schedulingPriority} =~ /^\d+$/;
    txn_do($db, sub {
        # Update the last evaluation time in the database.
        my $job = $jobset->jobs->update_or_create(
            { name => $jobName
            , lastevaltime => time
            });
```

Deletion in src/script/hydra_scheduler.pl at line 25 [8.1319]

B:BD[19.5364] → [4.451:545]

∅:D[4.545] → [19.5466:5467]

B:BD[19.5466] → [19.5466:5467]

B:BD[19.5467] → [20.63:578]

B:BD[20.578] → [21.0:66]

∅:D[21.66] → [20.644:769]

B:BD[20.644] → [20.644:769]

B:BD[20.769] → [4.546:636]

∅:D[21.161] → [15.4099:4142]

∅:D[4.636] → [15.4099:4142]

∅:D[20.863] → [15.4099:4142]

B:BD[15.4099] → [15.4099:4142]

B:BD[15.4142] → [20.864:997]

∅:D[20.997] → [22.9666:9676]

∅:D[15.5005] → [22.9666:9676]

B:BD[22.9666] → [22.9666:9676]

B:BD[22.9676] → [20.998:1007]

∅:D[20.1007] → [19.5600:5627]

B:BD[22.9677] → [19.5600:5627]

B:BD[19.5627] → [4.637:679]

∅:D[4.679] → [23.12279:12341]

∅:D[19.5674] → [23.12279:12341]

B:BD[23.12279] → [23.12279:12341]

B:BD[23.12341] → [4.680:996]

∅:D[4.996] → [22.10318:10386]

∅:D[7.1166] → [22.10318:10386]

∅:D[24.3007] → [22.10318:10386]

B:BD[22.10318] → [22.10318:10386]

B:BD[22.10386] → [4.997:1042]

∅:D[4.1042] → [15.5006:5035]

B:BD[22.10425] → [15.5006:5035]

B:BD[15.5035] → [2.490:592]

∅:D[2.592] → [22.10425:10441]

∅:D[15.5035] → [22.10425:10441]

B:BD[22.10425] → [22.10425:10441]

        $job->update({firstevaltime => time})
            unless defined $job->firstevaltime;
        # 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.
        # !!! Checking $outPath 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?
        my @previousBuilds = $job->builds->search({outPath => $outPath, isCurrent => 1});
        if (scalar(@previousBuilds) > 0) {
            print "already scheduled/built\n";
            $currentBuilds->{$_->id} = 1 foreach @previousBuilds;
            return;
        }
        
        # Nope, so add it.
        my $build = $job->builds->create(
            { finished => 0
            , timestamp => time()
            , description => $buildInfo->{description}
            , longdescription => $buildInfo->{longDescription}
            , license => $buildInfo->{license}
            , homepage => $buildInfo->{homepage}
            , maintainers => $buildInfo->{maintainers}
            , nixname => $buildInfo->{nixName}
            , drvpath => $drvPath
            , outpath => $outPath
            , system => $buildInfo->{system}
            , iscurrent => 1
            , nixexprinput => $jobset->nixexprinput
            , nixexprpath => $jobset->nixexprpath
            });

Deletion in src/script/hydra_scheduler.pl at line 26 [8.1319]

B:BD[22.10442] → [15.5036:5156]

∅:D[15.5156] → [25.17990:18044]

B:BD[22.10442] → [25.17990:18044]

∅:D[25.18044] → [19.5722:5758]

B:BD[19.5722] → [19.5722:5758]

∅:D[16.262] → [23.12456:12524]

∅:D[19.5758] → [23.12456:12524]

B:BD[23.12456] → [23.12456:12524]

B:BD[23.12524] → [14.67:143]

B:BD[14.143] → [4.1043:1092]

∅:D[4.1092] → [14.144:357]

B:BD[7.1210] → [14.144:357]

∅:D[14.357] → [19.5759:5807]

B:BD[7.1302] → [19.5759:5807]

B:BD[19.5807] → [14.358:390]

∅:D[14.390] → [22.10662:10742]

∅:D[7.1342] → [22.10662:10742]

∅:D[19.5846] → [22.10662:10742]

B:BD[22.10662] → [22.10662:10742]

B:BD[22.10742] → [26.3852:3901]

∅:D[26.3901] → [22.10844:10932]

B:BD[22.10844] → [22.10844:10932]

B:BD[22.10932] → [14.391:464]

∅:D[14.464] → [27.2396:2449]

B:BD[22.11007] → [27.2396:2449]

∅:D[27.2449] → [22.11007:11037]

B:BD[22.11007] → [22.11007:11037]

∅:D[28.642] → [22.11037:11045]

B:BD[22.11037] → [22.11037:11045]

∅:D[29.5794] → [13.1176:1179]

∅:D[22.11045] → [13.1176:1179]

B:BD[13.1176] → [13.1176:1179]

B:BD[13.1179] → [10.2962:2964]

        print "added to queue as build ", $build->id, "\n";
        
        $currentBuilds->{$build->id} = 1;
        
        $build->create_related('buildschedulinginfo',
            { priority => $priority
            , busy => 0
            , locker => ""
            });
        my %inputs;
        $inputs{$jobset->nixexprinput} = $nixExprInput;
        foreach my $arg (@{$buildInfo->{arg}}) {
            $inputs{$arg->{name}} = $inputInfo->{$arg->{name}}->[$arg->{altnr}]
                || die "invalid input";
        }
        foreach my $name (keys %inputs) {
            my $input = $inputs{$name};
            $build->buildinputs_builds->create(
                { name => $name
                , type => $input->{type}
                , uri => $input->{uri}
                , revision => $input->{revision}
                , value => $input->{value}
                , dependency => $input->{id}
                , path => $input->{storePath} || "" # !!! temporary hack
                , sha256hash => $input->{sha256hash}
                });
        }
    });
};

Deletion in src/script/hydra_scheduler.pl at line 36 [8.1319]

B:BD[13.1181] → [7.1353:1416]

∅:D[7.1416] → [13.1316:1317]

B:BD[13.1316] → [13.1316:1317]

B:BD[13.1317] → [7.1417:1783]

B:BD[7.1783] → [30.1412:1462]

∅:D[30.1462] → [7.1824:1959]

B:BD[7.1824] → [7.1824:1959]

B:BD[7.1959] → [30.1463:1663]

∅:D[30.1663] → [7.2024:2094]

B:BD[7.2024] → [7.2024:2094]

∅:D[7.2094] → [13.2283:2297]

∅:D[31.2656] → [13.2283:2297]

∅:D[10.3714] → [13.2283:2297]

B:BD[13.2283] → [13.2283:2297]

∅:D[10.3784] → [13.2473:2489]

B:BD[13.2473] → [13.2473:2489]

∅:D[23.12814] → [13.2724:2725]

B:BD[13.2724] → [13.2724:2725]

B:BD[13.2725] → [7.2095:2112]

∅:D[7.2112] → [13.3609:3611]

B:BD[13.3609] → [13.3609:3611]

∅:D[13.3611] → [12.7480:7481]

B:BD[12.7480] → [12.7480:7481]

B:BD[12.7481] → [10.3981:3982]

sub inputsToArgs {
    my ($inputInfo) = @_;
    my @res = ();
    foreach my $input (keys %{$inputInfo}) {
        foreach my $alt (@{$inputInfo->{$input}}) {
            given ($alt->{type}) {
                when ("string") {
                    push @res, "--argstr", $input, $alt->{value};
                }
                when ("boolean") {
                    push @res, "--arg", $input, $alt->{value};
                }
                when (["svn", "path", "build"]) {
                    push @res, "--arg", $input, (
                        "{ outPath = builtins.storePath " . $alt->{storePath} . "" .
                        (defined $alt->{revision} ? "; rev = \"" . $alt->{revision} . "\"" : "") .
                        (defined $alt->{version} ? "; version = \"" . $alt->{version} . "\"" : "") .
                        ";}"
                    );
                }
            }
        }
    }
    return @res;
}

Replacement in src/script/hydra_scheduler.pl at line 54 [8.1319]

B:BD[14.544] → [14.544:608]

∅:D[14.608] → [7.2302:2372]

B:BD[7.2302] → [7.2302:2372]

B:BD[7.2372] → [17.1443:1600]

∅:D[17.1600] → [14.609:688]

B:BD[7.2372] → [14.609:688]

∅:D[14.688] → [10.3983:3984]

∅:D[7.2420] → [10.3983:3984]

B:BD[12.7582] → [10.3983:3984]

B:BD[12.7583] → [10.4024:4086]

B:BD[10.4086] → [32.1164:1273]

∅:D[33.687] → [10.4164:4252]

∅:D[32.1273] → [10.4164:4252]

∅:D[7.2483] → [10.4164:4252]

B:BD[10.4164] → [10.4164:4252]

B:BD[10.4252] → [32.1274:1303]

    my $nixExprInput = $inputInfo->{$jobset->nixexprinput}->[0]
        or die "cannot find the input containing the job expression";
    die "multiple alternatives for the input containing the Nix expression are not supported"
        if scalar @{$inputInfo->{$jobset->nixexprinput}} != 1;
    my $nixExprPath = $nixExprInput->{storePath} . "/" . $jobset->nixexprpath;
    (my $res, my $jobsXml, my $stderr) = captureStdoutStderr(
        "hydra_eval_jobs", $nixExprPath, "--gc-roots-dir", getGCRootsDir,
        inputsToArgs($inputInfo));
    die "cannot evaluate the Nix expression containing the jobs:\n$stderr" unless $res;
    print STDERR "$stderr";

[7.2226]

[12.7781]

    my ($jobs, $nixExprInput) = evalJobs($inputInfo, $jobset->nixexprinput, $jobset->nixexprpath);

Deletion in src/script/hydra_scheduler.pl at line 56 [8.1319]

B:BD[12.7810] → [12.7810:7841]

B:BD[12.7841] → [7.2484:2622]

∅:D[7.2622] → [12.8027:8069]

B:BD[12.8027] → [12.8027:8069]

∅:D[7.2817] → [12.8109:8110]

B:BD[12.8109] → [12.8109:8110]

    my $jobs = XMLin($jobsXml,
                     ForceArray => ['error', 'job', 'arg'],
                     KeyAttr => [],
                     SuppressEmpty => '')
        or die "cannot parse XML output";

Replacement in src/script/hydra_scheduler.pl at line 61 [8.1319]

B:BD[7.2965] → [4.1093:1182]

        checkBuild($project, $jobset, $inputInfo, $nixExprInput, $job, \%currentBuilds);

[7.2965]

[34.7080]

        checkBuild($db, $project, $jobset, $inputInfo, $nixExprInput, $job, \%currentBuilds);

* Implemented the clone feature.

Dependencies

In channels

Change contents

Replacement in src/lib/Hydra/Controller/Build.pm at line 407 [5.1]

Insertion in src/lib/Hydra/Controller/Build.pm at line 412 [5.1]

Replacement in src/lib/Hydra/Controller/Build.pm at line 422 [5.1]

Insertion in src/lib/Hydra/Controller/Build.pm at line 429 [5.1]

Replacement in src/lib/Hydra/Controller/Build.pm at line 434 [5.1]

Insertion in src/lib/Hydra/Helper/AddBuilds.pm at line 4 [3.2663]

Insertion in src/lib/Hydra/Helper/AddBuilds.pm at line 7 [3.2663]

Replacement in src/lib/Hydra/Helper/AddBuilds.pm at line 11 [3.2663]

Insertion in src/lib/Hydra/Helper/AddBuilds.pm at line 229 [3.2663]

Insertion in src/lib/Hydra/Helper/AddBuilds.pm at line 266 [3.2663]

Deletion in src/script/hydra_scheduler.pl at line 5 [8.1319]

Deletion in src/script/hydra_scheduler.pl at line 8 [8.1319]