grahamc/hydra - Change FPK5LF53CFUEKFYJ3IYXT4UTVC6IITWJOCFATMC4PLHEUP5SIEAAC

* Put the project-related actions in a separate controller. Put the

actions for viewing the job status and all builds in a separate base class that's inherited both by Root.pm and Project.pm so that we get URIs like /jobstatus and /project/<name>/jobstatus for free.

Created by Eelco Dolstra on March 4, 2009

FPK5LF53CFUEKFYJ3IYXT4UTVC6IITWJOCFATMC4PLHEUP5SIEAAC

Dependencies

In channels

upstream

main

Change contents

File addition: ListBuilds.pm (----------)

[10.19]

package Hydra::Base::Controller::ListBuilds;
use strict;
use warnings;
use base 'Catalyst::Controller';
use Hydra::Helper::Nix;
use Hydra::Helper::CatalystUtils;
sub jobstatus : Chained('get_builds') PathPart Args(0) {
    my ($self, $c) = @_;
    $c->stash->{latestBuilds} = getLatestBuilds($c, $c->stash->{allBuilds}, {});
}
    
sub all : Chained('get_builds') PathPart {
    my ($self, $c, $page) = @_;
    $c->stash->{template} = 'all.tt';
    $page = (defined $page ? int($page) : 1) || 1;
    my $resultsPerPage = 50;
    my $nrBuilds = scalar($c->stash->{allBuilds}->search({finished => 1}));
    $c->stash->{baseUri} = $c->uri_for($self->action_for("all"), $c->req->captures);
    $c->stash->{page} = $page;
    $c->stash->{resultsPerPage} = $resultsPerPage;
    $c->stash->{totalBuilds} = $nrBuilds;
    $c->stash->{builds} = [$c->stash->{allBuilds}->search(
        {finished => 1}, {order_by => "timestamp DESC", rows => $resultsPerPage, page => $page})];
}
1;

Replacement in src/Hydra/lib/Hydra/Base/Controller/Nix.pm at line 5 [10.43]
B:BD[10.109] → [10.109:144]
```
use parent 'Catalyst::Controller';
```
[10.109]
[10.144]
```
use base 'Catalyst::Controller';
```
Replacement in src/Hydra/lib/Hydra/Controller/Build.pm at line 122 [12.1]
B:BD[11.527] → [11.527:578]
```
    $c->response->content_type('image/png'); # !!!
```
[11.527]
[11.578]
```
    $c->res->content_type('image/png'); # !!!
```
Replacement in src/Hydra/lib/Hydra/Controller/Build.pm at line 137 [12.1]
B:BD[11.956] → [11.956:1007]
```
    $c->response->content_type('image/png'); # !!!
```
[11.956]
[11.1007]
```
    $c->res->content_type('image/png'); # !!!
```

Replacement in src/Hydra/lib/Hydra/Controller/Build.pm at line 186 [12.1]

B:BD[7.823] → [7.823:916]

    $c->response->redirect($c->uri_for($self->action_for("view_build"), $c->req->captures));

[7.823]

[12.3293]

    $c->res->redirect($c->uri_for($self->action_for("view_build"), $c->req->captures));

File addition: Project.pm (----------)

[13.54]

package Hydra::Controller::Project;
use strict;
use warnings;
use base 'Hydra::Base::Controller::ListBuilds';
use Hydra::Helper::Nix;
use Hydra::Helper::CatalystUtils;
__PACKAGE__->config->{namespace} = '';
sub project : Chained('/') PathPart('project') CaptureArgs(1) {
    my ($self, $c, $projectName) = @_;
    
    my $project = $c->model('DB::Projects')->find($projectName);
    notFound($c, "Project $projectName doesn't exist.") unless defined $project;
    $c->stash->{curProject} = $project;
}
sub view : Chained('project') PathPart('') Args(0) {
    my ($self, $c) = @_;
    $c->stash->{template} = 'project.tt';
    getBuildStats($c, scalar $c->stash->{curProject}->builds);
}
sub edit : Chained('project') PathPart Args(0) {
    my ($self, $c) = @_;
    requireProjectOwner($c, $c->stash->{curProject});
    $c->stash->{template} = 'project.tt';
    $c->stash->{edit} = 1;
}
sub submit : Chained('project') PathPart Args(0) {
    my ($self, $c) = @_;
    requireProjectOwner($c, $c->stash->{curProject});
    error($c, "Request must be POSTed.") if $c->request->method ne "POST";
    
    $c->model('DB')->schema->txn_do(sub {
        updateProject($c, $c->stash->{curProject});
    });
    
    $c->res->redirect($c->uri_for($self->action_for("view"), $c->req->captures));
}
sub delete : Chained('project') PathPart Args(0) {
    my ($self, $c) = @_;
    requireProjectOwner($c, $c->stash->{curProject});
    error($c, "Request must be POSTed.") if $c->request->method ne "POST";
    
    $c->model('DB')->schema->txn_do(sub {
        $c->stash->{curProject}->delete;
    });
    
    $c->res->redirect($c->uri_for("/"));
}
sub create : Path('create-project') {
    my ($self, $c) = @_;
    requireAdmin($c);
    $c->stash->{template} = 'project.tt';
    $c->stash->{create} = 1;
    $c->stash->{edit} = 1;
}
sub create_submit : Path('create-project/submit') {
    my ($self, $c) = @_;
    requireAdmin($c);
    my $projectName = trim $c->request->params->{name};
    
    $c->model('DB')->schema->txn_do(sub {
        # Note: $projectName is validated in updateProject,
        # which will abort the transaction if the name isn't
        # valid.  Idem for the owner.
        my $project = $c->model('DB::Projects')->create(
            {name => $projectName, displayname => "", owner => trim $c->request->params->{owner}});
        updateProject($c, $project);
    });
    
    $c->res->redirect($c->uri_for($self->action_for("view"), [$projectName]));
}
sub updateProject {
    my ($c, $project) = @_;
    my $projectName = trim $c->request->params->{name};
    error($c, "Invalid project name: " . ($projectName || "(empty)")) unless $projectName =~ /^[[:alpha:]]\w*$/;
    
    my $displayName = trim $c->request->params->{displayname};
    error($c, "Invalid display name: $displayName") if $displayName eq "";
    
    $project->name($projectName);
    $project->displayname($displayName);
    $project->description(trim $c->request->params->{description});
    $project->homepage(trim $c->request->params->{homepage});
    $project->enabled(trim($c->request->params->{enabled}) eq "1" ? 1 : 0);
    if ($c->check_user_roles('admin')) {
        my $owner = trim $c->request->params->{owner};
        error($c, "Invalid owner: $owner")
            unless defined $c->model('DB::Users')->find({username => $owner});
        $project->owner($owner);
    }
    $project->update;
    
    my %jobsetNames;
    foreach my $param (keys %{$c->request->params}) {
        next unless $param =~ /^jobset-(\w+)-name$/;
        my $baseName = $1;
        next if $baseName eq "template";
        my $jobsetName = trim $c->request->params->{"jobset-$baseName-name"};
        error($c, "Invalid jobset name: $jobsetName") unless $jobsetName =~ /^[[:alpha:]]\w*$/;
        # The Nix expression path must be relative and can't contain ".." elements.
        my $nixExprPath = trim $c->request->params->{"jobset-$baseName-nixexprpath"};
        error($c, "Invalid Nix expression path: $nixExprPath") if $nixExprPath !~ /^$relPathRE$/;
        my $nixExprInput = trim $c->request->params->{"jobset-$baseName-nixexprinput"};
        error($c, "Invalid Nix expression input name: $nixExprInput") unless $nixExprInput =~ /^\w+$/;
        $jobsetNames{$jobsetName} = 1;
        my $jobset;
        my $description = trim $c->request->params->{"jobset-$baseName-description"};
        if ($baseName =~ /^\d+$/) { # numeric base name is auto-generated, i.e. a new entry
            $jobset = $project->jobsets->create(
                { name => $jobsetName
                , description => $description
                , nixexprpath => $nixExprPath
                , nixexprinput => $nixExprInput
                });
        } else { # it's an existing jobset
            $jobset = ($project->jobsets->search({name => $baseName}))[0];
            die unless defined $jobset;
            $jobset->name($jobsetName);
            $jobset->description($description);
            $jobset->nixexprpath($nixExprPath);
            $jobset->nixexprinput($nixExprInput);
            $jobset->update;
        }
        my %inputNames;
        
        # Process the inputs of this jobset.
        foreach my $param (keys %{$c->request->params}) {
            next unless $param =~ /^jobset-$baseName-input-(\w+)-name$/;
            my $baseName2 = $1;
            next if $baseName2 eq "template";
            print STDERR "GOT INPUT: $baseName2\n";
            my $inputName = trim $c->request->params->{"jobset-$baseName-input-$baseName2-name"};
            error($c, "Invalid input name: $inputName") unless $inputName =~ /^[[:alpha:]]\w*$/;
            my $inputType = trim $c->request->params->{"jobset-$baseName-input-$baseName2-type"};
            error($c, "Invalid input type: $inputType") unless
                $inputType eq "svn" || $inputType eq "cvs" || $inputType eq "tarball" ||
                $inputType eq "string" || $inputType eq "path" || $inputType eq "boolean";
            $inputNames{$inputName} = 1;
            
            my $input;
            if ($baseName2 =~ /^\d+$/) { # numeric base name is auto-generated, i.e. a new entry
                $input = $jobset->jobsetinputs->create(
                    { name => $inputName
                    , type => $inputType
                    });
            } else { # it's an existing jobset
                $input = ($jobset->jobsetinputs->search({name => $baseName2}))[0];
                die unless defined $input;
                $input->name($inputName);
                $input->type($inputType);
                $input->update;
            }
            # Update the values for this input.  Just delete all the
            # current ones, then create the new values.
            $input->jobsetinputalts->delete_all;
            my $values = $c->request->params->{"jobset-$baseName-input-$baseName2-values"};
            $values = [] unless defined $values;
            $values = [$values] unless ref($values) eq 'ARRAY';
            my $altnr = 0;
            foreach my $value (@{$values}) {
                print STDERR "VALUE: $value\n";
                my $value = trim $value;
                error($c, "Invalid Boolean value: $value") if
                    $inputType eq "boolean" && !($value eq "true" || $value eq "false");
                $input->jobsetinputalts->create({altnr => $altnr++, value => $value});
            }
        }
        # Get rid of deleted inputs.
        my @inputs = $jobset->jobsetinputs->all;
        foreach my $input (@inputs) {
            $input->delete unless defined $inputNames{$input->name};
        }
    }
    # Get rid of deleted jobsets, i.e., ones that are no longer submitted in the parameters.
    my @jobsets = $project->jobsets->all;
    foreach my $jobset (@jobsets) {
        $jobset->delete unless defined $jobsetNames{$jobset->name};
    }
}
# Hydra::Base::Controller::ListBuilds needs this.
sub get_builds : Chained('project') PathPart('') CaptureArgs(0) {
    my ($self, $c) = @_;
    $c->stash->{allBuilds} = $c->stash->{curProject}->builds;
}
1;

Insertion in src/Hydra/lib/Hydra/Controller/Root.pm at line 6 [16.804]
[14.47]
[15.86]
```
use base 'Hydra::Base::Controller::ListBuilds';
```
Deletion in src/Hydra/lib/Hydra/Controller/Root.pm at line 19 [16.804]
∅:D[17.75] → [16.1224:1226]
B:BD[16.1224] → [16.1224:1226]
B:BD[16.1226] → [18.0:1]
∅:D[18.1] → [16.1226:1227]
B:BD[16.1226] → [16.1226:1227]
B:BD[16.1227] → [18.2:73]
```
}
sub trim {
    my $s = shift;
    $s =~ s/^\s+|\s+$//g;
    return $s;
```

Deletion in src/Hydra/lib/Hydra/Controller/Root.pm at line 22 [16.804]

B:BD[16.1355] → [19.0:678]

sub getBuildStats {
    my ($c, $builds) = @_;
    
    $c->stash->{finishedBuilds} = $builds->search({finished => 1}) || 0;
    
    $c->stash->{succeededBuilds} = $builds->search(
        {finished => 1, buildStatus => 0},
        {join => 'resultInfo'}) || 0;
        
    $c->stash->{scheduledBuilds} = $builds->search({finished => 0}) || 0;
        
    $c->stash->{busyBuilds} = $builds->search(
        {finished => 0, busy => 1},
        {join => 'schedulingInfo'}) || 0;
        
    $c->stash->{totalBuildTime} = $builds->search({},
        {join => 'resultInfo', select => {sum => 'stoptime - starttime'}, as => ['sum']})
        ->first->get_column('sum') || 0;
}

Deletion in src/Hydra/lib/Hydra/Controller/Root.pm at line 63 [16.804]

B:BD[20.299] → [21.0:4]

B:BD[21.4] → [14.48:110]

B:BD[14.110] → [8.0:576]

∅:D[8.576] → [14.155:308]

B:BD[14.155] → [14.155:308]

B:BD[14.308] → [8.577:643]

∅:D[14.372] → [21.522:526]

∅:D[8.643] → [21.522:526]

B:BD[21.522] → [21.522:526]

B:BD[21.526] → [22.386:550]

∅:D[22.550] → [21.575:614]

B:BD[21.575] → [21.575:614]

B:BD[21.614] → [23.0:51]

∅:D[23.51] → [21.643:674]

B:BD[21.643] → [21.643:674]

B:BD[21.674] → [22.551:612]

∅:D[22.612] → [21.751:752]

B:BD[21.751] → [21.751:752]

B:BD[21.752] → [22.613:650]

∅:D[22.650] → [21.752:877]

B:BD[21.752] → [21.752:877]

B:BD[21.877] → [22.651:695]

∅:D[22.695] → [21.937:1036]

B:BD[21.937] → [21.937:1036]

∅:D[20.299] → [24.0:4]

∅:D[21.1036] → [24.0:4]

B:BD[25.604] → [24.0:4]

B:BD[24.4] → [22.696:821]

}
# Return the latest build for each job.
sub getLatestBuilds {
    my ($c, $builds, $extraAttrs) = @_;
    my @res = ();
    foreach my $job ($builds->search({},
        {group_by => ['project', 'attrname', 'system']}))
    {
        my $attrs =
            { project => $job->get_column('project')
            , attrname => $job->attrname
            , system => $job->system
            , finished => 1
            };
        my ($build) = $builds->search({ %$attrs, %$extraAttrs },
            { join => 'resultInfo', order_by => 'timestamp DESC', rows => 1 } );
        push @res, $build if defined $build;
    }
    return [@res];
}
sub showJobStatus {
    my ($c, $builds) = @_;
    $c->stash->{template} = 'jobstatus.tt';
    # Get the latest finished build for each unique job.
    $c->stash->{latestBuilds} = getLatestBuilds($c, $builds, {});
}
sub jobstatus :Local {
    my ($self, $c) = @_;
    showJobStatus($c, $c->model('DB::Builds'));
}
sub showAllBuilds {
    my ($c, $baseUri, $page, $builds) = @_;
    $c->stash->{template} = 'all.tt';
    $page = (defined $page ? int($page) : 1) || 1;
    my $resultsPerPage = 50;
    my $nrBuilds = scalar($builds->search({finished => 1}));
    $c->stash->{baseUri} = $baseUri;
    $c->stash->{page} = $page;
    $c->stash->{resultsPerPage} = $resultsPerPage;
    $c->stash->{totalBuilds} = $nrBuilds;
    $c->stash->{builds} = [$builds->search(
        {finished => 1}, {order_by => "timestamp DESC", rows => $resultsPerPage, page => $page})];
}
sub all :Local {
    my ($self, $c, $page) = @_;
    showAllBuilds($c, $c->uri_for("/all"), $page, $c->model('DB::Builds'));

Deletion in src/Hydra/lib/Hydra/Controller/Root.pm at line 221 [16.804]

B:BD[22.823] → [22.823:825]

∅:D[22.825] → [24.4:52]

B:BD[24.4] → [24.4:52]

B:BD[24.53] → [18.78:134]

∅:D[18.134] → [24.104:197]

B:BD[24.104] → [24.104:197]

B:BD[24.197] → [18.135:266]

∅:D[26.163] → [24.335:415]

∅:D[18.266] → [24.335:415]

B:BD[24.335] → [24.335:415]

B:BD[24.415] → [18.267:335]

B:BD[18.335] → [6.0:62]

∅:D[6.62] → [18.335:411]

B:BD[18.335] → [18.335:411]

B:BD[18.411] → [5.0:251]

∅:D[27.70] → [28.0:23]

∅:D[29.182] → [28.0:23]

∅:D[26.226] → [28.0:23]

∅:D[5.251] → [28.0:23]

∅:D[18.411] → [28.0:23]

B:BD[24.478] → [28.0:23]

∅:D[28.23] → [24.478:483]

B:BD[24.478] → [24.478:483]

B:BD[24.483] → [28.24:222]

B:BD[28.222] → [18.412:490]

∅:D[18.490] → [28.295:385]

B:BD[28.295] → [28.295:385]

B:BD[28.385] → [30.147:231]

B:BD[30.231] → [18.491:577]

B:BD[18.577] → [31.0:91]


sub updateProject {
    my ($c, $project) = @_;
    my $projectName = trim $c->request->params->{name};
    die "Invalid project name: $projectName" unless $projectName =~ /^[[:alpha:]]\w*$/;
    
    my $displayName = trim $c->request->params->{displayname};
    die "Invalid display name: $displayName" if $displayName eq "";
    
    $project->name($projectName);
    $project->displayname($displayName);
    $project->description(trim $c->request->params->{description});
    $project->homepage(trim $c->request->params->{homepage});
    $project->enabled(trim($c->request->params->{enabled}) eq "1" ? 1 : 0);
    if ($c->check_user_roles('admin')) {
        my $owner = trim $c->request->params->{owner};
        die "Invalid owner: $owner"
            unless defined $c->model('DB::Users')->find({username => $owner});
        $project->owner($owner);
    }
    $project->update;
    
    my %jobsetNames;
    foreach my $param (keys %{$c->request->params}) {
        next unless $param =~ /^jobset-(\w+)-name$/;
        my $baseName = $1;
        next if $baseName eq "template";
        my $jobsetName = trim $c->request->params->{"jobset-$baseName-name"};
        die "Invalid jobset name: $jobsetName" unless $jobsetName =~ /^[[:alpha:]]\w*$/;
        # The Nix expression path must be relative and can't contain ".." elements.
        my $nixExprPath = trim $c->request->params->{"jobset-$baseName-nixexprpath"};
        die "Invalid Nix expression path: $nixExprPath" if $nixExprPath !~ /^$relPathRE$/;

Deletion in src/Hydra/lib/Hydra/Controller/Root.pm at line 222 [16.804]

B:BD[28.571] → [18.578:666]

∅:D[18.666] → [28.654:750]

B:BD[28.654] → [28.654:750]

        my $nixExprInput = trim $c->request->params->{"jobset-$baseName-nixexprinput"};
        die "Invalid Nix expression input name: $nixExprInput" unless $nixExprInput =~ /^\w+$/;

Deletion in src/Hydra/lib/Hydra/Controller/Root.pm at line 223 [16.804]

B:BD[28.751] → [28.751:790]

B:BD[28.790] → [32.0:21]

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

∅:D[32.21] → [28.790:883]

∅:D[4.87] → [28.790:883]

B:BD[28.790] → [28.790:883]

B:BD[28.883] → [32.22:109]

B:BD[32.109] → [4.88:134]

∅:D[4.134] → [28.1111:1268]

∅:D[18.759] → [28.1111:1268]

B:BD[28.1111] → [28.1111:1268]

B:BD[28.1268] → [32.110:185]

∅:D[32.185] → [28.1343:1423]

B:BD[28.1343] → [28.1343:1423]

B:BD[28.1423] → [4.135:183]

∅:D[4.183] → [28.1512:1639]

∅:D[18.854] → [28.1512:1639]

B:BD[28.1512] → [28.1512:1639]

B:BD[28.1639] → [32.186:196]

B:BD[32.196] → [33.0:25]

∅:D[33.25] → [32.196:512]

B:BD[32.196] → [32.196:512]

B:BD[32.512] → [18.855:953]

∅:D[18.953] → [32.605:696]

B:BD[32.605] → [32.605:696]

B:BD[32.696] → [18.954:1052]

∅:D[18.1052] → [32.789:934]

B:BD[32.789] → [32.789:934]

B:BD[32.934] → [34.0:91]

∅:D[34.91] → [32.998:999]

B:BD[32.998] → [32.998:999]

B:BD[32.999] → [33.26:80]

∅:D[33.80] → [32.999:1119]

B:BD[32.999] → [32.999:1119]

B:BD[32.1119] → [33.81:243]

∅:D[33.243] → [32.1119:1689]

B:BD[32.1119] → [32.1119:1689]

B:BD[32.1689] → [2.0:49]

∅:D[2.49] → [32.1689:1873]

B:BD[32.1689] → [32.1689:1873]

B:BD[32.1873] → [34.92:364]

∅:D[34.364] → [32.1960:1974]

∅:D[18.1145] → [32.1960:1974]

B:BD[32.1960] → [32.1960:1974]

∅:D[32.1974] → [28.1639:1649]

B:BD[28.1639] → [28.1639:1649]

B:BD[28.1649] → [33.244:245]

B:BD[33.245] → [3.0:37]

∅:D[3.37] → [33.282:448]

B:BD[33.282] → [33.282:448]

∅:D[33.448] → [28.1649:1901]

B:BD[28.1649] → [28.1649:1901]

∅:D[24.505] → [35.0:25]

∅:D[25.604] → [35.0:25]

∅:D[28.1901] → [35.0:25]

B:BD[36.226] → [35.0:25]

B:BD[35.25] → [22.826:884]

∅:D[20.352] → [35.66:108]

∅:D[24.560] → [35.66:108]

∅:D[22.884] → [35.66:108]

B:BD[35.66] → [35.66:108]

B:BD[35.108] → [37.0:5]

B:BD[37.5] → [38.2919:2984]

B:BD[38.2984] → [10.2903:2981]

∅:D[18.1228] → [24.561:613]

∅:D[10.2981] → [24.561:613]

B:BD[35.280] → [24.561:613]

B:BD[24.613] → [22.885:930]

∅:D[22.930] → [24.613:662]

B:BD[24.613] → [24.613:662]

B:BD[24.662] → [22.931:1035]

∅:D[22.1035] → [29.183:184]

B:BD[24.662] → [29.183:184]

B:BD[29.184] → [22.1036:1233]

B:BD[29.267] → [26.227:228]

B:BD[26.228] → [7.1001:1044]

∅:D[39.301] → [29.267:276]

∅:D[26.419] → [29.267:276]

∅:D[7.1044] → [29.267:276]

B:BD[29.267] → [29.267:276]

B:BD[29.487] → [29.487:736]

B:BD[29.736] → [40.1792:1871]

∅:D[40.1871] → [29.833:843]

B:BD[29.833] → [29.833:843]

∅:D[29.843] → [24.662:663]

B:BD[24.662] → [24.662:663]

B:BD[24.663] → [29.844:1081]

B:BD[29.1081] → [10.3076:3134]

∅:D[10.3134] → [29.1146:1156]

B:BD[29.1146] → [29.1146:1156]

∅:D[29.1156] → [24.1253:1260]

B:BD[24.1253] → [24.1253:1260]

B:BD[41.141] → [19.744:792]

∅:D[42.125] → [41.972:977]

∅:D[19.792] → [41.972:977]

B:BD[41.972] → [41.972:977]

∅:D[41.977] → [35.317:475]

B:BD[35.317] → [35.317:475]

∅:D[36.226] → [43.0:3]

∅:D[44.303] → [43.0:3]

∅:D[35.475] → [43.0:3]

B:BD[45.397] → [43.0:3]

B:BD[43.3] → [24.1261:1289]

B:BD[24.1289] → [20.353:391]

∅:D[20.391] → [43.3:4]

∅:D[24.1329] → [43.3:4]

B:BD[43.3] → [43.3:4]

B:BD[43.4] → [7.1045:1087]

∅:D[7.1087] → [26.420:421]

B:BD[29.1206] → [26.420:421]

B:BD[26.421] → [10.3135:3193]

∅:D[10.3193] → [26.486:532]

B:BD[26.486] → [26.486:532]

∅:D[26.532] → [29.1329:1330]

B:BD[29.1329] → [29.1329:1330]

∅:D[29.1330] → [24.1330:1388]

B:BD[43.4] → [24.1330:1388]

B:BD[24.1388] → [10.3194:3762]

∅:D[10.3762] → [24.1993:2106]

B:BD[24.1993] → [24.1993:2106]

        $jobsetNames{$jobsetName} = 1;
        my $jobset;
        my $description = trim $c->request->params->{"jobset-$baseName-description"};
        if ($baseName =~ /^\d+$/) { # numeric base name is auto-generated, i.e. a new entry
            $jobset = $project->jobsets->create(
                { name => $jobsetName
                , description => $description
                , nixexprpath => $nixExprPath
                , nixexprinput => $nixExprInput
                });
        } else { # it's an existing jobset
            $jobset = ($project->jobsets->search({name => $baseName}))[0];
            die unless defined $jobset;
            $jobset->name($jobsetName);
            $jobset->description($description);
            $jobset->nixexprpath($nixExprPath);
            $jobset->nixexprinput($nixExprInput);
            $jobset->update;
        }
        my %inputNames;
        
        # Process the inputs of this jobset.
        foreach my $param (keys %{$c->request->params}) {
            next unless $param =~ /^jobset-$baseName-input-(\w+)-name$/;
            my $baseName2 = $1;
            next if $baseName2 eq "template";
            print STDERR "GOT INPUT: $baseName2\n";
            my $inputName = trim $c->request->params->{"jobset-$baseName-input-$baseName2-name"};
            die "Invalid input name: $inputName" unless $inputName =~ /^[[:alpha:]]\w*$/;
            my $inputType = trim $c->request->params->{"jobset-$baseName-input-$baseName2-type"};
            die "Invalid input type: $inputType" unless
                $inputType eq "svn" || $inputType eq "cvs" || $inputType eq "tarball" ||
                $inputType eq "string" || $inputType eq "path" || $inputType eq "boolean";
            $inputNames{$inputName} = 1;
            
            my $input;
            if ($baseName2 =~ /^\d+$/) { # numeric base name is auto-generated, i.e. a new entry
                $input = $jobset->jobsetinputs->create(
                    { name => $inputName
                    , type => $inputType
                    });
            } else { # it's an existing jobset
                $input = ($jobset->jobsetinputs->search({name => $baseName2}))[0];
                die unless defined $input;
                $input->name($inputName);
                $input->type($inputType);
                $input->update;
            }
            # Update the values for this input.  Just delete all the
            # current ones, then create the new values.
            $input->jobsetinputalts->delete_all;
            my $values = $c->request->params->{"jobset-$baseName-input-$baseName2-values"};
            $values = [] unless defined $values;
            $values = [$values] unless ref($values) eq 'ARRAY';
            my $altnr = 0;
            foreach my $value (@{$values}) {
                print STDERR "VALUE: $value\n";
                my $value = trim $value;
                die "Invalid Boolean value: $value" if
                    $inputType eq "boolean" && !($value eq "true" || $value eq "false");
                $input->jobsetinputalts->create({altnr => $altnr++, value => $value});
            }
        }
        # Get rid of deleted inputs.
        my @inputs = $jobset->jobsetinputs->all;
        foreach my $input (@inputs) {
            $input->delete unless defined $inputNames{$input->name};
        }
    }
    # Get rid of deleted jobsets, i.e., ones that are no longer submitted in the parameters.
    my @jobsets = $project->jobsets->all;
    foreach my $jobset (@jobsets) {
        $jobset->delete unless defined $jobsetNames{$jobset->name};
    }
}
sub project :Local {
    my ($self, $c, $projectName, $subcommand, $arg) = @_;
    $c->stash->{template} = 'project.tt';
    
    my $project = $c->model('DB::Projects')->find($projectName);
    notFound($c, "Project $projectName doesn't exist.") if !defined $project;
    my $isPosted = $c->request->method eq "POST";
    $c->stash->{curProject} = $project;
    
    $subcommand = "" unless defined $subcommand;
    if ($subcommand eq "jobstatus") {
        return showJobStatus($c, scalar $project->builds);
    }
    elsif ($subcommand eq "all") {
        return showAllBuilds($c, $c->uri_for("/project", $projectName, "all"),
            $arg, scalar $project->builds);
    }
    elsif ($subcommand ne "") {
        requireProjectOwner($c, $project);
        
        if ($subcommand eq "edit") {
            $c->stash->{edit} = 1;
        }
        elsif ($subcommand eq "submit" && $isPosted) {
            $c->model('DB')->schema->txn_do(sub {
                updateProject($c, $project);
            });
            return $c->res->redirect($c->uri_for("/project", $project->name));
        }
        elsif ($subcommand eq "delete" && $isPosted) {
            $c->model('DB')->schema->txn_do(sub {
                $project->delete;
            });
            return $c->res->redirect($c->uri_for("/"));
        }
        else {
            error($c, "Unknown subcommand $subcommand.");
        }
    }
    getBuildStats($c, scalar $project->builds);
    
    $c->stash->{jobNames} =
        [$c->model('DB::Builds')->search({project => $projectName}, {select => [{distinct => 'attrname'}], as => ['attrname']})];
}
sub createproject :Local {
    my ($self, $c, $subcommand) = @_;
    requireLogin($c) if !$c->user_exists;
    error($c, "Only administrators can create projects.")
        unless $c->check_user_roles('admin');
    if (defined $subcommand && $subcommand eq "submit") {
        my $projectName = trim $c->request->params->{name};
        $c->model('DB')->schema->txn_do(sub {
            # Note: $projectName is validated in updateProject,
            # which will abort the transaction if the name isn't
            # valid.  Idem for the owner.
            my $project = $c->model('DB::Projects')->create(
                {name => $projectName, displayname => "", owner => trim $c->request->params->{owner}});
            updateProject($c, $project);
        });
        return $c->res->redirect($c->uri_for("/project", $projectName));
    }
    
    $c->stash->{template} = 'project.tt';
    $c->stash->{create} = 1;
    $c->stash->{edit} = 1;
}

Insertion in src/Hydra/lib/Hydra/Controller/Root.pm at line 259 [16.804]

[14.712]

[16.1511]

# Hydra::Base::Controller::ListBuilds needs this.
sub get_builds : Chained('/') PathPart('') CaptureArgs(0) {
    my ($self, $c) = @_;
    $c->stash->{allBuilds} = $c->model('DB::Builds');
}

Replacement in src/Hydra/lib/Hydra/Helper/CatalystUtils.pm at line 9 [12.3469]

B:BD[31.125] → [31.125:153]

B:BD[31.153] → [7.1088:1125]

    getBuild error notFound
    requireLogin requireProjectOwner

[31.125]

[31.153]

    getBuild getBuildStats getLatestBuilds
    error notFound
    requireLogin requireProjectOwner requireAdmin
    trim

Insertion in src/Hydra/lib/Hydra/Helper/CatalystUtils.pm at line 21 [12.3469]

[12.3706]

}
sub getBuildStats {
    my ($c, $builds) = @_;
    
    $c->stash->{finishedBuilds} = $builds->search({finished => 1}) || 0;
    
    $c->stash->{succeededBuilds} = $builds->search(
        {finished => 1, buildStatus => 0},
        {join => 'resultInfo'}) || 0;
        
    $c->stash->{scheduledBuilds} = $builds->search({finished => 0}) || 0;
        
    $c->stash->{busyBuilds} = $builds->search(
        {finished => 0, busy => 1},
        {join => 'schedulingInfo'}) || 0;
        
    $c->stash->{totalBuildTime} = $builds->search({},
        {join => 'resultInfo', select => {sum => 'stoptime - starttime'}, as => ['sum']})
        ->first->get_column('sum') || 0;
}
# Return the latest build for each job.
sub getLatestBuilds {
    my ($c, $builds, $extraAttrs) = @_;
    my @res = ();
    foreach my $job ($builds->search({},
        {group_by => ['project', 'attrname', 'system']}))
    {
        my $attrs =
            { project => $job->get_column('project')
            , attrname => $job->attrname
            , system => $job->system
            , finished => 1
            };
        my ($build) = $builds->search({ %$attrs, %$extraAttrs },
            { join => 'resultInfo', order_by => 'timestamp DESC', rows => 1 } );
        push @res, $build if defined $build;
    }
    return [@res];

Replacement in src/Hydra/lib/Hydra/Helper/CatalystUtils.pm at line 96 [12.3469]

B:BD[7.1439] → [7.1439:1528]

    error($c, "Only the project owner or the administrator can perform this operation.")

[7.1439]

[7.1528]

    error($c, "Only the project owner or administrators can perform this operation.")

Insertion in src/Hydra/lib/Hydra/Helper/CatalystUtils.pm at line 101 [12.3469]

[7.1629]

[31.184]

sub requireAdmin {
    my ($c) = @_;
    requireLogin($c) if !$c->user_exists;
    
    error($c, "Only administrators can perform this operation.")
        unless $c->check_user_roles('admin');
}
sub trim {
    my $s = shift;
    $s =~ s/^\s+|\s+$//g;
    return $s;
}

Replacement in src/Hydra/root/error.tt at line 6 [16.8490]

B:BD[16.8555] → [9.76:216]

<p>I'm very sorry, but an error occurred: <span class="error-msg">[% FOREACH error IN errors %][% HTML.escape(error) %][% END %]</span></p>

[16.8555]

[16.8645]

<p>I'm very sorry, but the following error(s) occurred:</p>
<ul>
[% FOREACH error IN errors %]
<li><div class="error-msg">[% HTML.escape(error) %]</div></li>
[% END %]
</ul>

Replacement in src/Hydra/root/layout.tt at line 135 [16.11219]

B:BD[46.4611] → [46.4611:4707]

              [% INCLUDE makeLink uri = c.uri_for('/createproject') title = "Create project" %]

[46.4611]

[47.4682]

              [% INCLUDE makeLink uri = c.uri_for('/create-project') title = "Create project" %]

Replacement in src/Hydra/root/project.tt at line 142 [48.1667]

B:BD[28.2884] → [28.2884:3043]

  <form action="[% IF create %][% c.uri_for('/createproject/submit') %][% ELSE %][% c.uri_for('/project' curProject.name 'submit') %][% END %]" method="post">

[28.2884]

[28.3043]

  <form action="[% IF create %][% c.uri_for('/create-project/submit') %][% ELSE %][% c.uri_for('/project' curProject.name 'submit') %][% END %]" method="post">