grahamc/hydra2 - Change LZVO64YG43JD7YMZSCTZNOBS5ROZA4FMPKJW2YOMHX2V5PTGBVWQC

Merge in the first bits of the API work

The catalyst-action-rest branch from shlevy/hydra was an exploration of using Catalyst::Action::REST to create a JSON API for hydra. This commit merges in the best bits from that experiment, with the goal that further API endpoints can be added incrementally.

In addition to migrating more endpoints, there is potential for improvement in what's already been done:

The web interface can be updated to use the same non-GET endpoints as the JSON interface (using x-tunneled-method) instead of having a separate endpoint
The web rendering should use the $c->stash->{resource} data structure where applicable rather than putting the same data in two places in the stash
Which columns to render for each endpoint is a completely debatable question
Hydra::Component::ToJSON should turn has_many relations that have strings as their primary keys into objects instead of arrays

Fixes NixOS/hydra#98

Signed-off-by: Shea Levy <shea@shealevy.com>

Created by Shea Levy on June 17, 2013

LZVO64YG43JD7YMZSCTZNOBS5ROZA4FMPKJW2YOMHX2V5PTGBVWQC

Dependencies

In channels

main

Change contents

Insertion in release.nix at line 74 [19.1]
[15.556]
[15.601]
```
            CatalystActionREST
```

Insertion in release.nix at line 171 [19.1]

[20.1077]

[21.3482]

  tests.api = genAttrs' (system:
    with import <nixos/lib/testing.nix> { inherit system; };
    let hydra = builtins.getAttr system build; in # build.${system}
    simpleTest {
      machine =
        { config, pkgs, ... }:
        { services.postgresql.enable = true;
          services.postgresql.package = pkgs.postgresql92;
          environment.systemPackages = [ hydra pkgs.perlPackages.LWP pkgs.perlPackages.JSON ];
          virtualisation.memorySize = 2048;
        };
      testScript =
        ''
          $machine->waitForJob("postgresql");
          # Initialise the database and the state.
          $machine->mustSucceed
              ( "createdb -O root hydra"
              , "psql hydra -f ${hydra}/libexec/hydra/sql/hydra-postgresql.sql"
              , "mkdir /var/lib/hydra"
              , "echo \"insert into Users(userName, emailAddress, password) values('root', 'e.dolstra\@tudelft.nl', '\$(echo -n foobar | sha1sum | cut -c1-40)');\" | psql hydra"
              , "echo \"insert into UserRoles(userName, role) values('root', 'admin');\" | psql hydra"
              , "mkdir /run/jobset"
              , "chmod 755 /run/jobset"
              , "cp ${./tests/api-test.nix} /run/jobset/default.nix"
              , "chmod 644 /run/jobset/default.nix"
              );
          # Start the web interface.
          $machine->mustSucceed("NIX_STORE_DIR=/run/nix NIX_LOG_DIR=/run/nix/var/log/nix NIX_STATE_DIR=/run/nix/var/nix HYDRA_DATA=/var/lib/hydra HYDRA_DBI='dbi:Pg:dbname=hydra;user=root;' LOGNAME=root DBIC_TRACE=1 hydra-server -d >&2 &");
          $machine->waitForOpenPort("3000");
          $machine->mustSucceed("perl ${./tests/api-test.pl} >&2");
        '';
  });

Replacement in src/lib/Hydra/Base/Controller/ListBuilds.pm at line 104 [24.1]

∅:D[22.845] → [23.33:142]

B:BD[25.372] → [23.33:142]

    $c->res->redirect($c->uri_for($c->controller('Build')->action_for("view_build"), [$latest->id], @rest));

[22.845]

[25.479]

    $c->res->redirect($c->uri_for($c->controller('Build')->action_for("build"), [$latest->id], @rest));

Replacement in src/lib/Hydra/Base/Controller/ListBuilds.pm at line 119 [24.1]

∅:D[22.849] → [23.185:294]

B:BD[25.1143] → [23.185:294]

    $c->res->redirect($c->uri_for($c->controller('Build')->action_for("view_build"), [$latest->id], @rest));

[22.849]

[26.702]

    $c->res->redirect($c->uri_for($c->controller('Build')->action_for("build"), [$latest->id], @rest));

Replacement in src/lib/Hydra/Base/Controller/NixChannel.pm at line 5 [27.43]
B:BD[27.109] → [24.1027:1060]
```
use base 'Catalyst::Controller';
```
[27.109]
[28.604]
```
use base 'Hydra::Base::Controller::REST';
```

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

[29.90]

package Hydra::Base::Controller::REST;
use strict;
use warnings;
use base 'Catalyst::Controller::REST';
__PACKAGE__->config(
    map => {
        'text/html' => [ 'View', 'TT' ]
    },
    default => 'text/html',
    'stash_key' => 'resource',
);
sub begin { my ( $self, $c ) = @_; $c->forward('Hydra::Controller::Root::begin'); }
sub end { my ( $self, $c ) = @_; $c->forward('Hydra::Controller::Root::end'); }
1;

File addition: Component (d--x------)
[29.53]

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

[0.2446]

use utf8;
package Hydra::Component::ToJSON;
use strict;
use warnings;
use base 'DBIx::Class';
sub TO_JSON {
    my $self = shift;
    my $json = { $self->get_columns };
    my $rs = $self->result_source;
    my @relnames = $rs->relationships;
    RELLOOP: foreach my $relname (@relnames) {
        my $relinfo = $rs->relationship_info($relname);
        next unless defined $relinfo->{attrs}->{accessor};
        my $accessor = $relinfo->{attrs}->{accessor};
        if ($accessor eq "single" and exists $self->{_relationship_data}{$relname}) {
            $json->{$relname} = $self->$relname->TO_JSON;
        } else {
            unless (defined $self->{related_resultsets}{$relname}) {
                my $cond = $relinfo->{cond};
                if (ref $cond eq 'HASH') {
                    foreach my $k (keys %{$cond}) {
                        my $v = $cond->{$k};
                        $v =~ s/^self\.//;
                        next RELLOOP unless $self->has_column_loaded($v);
                    }
                } #!!! TODO: Handle ARRAY conditions
            }
            if (defined $self->related_resultset($relname)->get_cache) {
                if ($accessor eq "multi") {
                    $json->{$relname} = [ map { $_->TO_JSON } $self->$relname ];
                } else {
                    $json->{$relname} = $self->$relname->TO_JSON;
                }
            }
        }
    }
    return $json;
}
1;

Replacement in src/lib/Hydra/Controller/API.pm at line 6 [30.24]
B:BD[30.84] → [30.84:117]
```
use base 'Catalyst::Controller';
```
[30.84]
[30.117]
```
use base 'Hydra::Base::Controller::REST';
```

Insertion in src/lib/Hydra/Controller/API.pm at line 313 [30.24]

[31.1440]

[32.43]


    $self->status_ok(
        $c,
        entity => { jobsetsTriggered => $c->stash->{json}->{jobsetsTriggered} }
    );

Replacement in src/lib/Hydra/Controller/Build.pm at line 17 [33.1]

B:BD[33.304] → [33.304:355]

sub build : Chained('/') PathPart CaptureArgs(1) {

[33.158]

[33.355]

sub buildChain :Chained('/') :PathPart('build') :CaptureArgs(1) {

Replacement in src/lib/Hydra/Controller/Build.pm at line 53 [33.1]

∅:D[28.2124] → [33.686:743]

B:BD[33.686] → [33.686:743]

sub view_build : Chained('build') PathPart('') Args(0) {

[28.2124]

[33.743]

sub build :Chained('buildChain') :PathPart('') :Args(0) :ActionClass('REST') { }
sub build_GET {

Insertion in src/lib/Hydra/Controller/Build.pm at line 101 [33.1]

[34.199]

[33.1111]

    $self->status_ok(
        $c,
        entity => $c->model('DB::Builds')->find($build->id,{
                columns => [
                    'id',
                    'finished',
                    'timestamp',
                    'buildstatus',
                    'job',
                    'project',
                    'jobset',
                    'starttime',
                    'stoptime',
                ]
            })
    );

Replacement in src/lib/Hydra/Controller/Build.pm at line 120 [33.1]

B:BD[33.1115] → [35.0:56]

sub view_nixlog : Chained('build') PathPart('nixlog') {

[33.1115]

[35.56]

sub view_nixlog : Chained('buildChain') PathPart('nixlog') {

Replacement in src/lib/Hydra/Controller/Build.pm at line 132 [33.1]
B:BD[33.1558] → [35.139:189]
```
sub view_log : Chained('build') PathPart('log') {
```
[33.1558]
[35.189]
```
sub view_log : Chained('buildChain') PathPart('log') {
```
Replacement in src/lib/Hydra/Controller/Build.pm at line 197 [33.1]
∅:D[23.613] → [36.145:188]
B:BD[33.2288] → [36.145:188]
```
sub download : Chained('build') PathPart {
```
[23.613]
[37.0]
```
sub download : Chained('buildChain') PathPart {
```

Replacement in src/lib/Hydra/Controller/Build.pm at line 244 [33.1]

B:BD[23.952] → [23.952:1023]

sub download_by_type : Chained('build') PathPart('download-by-type') {

[23.952]

[23.1023]

sub download_by_type : Chained('buildChain') PathPart('download-by-type') {

Replacement in src/lib/Hydra/Controller/Build.pm at line 259 [33.1]
B:BD[36.193] → [38.0:51]
```
sub contents : Chained('build') PathPart Args(1) {
```
[36.193]
[38.51]
```
sub contents : Chained('buildChain') PathPart Args(1) {
```

Replacement in src/lib/Hydra/Controller/Build.pm at line 363 [33.1]

B:BD[39.1017] → [40.0:59]

sub build_deps : Chained('build') PathPart('build-deps') {

[39.1017]

[41.73]

sub build_deps : Chained('buildChain') PathPart('build-deps') {

Replacement in src/lib/Hydra/Controller/Build.pm at line 376 [33.1]

B:BD[40.272] → [40.272:335]

sub runtime_deps : Chained('build') PathPart('runtime-deps') {

[40.272]

[40.335]

sub runtime_deps : Chained('buildChain') PathPart('runtime-deps') {

Replacement in src/lib/Hydra/Controller/Build.pm at line 390 [33.1]
∅:D[42.1011] → [27.1410:1470]
∅:D[41.1327] → [27.1410:1470]
B:BD[27.1410] → [27.1410:1470]
```
sub nix : Chained('build') PathPart('nix') CaptureArgs(0) {
```
[41.1327]
[27.1470]
```
sub nix : Chained('buildChain') PathPart('nix') CaptureArgs(0) {
```
Replacement in src/lib/Hydra/Controller/Build.pm at line 410 [33.1]
B:BD[43.60] → [44.52:102]
```
sub restart : Chained('build') PathPart Args(0) {
```
[43.60]
[43.121]
```
sub restart : Chained('buildChain') PathPart Args(0) {
```

Replacement in src/lib/Hydra/Controller/Build.pm at line 425 [33.1]

∅:D[45.624] → [44.368:456]

B:BD[44.368] → [44.368:456]

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

[45.624]

[44.456]

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

Replacement in src/lib/Hydra/Controller/Build.pm at line 429 [33.1]
B:BD[44.460] → [44.460:509]
```
sub cancel : Chained('build') PathPart Args(0) {
```
[44.460]
[44.509]
```
sub cancel : Chained('buildChain') PathPart Args(0) {
```

Replacement in src/lib/Hydra/Controller/Build.pm at line 455 [33.1]

∅:D[45.626] → [46.66:154]

B:BD[46.66] → [46.66:154]

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

[45.626]

[46.154]

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

Replacement in src/lib/Hydra/Controller/Build.pm at line 459 [33.1]
B:BD[46.158] → [46.158:205]
```
sub keep : Chained('build') PathPart Args(1) {
```
[46.158]
[28.3625]
```
sub keep : Chained('buildChain') PathPart Args(1) {
```

Replacement in src/lib/Hydra/Controller/Build.pm at line 478 [33.1]

∅:D[45.628] → [47.5:93]

B:BD[47.5] → [47.5:93]

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

[45.628]

[47.93]

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

Replacement in src/lib/Hydra/Controller/Build.pm at line 482 [33.1]

B:BD[47.97] → [47.97:172]

sub add_to_release : Chained('build') PathPart('add-to-release') Args(0) {

[47.97]

[47.172]

sub add_to_release : Chained('buildChain') PathPart('add-to-release') Args(0) {

Replacement in src/lib/Hydra/Controller/Build.pm at line 507 [33.1]

∅:D[45.640] → [24.1155:1243]

∅:D[47.828] → [24.1155:1243]

B:BD[43.823] → [24.1155:1243]

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

[45.640]

[48.0]

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

Replacement in src/lib/Hydra/Controller/Build.pm at line 511 [33.1]

B:BD[48.4] → [48.4:61]

sub clone : Chained('build') PathPart('clone') Args(0) {

[48.4]

[48.61]

sub clone : Chained('buildChain') PathPart('clone') Args(0) {

Replacement in src/lib/Hydra/Controller/Build.pm at line 522 [33.1]

B:BD[48.225] → [48.225:296]

sub clone_submit : Chained('build') PathPart('clone/submit') Args(0) {

[48.225]

[48.296]

sub clone_submit : Chained('buildChain') PathPart('clone/submit') Args(0) {

Replacement in src/lib/Hydra/Controller/Build.pm at line 588 [33.1]

B:BD[33.3297] → [49.0:67]

sub get_info : Chained('build') PathPart('api/get-info') Args(0) {

[33.3297]

[50.149]

sub get_info : Chained('buildChain') PathPart('api/get-info') Args(0) {

Replacement in src/lib/Hydra/Controller/Build.pm at line 599 [33.1]

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

sub evals : Chained('build') PathPart('evals') Args(0) {

[49.72]

[49.132]

sub evals : Chained('buildChain') PathPart('evals') Args(0) {

Replacement in src/lib/Hydra/Controller/Build.pm at line 617 [33.1]

B:BD[9.4] → [9.4:69]

sub reproduce : Chained('build') PathPart('reproduce') Args(0) {

[9.4]

[9.69]

sub reproduce : Chained('buildChain') PathPart('reproduce') Args(0) {

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 10 [51.104]

B:BD[51.275] → [51.275:337]

sub jobset : Chained('/') PathPart('jobset') CaptureArgs(2) {

[51.275]

[51.337]

sub jobsetChain :Chained('/') :PathPart('jobset') :CaptureArgs(2) {

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 13 [51.104]

B:BD[51.390] → [51.390:518]

    my $project = $c->model('DB::Projects')->find($projectName)
        or notFound($c, "Project $projectName doesn't exist.");

[51.390]

[51.518]

    my $project = $c->model('DB::Projects')->find($projectName);
    if ($project) {
        $c->stash->{project} = $project;

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 18 [51.104]

B:BD[51.519] → [52.522:559]

    $c->stash->{project} = $project;

[51.519]

[53.0]

        $c->stash->{jobset_} = $project->jobsets->search({'me.name' => $jobsetName});
        my $jobset = $c->stash->{jobset_}->single;

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 21 [51.104]

∅:D[53.1] → [54.851:983]

B:BD[51.564] → [54.851:983]

∅:D[54.983] → [51.637:699]

B:BD[51.637] → [51.637:699]

    $c->stash->{jobset_} = $project->jobsets->search({name => $jobsetName});
    $c->stash->{jobset} = $c->stash->{jobset_}->single
        or notFound($c, "Jobset $jobsetName doesn't exist.");

[53.1]

[51.699]

        if ($jobset) {
            $c->stash->{jobset} = $jobset;
        } else {
            if ($c->action->name eq "jobset" and $c->request->method eq "PUT") {
                $c->stash->{jobsetName} = $jobsetName;
            } else {
                $self->status_not_found(
                    $c,
                    message => "Jobset $jobsetName doesn't exist."
                );
                $c->detach;
            }
        }
    } else {
        $self->status_not_found(
            $c,
            message => "Project $projectName doesn't exist."
        );
        $c->detach;
    }

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 44 [51.104]

B:BD[51.702] → [55.0:53]

sub index : Chained('jobset') PathPart('') Args(0) {

[51.702]

[55.53]

sub jobset :Chained('jobsetChain') :PathPart('') :Args(0) :ActionClass('REST::ForBrowsers') { }
sub jobset_GET {

Deletion in src/lib/Hydra/Controller/Jobset.pm at line 51 [51.104]

B:BD[56.1] → [56.1:100]

    my $projectName = $c->stash->{project}->name;
    my $jobsetName = $c->stash->{jobset}->name;

Insertion in src/lib/Hydra/Controller/Jobset.pm at line 54 [51.104]

[55.293]


    $self->status_ok(
        $c,
        entity => $c->stash->{jobset_}->find({}, {
                columns => [
                    'me.name',
                    'me.project',
                    'me.errormsg',
                    'jobsetinputs.name',
                    {
                        'jobsetinputs.jobsetinputalts.altnr' => 'jobsetinputalts.altnr',
                        'jobsetinputs.jobsetinputalts.value' => 'jobsetinputalts.value'
                    }
                ],
                join => { 'jobsetinputs' => 'jobsetinputalts' },
                collapse => 1,
                order_by => "me.name"
            })
    );

Insertion in src/lib/Hydra/Controller/Jobset.pm at line 75 [51.104]
[55.296]
[55.296]
```
sub jobset_PUT {
    my ($self, $c) = @_;
```

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 78 [51.104]

B:BD[55.297] → [55.297:361]

sub jobs_tab : Chained('jobset') PathPart('jobs-tab') Args(0) {

[55.297]

[55.361]

    requireProjectOwner($c, $c->stash->{project});
    if (defined $c->stash->{jobset}) {
        error($c, "Cannot rename jobset `$c->stash->{params}->{oldName}' over existing jobset `$c->stash->{jobset}->name") if defined $c->stash->{params}->{oldName} and $c->stash->{params}->{oldName} ne $c->stash->{jobset}->name;
        txn_do($c->model('DB')->schema, sub {
            updateJobset($c, $c->stash->{jobset});
        });
        if ($c->req->looks_like_browser) {
            $c->res->redirect($c->uri_for($self->action_for("jobset"),
                [$c->stash->{project}->name, $c->stash->{jobset}->name]) . "#tabs-configuration");
        } else {
            $self->status_no_content($c);
        }
    } elsif (defined $c->stash->{params}->{oldName}) {
        my $jobset = $c->stash->{project}->jobsets->find({'me.name' => $c->stash->{params}->{oldName}});
        if (defined $jobset) {
            txn_do($c->model('DB')->schema, sub {
                updateJobset($c, $jobset);
            });
            my $uri = $c->uri_for($self->action_for("jobset"), [$c->stash->{project}->name, $jobset->name]);
            if ($c->req->looks_like_browser) {
                $c->res->redirect($uri . "#tabs-configuration");
            } else {
                $self->status_created(
                    $c,
                    location => "$uri",
                    entity => { name => $jobset->name, uri => "$uri", type => "jobset" }
                );
            }
        } else {
            $self->status_not_found(
                $c,
                message => "Jobset $c->stash->{params}->{oldName} doesn't exist."
            );
        }
    } else {
        my $exprType =
            $c->stash->{params}->{"nixexprpath"} =~ /.scm$/ ? "guile" : "nix";
        error($c, "Invalid jobset name: ‘$c->stash->{jobsetName}’") if $c->stash->{jobsetName} !~ /^$jobsetNameRE$/;
        my $jobset;
        txn_do($c->model('DB')->schema, sub {
            # Note: $jobsetName is validated in updateProject, which will
            # abort the transaction if the name isn't valid.
            $jobset = $c->stash->{project}->jobsets->create(
                {name => $c->stash->{jobsetName}, nixexprinput => "", nixexprpath => "", emailoverride => ""});
            updateJobset($c, $jobset);
        });
        my $uri = $c->uri_for($self->action_for("jobset"), [$c->stash->{project}->name, $jobset->name]);
        if ($c->req->looks_like_browser) {
            $c->res->redirect($uri . "#tabs-configuration");
        } else {
            $self->status_created(
                $c,
                location => "$uri",
                entity => { name => $jobset->name, uri => "$uri", type => "jobset" }
            );
        }
    }
}
sub jobs_tab : Chained('jobsetChain') PathPart('jobs-tab') Args(0) {

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 175 [51.104]

B:BD[55.1094] → [55.1094:1162]

sub status_tab : Chained('jobset') PathPart('status-tab') Args(0) {

[55.1094]

[55.1162]

sub status_tab : Chained('jobsetChain') PathPart('status-tab') Args(0) {

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 212 [51.104]

B:BD[51.873] → [51.873:938]

sub get_builds : Chained('jobset') PathPart('') CaptureArgs(0) {

[51.873]

[51.938]

sub get_builds : Chained('jobsetChain') PathPart('') CaptureArgs(0) {

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 226 [51.104]
B:BD[57.507] → [57.507:555]
```
sub edit : Chained('jobset') PathPart Args(0) {
```
[57.507]
[57.555]
```
sub edit : Chained('jobsetChain') PathPart Args(0) {
```
Replacement in src/lib/Hydra/Controller/Jobset.pm at line 236 [51.104]
B:BD[57.709] → [57.709:759]
```
sub submit : Chained('jobset') PathPart Args(0) {
```
[57.709]
[57.759]
```
sub submit : Chained('jobsetChain') PathPart Args(0) {
```
Deletion in src/lib/Hydra/Controller/Jobset.pm at line 239 [51.104]
∅:D[53.15] → [57.789:840]
B:BD[57.789] → [57.789:840]
```
    requireProjectOwner($c, $c->stash->{project});
```

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 247 [51.104]

∅:D[17.210] → [58.99:223]

B:BD[58.99] → [58.99:223]

        return $c->res->redirect($c->uri_for($c->controller('Project')->action_for("view"), [$c->stash->{project}->name]));

[17.210]

[58.223]

        return $c->res->redirect($c->uri_for($c->controller('Project')->action_for("project"), [$c->stash->{project}->name]));

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 250 [51.104]

∅:D[53.17] → [59.129:171]

B:BD[57.866] → [59.129:171]

∅:D[59.171] → [57.908:1026]

B:BD[57.908] → [57.908:1026]

B:BD[57.1026] → [18.0:91]

    txn_do($c->model('DB')->schema, sub {
        updateJobset($c, $c->stash->{jobset});
    });
    $c->res->redirect($c->uri_for($self->action_for("index"),
        [$c->stash->{project}->name, $c->stash->{jobset}->name]) . "#tabs-configuration");

[53.17]

[60.848]

    my $newName = trim $c->stash->{params}->{name};
    my $oldName = trim $c->stash->{jobset}->name;
    unless ($oldName eq $newName) {
        $c->stash->{params}->{oldName} = $oldName;
        $c->stash->{jobsetName} = $newName;
        undef $c->stash->{jobset};
    }
    jobset_PUT($self, $c);

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 265 [51.104]

B:BD[60.983] → [60.983:1048]

    my $nixExprPath = trim $c->request->params->{"nixexprpath"};

[60.983]

[60.1048]

    my $nixExprPath = trim $c->stash->{params}->{"nixexprpath"};

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 268 [51.104]

B:BD[60.1143] → [60.1143:1210]

    my $nixExprInput = trim $c->request->params->{"nixexprinput"};

[60.1143]

[60.1210]

    my $nixExprInput = trim $c->stash->{params}->{"nixexprinput"};

Deletion in src/lib/Hydra/Controller/Jobset.pm at line 272 [51.104]

B:BD[60.1352] → [60.1352:1692]

B:BD[60.1692] → [61.0:112]

B:BD[61.112] → [2.0:140]

∅:D[2.140] → [62.50:133]

B:BD[60.1858] → [62.50:133]

∅:D[62.133] → [60.1889:1927]

∅:D[63.155] → [60.1889:1927]

B:BD[60.1889] → [60.1889:1927]

}
sub checkInput {
    my ($c, $baseName) = @_;
    my $inputName = trim $c->request->params->{"input-$baseName-name"};
    error($c, "Invalid input name: $inputName") unless $inputName =~ /^[[:alpha:]]\w*$/;
    my $inputType = trim $c->request->params->{"input-$baseName-type"};
    error($c, "Invalid input type: $inputType") unless
        $inputType eq "svn" || $inputType eq "svn-checkout" || $inputType eq "hg" || $inputType eq "tarball" ||
        $inputType eq "string" || $inputType eq "path" || $inputType eq "boolean" || $inputType eq "bzr" || $inputType eq "bzr-checkout" ||
        $inputType eq "git" || $inputType eq "build" || $inputType eq "sysbuild" ;
    return ($inputName, $inputType);

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 287 [51.104]

B:BD[57.1514] → [57.1514:1571]

    my $jobsetName = trim $c->request->params->{"name"};

[57.1514]

[64.0]

    my $jobsetName = $c->stash->{jobsetName} or $jobset->name;

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 293 [51.104]

B:BD[65.475] → [66.2292:2367]

        $c->request->params->{"nixexprpath"} =~ /.scm$/ ? "guile" : "nix";

[65.475]

[65.543]

        $c->stash->{params}->{"nixexprpath"} =~ /.scm$/ ? "guile" : "nix";

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 299 [51.104]

B:BD[57.2126] → [57.2126:2194]

        , description => trim($c->request->params->{"description"})

[57.2126]

[57.2194]

        , description => trim($c->stash->{params}->{"description"})

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 302 [51.104]

B:BD[57.2272] → [67.47:191]

∅:D[67.191] → [68.0:76]

B:BD[69.81] → [68.0:76]

B:BD[68.76] → [70.0:67]

B:BD[70.67] → [11.0:141]

        , enabled => defined $c->request->params->{enabled} ? 1 : 0
        , enableemail => defined $c->request->params->{enableemail} ? 1 : 0
        , emailoverride => trim($c->request->params->{emailoverride}) || ""
        , hidden => defined $c->request->params->{visible} ? 0 : 1
        , keepnr => int(trim($c->request->params->{keepnr})) || 3
        , checkinterval => int(trim($c->request->params->{checkinterval}))

[57.2272]

[71.0]

        , enabled => defined $c->stash->{params}->{enabled} ? 1 : 0
        , enableemail => defined $c->stash->{params}->{enableemail} ? 1 : 0
        , emailoverride => trim($c->stash->{params}->{emailoverride}) || ""
        , hidden => defined $c->stash->{params}->{visible} ? 0 : 1
        , keepnr => int(trim($c->stash->{params}->{keepnr})) || 3
        , checkinterval => int(trim($c->stash->{params}->{checkinterval}))

Deletion in src/lib/Hydra/Controller/Jobset.pm at line 311 [51.104]
B:BD[57.2285] → [57.2285:2305]
B:BD[57.2305] → [53.184:185]
```
    my %inputNames;
```

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 312 [51.104]

B:BD[57.2355] → [57.2355:2461]

B:BD[57.2461] → [60.2221:2289]

    foreach my $param (keys %{$c->request->params}) {
        next unless $param =~ /^input-(\w+)-name$/;
        my $baseName = $1;
        next if $baseName eq "template";

[57.2355]

[57.2579]

    unless (defined $c->stash->{params}->{inputs}) {
        $c->stash->{params}->{inputs} = {};
        foreach my $param (keys %{$c->stash->{params}}) {
            next unless $param =~ /^input-(\w+)-name$/;
            my $baseName = $1;
            next if $baseName eq "template";
            $c->stash->{params}->{inputs}->{$c->stash->{params}->{$param}} = { type => $c->stash->{params}->{"input-$baseName-type"}, values => $c->stash->{params}->{"input-$baseName-values"} };
            unless ($baseName =~ /^\d+$/) { # non-numeric base name is an existing entry
                $c->stash->{params}->{inputs}->{$c->stash->{params}->{$param}}->{oldName} = $baseName;
            }
        }
    }

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 325 [51.104]

B:BD[57.2580] → [60.2290:2355]

        my ($inputName, $inputType) = checkInput($c, $baseName);

[57.2580]

[57.2750]

    foreach my $inputName (keys %{$c->stash->{params}->{inputs}}) {
        my $inputData = $c->stash->{params}->{inputs}->{$inputName};
        error($c, "Invalid input name: $inputName") unless $inputName =~ /^[[:alpha:]]\w*$/;

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 329 [51.104]

B:BD[57.3097] → [57.3097:3134]

        $inputNames{$inputName} = 1;

[57.2751]

[53.186]

        my $inputType = $inputData->{type};
        error($c, "Invalid input type: $inputType") unless
            $inputType eq "svn" || $inputType eq "svn-checkout" || $inputType eq "hg" || $inputType eq "tarball" ||
            $inputType eq "string" || $inputType eq "path" || $inputType eq "boolean" || $inputType eq "bzr" || $inputType eq "bzr-checkout" ||
            $inputType eq "git" || $inputType eq "build" || $inputType eq "sysbuild" ;

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 336 [51.104]

B:BD[57.3166] → [60.2356:2448]

∅:D[60.2448] → [57.3259:3311]

B:BD[57.3259] → [57.3259:3311]

        if ($baseName =~ /^\d+$/) { # numeric base name is auto-generated, i.e. a new entry
            $input = $jobset->jobsetinputs->create(

[57.3166]

[57.3311]

        unless (defined $inputData->{oldName}) {
            $input = $jobset->jobsetinputs->update_or_create(

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 342 [51.104]

B:BD[57.3447] → [60.2449:2527]

            $input = ($jobset->jobsetinputs->search({name => $baseName}))[0];

[57.3447]

[57.3526]

            $input = ($jobset->jobsetinputs->search({name => $inputData->{oldName}}))[0];

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 350 [51.104]

B:BD[57.3808] → [60.2528:2598]

        my $values = $c->request->params->{"input-$baseName-values"};

[57.3808]

[57.3879]

        my $values = $inputData->{values};

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 363 [51.104]

B:BD[57.4484] → [57.4484:4549]

        $input->delete unless defined $inputNames{$input->name};

[57.4484]

[57.4549]

        $input->delete unless defined $c->stash->{params}->{inputs}->{$input->name};

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 368 [51.104]

B:BD[72.4] → [72.4:62]

sub clone : Chained('jobset') PathPart('clone') Args(0) {

[72.4]

[72.62]

sub clone : Chained('jobsetChain') PathPart('clone') Args(0) {

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 378 [51.104]

∅:D[73.139] → [72.222:294]

B:BD[51.1140] → [72.222:294]

sub clone_submit : Chained('jobset') PathPart('clone/submit') Args(0) {

[73.139]

[72.294]

sub clone_submit : Chained('jobsetChain') PathPart('clone/submit') Args(0) {

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 385 [51.104]

B:BD[72.427] → [64.94:159]

    my $newJobsetName = trim $c->request->params->{"newjobset"};

[72.427]

[64.159]

    my $newJobsetName = trim $c->stash->{params}->{"newjobset"};

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 412 [51.104]

B:BD[74.39] → [74.39:97]

sub evals : Chained('jobset') PathPart('evals') Args(0) {

[74.39]

[74.97]

sub evals :Chained('jobsetChain') :PathPart('evals') :Args(0) :ActionClass('REST') { }
sub evals_GET {

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 428 [51.104]

B:BD[75.257] → [75.257:358]

    $c->stash->{evals} = getEvals($self, $c, $evals, ($page - 1) * $resultsPerPage, $resultsPerPage)

[75.257]

[74.1296]

    my $offset = ($page - 1) * $resultsPerPage;
    $c->stash->{evals} = getEvals($self, $c, $evals, $offset, $resultsPerPage);
    my %entity = (
        evals => [ $evals->search({ 'me.hasnewbuilds' => 1 }, {
                    columns => [
                        'me.hasnewbuilds',
                        'me.id',
                        'jobsetevalinputs.name',
                        'jobsetevalinputs.altnr',
                        'jobsetevalinputs.revision',
                        'jobsetevalinputs.type',
                        'jobsetevalinputs.uri',
                        'jobsetevalinputs.dependency',
                        'jobsetevalmembers.build',
                    ],
                    join => [ 'jobsetevalinputs', 'jobsetevalmembers' ],
                    collapse => 1,
                    rows => $resultsPerPage,
                    offset => $offset,
                    order_by => "me.id DESC",
                 }) ],
        first => "?page=1",
        last => "?page=" . POSIX::ceil($c->stash->{total}/$resultsPerPage)
    );
    if ($page > 1) {
        $entity{previous} = "?page=" . ($page - 1);
    }
    if ($page < POSIX::ceil($c->stash->{total}/$resultsPerPage)) {
        $entity{next} = "?page=" . ($page + 1);
    }
    $self->status_ok(
        $c,
        entity => \%entity
    );

Replacement in src/lib/Hydra/Controller/Jobset.pm at line 466 [51.104]

B:BD[76.61] → [76.61:123]

sub latest_eval : Chained('jobset') PathPart('latest-eval') {

[76.61]

[76.123]

sub latest_eval : Chained('jobsetChain') PathPart('latest-eval') {

Replacement in src/lib/Hydra/Controller/Project.pm at line 10 [24.1245]

B:BD[24.1458] → [24.1458:1522]

sub project : Chained('/') PathPart('project') CaptureArgs(1) {

[24.1457]

[24.1522]

sub projectChain :Chained('/') :PathPart('project') :CaptureArgs(1) {

Replacement in src/lib/Hydra/Controller/Project.pm at line 13 [24.1245]

∅:D[22.2215] → [77.554:682]

B:BD[24.1566] → [77.554:682]

    my $project = $c->model('DB::Projects')->find($projectName)
        or notFound($c, "Project $projectName doesn't exist.");

[22.2215]

[24.1712]

    my $project = $c->model('DB::Projects')->find($projectName, { columns => [
      "me.name",
      "me.displayName",
      "me.description",
      "me.enabled",
      "me.hidden",
      "me.homepage",
      "owner.username",
      "owner.fullname",
      "views.name",
      "releases.name",
      "releases.timestamp",
      "jobsets.name",
    ], join => [ 'owner', 'views', 'releases', 'jobsets' ], order_by => { -desc => "releases.timestamp" }, collapse => 1 });

Replacement in src/lib/Hydra/Controller/Project.pm at line 28 [24.1245]

B:BD[24.1713] → [52.631:668]

    $c->stash->{project} = $project;

[24.1713]

[24.1753]

    if ($project) {
        $c->stash->{project} = $project;
    } else {
        if ($c->action->name eq "project" and $c->request->method eq "PUT") {
            $c->stash->{projectName} = $projectName;
        } else {
            $self->status_not_found(
                $c,
                message => "Project $projectName doesn't exist."
            );
            $c->detach;
        }
    }

Replacement in src/lib/Hydra/Controller/Project.pm at line 44 [24.1245]

∅:D[4.3] → [24.1757:1810]

B:BD[24.1757] → [24.1757:1810]

sub view : Chained('project') PathPart('') Args(0) {

[4.3]

[24.1810]

sub project :Chained('projectChain') :PathPart('') :Args(0) :ActionClass('REST::ForBrowsers') { }
sub project_GET {

Insertion in src/lib/Hydra/Controller/Project.pm at line 55 [24.1245]

[78.116]

[24.1942]


    $self->status_ok(
        $c,
        entity => $c->stash->{project}
    );

Insertion in src/lib/Hydra/Controller/Project.pm at line 62 [24.1245]
[24.1945]
[24.1945]
```
sub project_PUT {
    my ($self, $c) = @_;
```

Replacement in src/lib/Hydra/Controller/Project.pm at line 65 [24.1245]

B:BD[24.1946] → [24.1946:1995]

sub edit : Chained('project') PathPart Args(0) {

[24.1946]

[24.1995]

    if (defined $c->stash->{project}) {
        error($c, "Cannot rename project `$c->stash->{params}->{oldName}' over existing project `$c->stash->{project}->name") if defined $c->stash->{params}->{oldName};
        requireProjectOwner($c, $c->stash->{project});
        txn_do($c->model('DB')->schema, sub {
            updateProject($c, $c->stash->{project});
        });
        if ($c->req->looks_like_browser) {
            $c->res->redirect($c->uri_for($self->action_for("project"), [$c->stash->{project}->name]) . "#tabs-configuration");
        } else {
            $self->status_no_content($c);
        }
    } elsif (defined $c->stash->{params}->{oldName}) {
        my $project = $c->model('DB::Projects')->find($c->stash->{params}->{oldName});
        if (defined $project) {
            requireProjectOwner($c, $project);
            txn_do($c->model('DB')->schema, sub {
                updateProject($c, $project);
            });
            my $uri = $c->uri_for($self->action_for("project"), [$project->name]);
            if ($c->req->looks_like_browser) {
                $c->res->redirect($uri . "#tabs-configuration");
            } else {
                $self->status_created(
                    $c,
                    location => "$uri",
                    entity => { name => $project->name, uri => "$uri", type => "project" }
                );
            }
        } else {
            $self->status_not_found(
                $c,
                message => "Project $c->stash->{params}->{oldName} doesn't exist."
            );
        }
    } else {
        requireMayCreateProjects($c);
        error($c, "Invalid project name: ‘$c->stash->{projectName}’") if $c->stash->{projectName} !~ /^$projectNameRE$/;
        my $project;
        txn_do($c->model('DB')->schema, sub {
            # Note: $projectName is validated in updateProject,
            # which will abort the transaction if the name isn't
            # valid.  Idem for the owner.
            my $owner = $c->user->username;
            $project = $c->model('DB::Projects')->create(
                {name => $c->stash->{projectName}, displayname => "", owner => $owner});
            updateProject($c, $project);
        });
        my $uri = $c->uri_for($self->action_for("project"), [$project->name]);
        if ($c->req->looks_like_browser) {
            $c->res->redirect($uri . "#tabs-configuration");
        } else {
            $self->status_created(
                $c,
                location => "$uri",
                entity => { name => $project->name, uri => "$uri", type => "project" }
            );
        }
    }
}
sub edit : Chained('projectChain') PathPart Args(0) {

Replacement in src/lib/Hydra/Controller/Project.pm at line 141 [24.1245]
B:BD[24.2149] → [24.2149:2200]
```
sub submit : Chained('project') PathPart Args(0) {
```
[24.2149]
[24.2200]
```
sub submit : Chained('projectChain') PathPart Args(0) {
```
Deletion in src/lib/Hydra/Controller/Project.pm at line 144 [24.1245]
B:BD[24.2226] → [52.782:833]
```
    requireProjectOwner($c, $c->stash->{project});
```
Deletion in src/lib/Hydra/Controller/Project.pm at line 145 [24.1245]
B:BD[57.4652] → [22.2216:2217]

Replacement in src/lib/Hydra/Controller/Project.pm at line 154 [24.1245]

∅:D[79.792] → [59.215:257]

B:BD[24.2361] → [59.215:257]

∅:D[59.257] → [52.834:883]

B:BD[24.2403] → [52.834:883]

∅:D[52.883] → [24.2455:2463]

B:BD[24.2455] → [24.2455:2463]

B:BD[24.2463] → [22.2218:2219]

B:BD[22.2219] → [18.92:209]

    txn_do($c->model('DB')->schema, sub {
        updateProject($c, $c->stash->{project});
    });
    $c->res->redirect($c->uri_for($self->action_for("view"), [$c->stash->{project}->name]) . "#tabs-configuration");

[79.792]

[80.884]

    my $newName = trim $c->stash->{params}->{name};
    my $oldName = trim $c->stash->{project}->name;
    unless ($oldName eq $newName) {
        $c->stash->{params}->{oldName} = $oldName;
        $c->stash->{projectName} = $newName;
        undef $c->stash->{project};
    }
    project_PUT($self, $c);

Deletion in src/lib/Hydra/Controller/Project.pm at line 188 [24.1245]
B:BD[24.3173] → [24.3173:3174]
B:BD[24.3174] → [81.308:342]
∅:D[81.342] → [24.3196:3253]
B:BD[24.3196] → [24.3196:3253]
B:BD[24.3253] → [22.2230:2231]
∅:D[22.2231] → [64.1175:1272]
B:BD[24.3258] → [64.1175:1272]
```
    requireMayCreateProjects($c);
    my $projectName = trim $c->request->params->{name};
    error($c, "Invalid project name: ‘$projectName’") if $projectName !~ /^$projectNameRE$/;
```

Replacement in src/lib/Hydra/Controller/Project.pm at line 189 [24.1245]

∅:D[64.1273] → [59.301:343]

B:BD[24.3258] → [59.301:343]

∅:D[59.343] → [24.3300:3459]

B:BD[24.3300] → [24.3300:3459]

B:BD[24.3459] → [81.343:463]

∅:D[81.463] → [24.3459:3516]

B:BD[24.3459] → [24.3459:3516]

B:BD[24.3516] → [81.464:537]

∅:D[81.537] → [24.3616:3661]

B:BD[24.3616] → [24.3616:3661]

    txn_do($c->model('DB')->schema, sub {
        # Note: $projectName is validated in updateProject,
        # which will abort the transaction if the name isn't
        # valid.  Idem for the owner.
        my $owner = $c->check_user_roles('admin')
            ? trim $c->request->params->{owner} : $c->user->username;
        my $project = $c->model('DB::Projects')->create(
            {name => $projectName, displayname => "", owner => $owner});
        updateProject($c, $project);
    });

[64.1273]

[22.2232]

    $c->stash->{projectName} = trim $c->stash->{params}->{name};

Replacement in src/lib/Hydra/Controller/Project.pm at line 191 [24.1245]
∅:D[22.2233] → [24.3666:3745]
B:BD[24.3666] → [24.3666:3745]
```
    $c->res->redirect($c->uri_for($self->action_for("view"), [$projectName]));
```
[22.2233]
[57.4769]
```
    project_PUT($self, $c);
```

Replacement in src/lib/Hydra/Controller/Project.pm at line 195 [24.1245]

B:BD[57.4773] → [57.4773:4848]

sub create_jobset : Chained('project') PathPart('create-jobset') Args(0) {

[57.4773]

[57.4848]

sub create_jobset : Chained('projectChain') PathPart('create-jobset') Args(0) {

Replacement in src/lib/Hydra/Controller/Project.pm at line 206 [24.1245]

B:BD[57.5031] → [57.5031:5120]

sub create_jobset_submit : Chained('project') PathPart('create-jobset/submit') Args(0) {

[57.5031]

[57.5120]

sub create_jobset_submit : Chained('projectChain') PathPart('create-jobset/submit') Args(0) {

Replacement in src/lib/Hydra/Controller/Project.pm at line 209 [24.1245]

B:BD[57.5146] → [57.5146:5197]

    requireProjectOwner($c, $c->stash->{project});

[57.5146]

[22.2236]

    $c->stash->{jobsetName} = trim $c->stash->{params}->{name};

Replacement in src/lib/Hydra/Controller/Project.pm at line 211 [24.1245]

∅:D[22.2237] → [57.5202:5257]

B:BD[57.5202] → [57.5202:5257]

B:BD[57.5257] → [65.545:564]

B:BD[65.564] → [66.2431:2506]

∅:D[65.632] → [64.1274:1368]

∅:D[66.2506] → [64.1274:1368]

B:BD[57.5257] → [64.1274:1368]

∅:D[64.1368] → [57.5257:5258]

B:BD[57.5257] → [57.5257:5258]

B:BD[57.5258] → [59.344:386]

∅:D[59.386] → [57.5300:5487]

B:BD[57.5300] → [57.5300:5487]

B:BD[57.5487] → [3.0:96]

∅:D[3.96] → [57.5562:5632]

B:BD[57.5562] → [57.5562:5632]

B:BD[57.5632] → [22.2238:2239]

∅:D[22.2239] → [57.5637:5771]

B:BD[57.5637] → [57.5637:5771]

    my $jobsetName = trim $c->request->params->{name};
    my $exprType =
        $c->request->params->{"nixexprpath"} =~ /.scm$/ ? "guile" : "nix";
    error($c, "Invalid jobset name: ‘$jobsetName’") if $jobsetName !~ /^$jobsetNameRE$/;
    txn_do($c->model('DB')->schema, sub {
        # Note: $jobsetName is validated in updateProject, which will
        # abort the transaction if the name isn't valid.
        my $jobset = $c->stash->{project}->jobsets->create(
            {name => $jobsetName, nixexprinput => "", nixexprpath => "", emailoverride => ""});
        Hydra::Controller::Jobset::updateJobset($c, $jobset);
    });
    $c->res->redirect($c->uri_for($c->controller('Jobset')->action_for("index"),
        [$c->stash->{project}->name, $jobsetName]));

[22.2237]

[24.3745]

    Hydra::Controller::Jobset::jobset_PUT($self, $c);

Replacement in src/lib/Hydra/Controller/Project.pm at line 219 [24.1245]

∅:D[57.5805] → [24.4396:4437]

B:BD[24.4396] → [24.4396:4437]

B:BD[24.4437] → [57.5806:5858]

    if ($c->check_user_roles('admin')) {
        $owner = trim $c->request->params->{owner};

[57.5805]

[24.4492]

    if ($c->check_user_roles('admin') and defined $c->stash->{params}->{owner}) {
        $owner = trim $c->stash->{params}->{owner};

Replacement in src/lib/Hydra/Controller/Project.pm at line 225 [24.1245]

B:BD[24.5515] → [79.795:851]

    my $projectName = trim $c->request->params->{name};

[24.5515]

[79.851]

    my $projectName = $c->stash->{projectName} or $project->name;

Replacement in src/lib/Hydra/Controller/Project.pm at line 228 [24.1245]
∅:D[22.2243] → [79.953:1016]
B:BD[79.953] → [79.953:1016]
```
    my $displayName = trim $c->request->params->{displayname};
```
[22.2243]
[79.1016]
```
    my $displayName = trim $c->stash->{params}->{displayname};
```

Replacement in src/lib/Hydra/Controller/Project.pm at line 234 [24.1245]

B:BD[57.5950] → [57.5950:6076]

B:BD[57.6076] → [82.0:135]

        , description => trim($c->request->params->{description})
        , homepage => trim($c->request->params->{homepage})
        , enabled => defined $c->request->params->{enabled} ? 1 : 0
        , hidden => defined $c->request->params->{visible} ? 0 : 1

[57.5950]

[57.6149]

        , description => trim($c->stash->{params}->{description})
        , homepage => trim($c->stash->{params}->{homepage})
        , enabled => defined $c->stash->{params}->{enabled} ? 1 : 0
        , hidden => defined $c->stash->{params}->{visible} ? 0 : 1

Replacement in src/lib/Hydra/Controller/Project.pm at line 244 [24.1245]

B:BD[24.9216] → [24.9216:9282]

sub get_builds : Chained('project') PathPart('') CaptureArgs(0) {

[24.9216]

[24.9282]

sub get_builds : Chained('projectChain') PathPart('') CaptureArgs(0) {

Replacement in src/lib/Hydra/Controller/Project.pm at line 257 [24.1245]

B:BD[83.4] → [83.4:89]

sub create_view_submit : Chained('project') PathPart('create-view/submit') Args(0) {

[83.4]

[83.89]

sub create_view_submit : Chained('projectChain') PathPart('create-view/submit') Args(0) {

Replacement in src/lib/Hydra/Controller/Project.pm at line 277 [24.1245]

B:BD[24.9372] → [83.676:747]

sub create_view : Chained('project') PathPart('create-view') Args(0) {

[24.9372]

[83.747]

sub create_view : Chained('projectChain') PathPart('create-view') Args(0) {

Replacement in src/lib/Hydra/Controller/Project.pm at line 287 [24.1245]

B:BD[84.4] → [84.4:81]

sub create_release : Chained('project') PathPart('create-release') Args(0) {

[84.4]

[84.81]

sub create_release : Chained('projectChain') PathPart('create-release') Args(0) {

Replacement in src/lib/Hydra/Controller/Project.pm at line 295 [24.1245]

B:BD[85.204] → [84.234:325]

sub create_release_submit : Chained('project') PathPart('create-release/submit') Args(0) {

[85.204]

[85.274]

sub create_release_submit : Chained('projectChain') PathPart('create-release/submit') Args(0) {

Replacement in src/lib/Hydra/Controller/Release.pm at line 69 [84.977]

B:BD[86.160] → [78.117:202]

        $c->res->redirect($c->uri_for($c->controller('Project')->action_for('view'),

[86.160]

[86.249]

        $c->res->redirect($c->uri_for($c->controller('Project')->action_for('project'),

Replacement in src/lib/Hydra/Controller/Release.pm at line 75 [84.977]

B:BD[86.417] → [86.417:482]

        $c->res->redirect($c->uri_for($self->action_for("view"),

[86.417]

[86.482]

        $c->res->redirect($c->uri_for($self->action_for("project"),

Insertion in src/lib/Hydra/Controller/Root.pm at line 40 [87.804]

[16.575]

[87.1351]


    $c->forward('deserialize');
    $c->stash->{params} = $c->request->data or $c->request->params;
    unless (defined $c->stash->{params} and %{$c->stash->{params}}) {
        $c->stash->{params} = $c->request->params;
    }

Insertion in src/lib/Hydra/Controller/Root.pm at line 48 [87.804]
[87.1353]
[87.1353]
```
sub deserialize :ActionClass('Deserialize') { }
```

Insertion in src/lib/Hydra/Controller/Root.pm at line 57 [87.804]

[88.2335]

[89.1318]

    $self->status_ok(
        $c,
        entity => [$c->model('DB::Projects')->search(isAdmin($c) ? {} : {hidden => 0}, {
                    order_by => 'name',
                    columns => [ 'name', 'displayname' ]
                })]
    );

Replacement in src/lib/Hydra/Controller/Root.pm at line 67 [87.804]
∅:D[89.1322] → [90.56:75]
B:BD[90.56] → [90.56:75]
```
sub queue :Local {
```
[89.1322]
[89.1323]
```
sub queue :Local :Args(0) :ActionClass('REST') { }
sub queue_GET {
```

Deletion in src/lib/Hydra/Controller/Root.pm at line 72 [87.804]

B:BD[90.141] → [90.141:200]

B:BD[90.200] → [13.970:1147]

    $c->stash->{queue} = [$c->model('DB::Builds')->search(
        {finished => 0}, { join => ['project'], order_by => ["priority DESC", "id"], columns => [@buildListColumns], '+select' => ['project.enabled'], '+as' => ['enabled'] })];

Insertion in src/lib/Hydra/Controller/Root.pm at line 73 [87.804]

[91.250]

[92.2120]

    $self->status_ok(
        $c,
        entity => [$c->model('DB::Builds')->search(
            {finished => 0}, { join => ['project'], order_by => ["priority DESC", "id"], columns => [@buildListColumns], '+select' => ['project.enabled'], '+as' => ['enabled'] })]
    );

Insertion in src/lib/Hydra/Controller/Root.pm at line 93 [87.804]
[93.557]
[94.377]
Insertion in src/lib/Hydra/Controller/Root.pm at line 95 [87.804]
[94.378]
[93.557]
```
sub status :Local :Args(0) :ActionClass('REST') { }
```
Replacement in src/lib/Hydra/Controller/Root.pm at line 97 [87.804]
B:BD[93.558] → [94.379:399]
```
sub status :Local {
```
[93.558]
[94.399]
```
sub status_GET {
```

Replacement in src/lib/Hydra/Controller/Root.pm at line 99 [87.804]

B:BD[94.424] → [5.0:215]

    $c->stash->{steps} = [ $c->model('DB::BuildSteps')->search(
        { 'me.busy' => 1, 'build.finished' => 0, 'build.busy' => 1 },
        { join => [ 'build' ]
        , order_by => [ 'machine' ]
        } ) ];

[94.424]

[94.646]

    $self->status_ok(
        $c,
        entity => [ $c->model('DB::BuildSteps')->search(
            { 'me.busy' => 1, 'build.finished' => 0, 'build.busy' => 1 },
            { join => { build => [ 'project', 'job', 'jobset' ] },
                columns => [
                    'me.machine',
                    'me.system',
                    'me.stepnr',
                    'me.drvpath',
                    'me.starttime',
                    'build.id',
                    {
                    'build.project.name' => 'project.name',
                    'build.jobset.name' => 'jobset.name',
                    'build.job.name' => 'job.name'
                    }
                ],
                order_by => [ 'machine' ]
            }
        ) ]
    );

Replacement in src/lib/Hydra/Controller/Root.pm at line 224 [87.804]

B:BD[95.226] → [95.226:260]

    elsif (scalar @{$c->error}) {

[95.226]

[96.1625]

    if (scalar @{$c->error}) {
        $c->stash->{resource} = { errors => "$c->error" };

Insertion in src/lib/Hydra/Controller/Root.pm at line 234 [87.804]

[96.1736]

    } elsif (defined $c->stash->{resource} and
        (ref $c->stash->{resource} eq ref {}) and
        defined $c->stash->{resource}->{error}) {
        $c->stash->{template} = 'error.tt';
        $c->stash->{httpStatus} =
            $c->response->status . " " . HTTP::Status::status_message($c->response->status);

Insertion in src/lib/Hydra/Controller/Root.pm at line 241 [87.804]
[96.1742]
[96.1742]
```
    $c->forward('serialize');
```
Insertion in src/lib/Hydra/Controller/Root.pm at line 244 [87.804]
[96.1744]
[97.362]
```
sub serialize : ActionClass('Serialize') { }
```
Replacement in src/lib/Hydra/Controller/User.pm at line 6 [91.252]
B:BD[91.313] → [91.313:346]
```
use base 'Catalyst::Controller';
```
[91.313]
[95.272]
```
use base 'Hydra::Base::Controller::REST';
```
Replacement in src/lib/Hydra/Controller/User.pm at line 16 [91.252]
B:BD[91.478] → [91.478:497]
```
sub login :Local {
```
[91.478]
[91.497]
```
sub login :Local :Args(0) :ActionClass('REST::ForBrowsers') { }
sub login_GET {
```

Replacement in src/lib/Hydra/Controller/User.pm at line 21 [91.252]

B:BD[91.523] → [91.523:639]

    my $username = $c->request->params->{username} || "";
    my $password = $c->request->params->{password} || "";

[91.523]

[91.639]

    my $baseurl = $c->uri_for('/');
    my $referer = $c->request->referer;
    $c->session->{referer} = $referer if defined $referer && $referer =~ m/^($baseurl)/;

Replacement in src/lib/Hydra/Controller/User.pm at line 25 [91.252]

B:BD[91.640] → [95.296:377]

∅:D[95.377] → [91.719:759]

B:BD[91.719] → [91.719:759]

B:BD[91.759] → [95.378:515]

∅:D[95.515] → [91.871:877]

B:BD[91.871] → [91.871:877]

    if ($username eq "" && $password eq "" && !defined $c->session->{referer}) {
        my $baseurl = $c->uri_for('/');
        my $referer = $c->request->referer;
        $c->session->{referer} = $referer if defined $referer && $referer =~ m/^($baseurl)/;
    }

[91.640]

[91.877]

    $c->stash->{template} = 'login.tt';
}
sub login_POST {
    my ($self, $c) = @_;
    my $username;
    my $password;
    $username = $c->stash->{params}->{username};
    $password = $c->stash->{params}->{password};

Replacement in src/lib/Hydra/Controller/User.pm at line 38 [91.252]

B:BD[91.912] → [95.516:611]

∅:D[95.611] → [91.1142:1203]

B:BD[91.1142] → [91.1142:1203]

        backToReferer($c) if $c->authenticate({username => $username, password => $password});
        $c->stash->{errorMsg} = "Bad username or password.";

[91.912]

[91.1203]

        if ($c->authenticate({username => $username, password => $password})) {
            if ($c->request->looks_like_browser) {
                backToReferer($c);
            } else {
                currentUser_GET($self, $c);
            }
        } else {
            $self->status_forbidden($c, message => "Bad username or password.");
            if ($c->request->looks_like_browser) {
                login_GET($self, $c);
            }
        }

Insertion in src/lib/Hydra/Controller/User.pm at line 51 [91.252]
[91.1209]
[91.1241]
```
}
```
Deletion in src/lib/Hydra/Controller/User.pm at line 53 [91.252]
B:BD[91.1242] → [91.1242:1284]
```
    $c->stash->{template} = 'login.tt';
}
```
Insertion in src/lib/Hydra/Controller/User.pm at line 54 [91.252]
[91.1285]
[91.1285]
```
sub logout :Local :Args(0) :ActionClass('REST::ForBrowsers') { }
```
Replacement in src/lib/Hydra/Controller/User.pm at line 56 [91.252]
B:BD[91.1286] → [91.1286:1306]
```
sub logout :Local {
```
[91.1286]
[91.1306]
```
sub logout_POST {
```

Replacement in src/lib/Hydra/Controller/User.pm at line 59 [91.252]

B:BD[91.1347] → [91.1347:1417]

    $c->response->redirect($c->request->referer || $c->uri_for('/'));

[91.1347]

[91.1417]

    if ($c->request->looks_like_browser) {
        $c->response->redirect($c->request->referer || $c->uri_for('/'));
    } else {
        $self->status_no_content($c);
    }

Insertion in src/lib/Hydra/Controller/User.pm at line 66 [91.252]

[91.1420]

sub logout_GET {
    # Probably a better way to do this
    my ($self, $c) = @_;
    logout_POST($self, $c);
}

Insertion in src/lib/Hydra/Controller/User.pm at line 72 [91.252]
[91.1421]
[91.1421]

Insertion in src/lib/Hydra/Controller/User.pm at line 148 [91.252]

[95.1128]

sub currentUser :Path('/current-user') :ActionClass('REST') { }
sub currentUser_GET {
    my ($self, $c) = @_;
    requireLogin($c) if !$c->user_exists;
    $self->status_ok(
        $c,
        entity => $c->model('DB::Users')->find({ 'me.username' => $c->user->username}, {
          columns => [ "me.fullname", "me.emailaddress", "me.username", "userroles.role" ]
        , join => [ "userroles" ]
        , collapse => 1
        })
    );
}

Replacement in src/lib/Hydra/Controller/User.pm at line 189 [91.252]

B:BD[95.1855] → [95.1855:1891]

sub edit :Chained('user') Args(0) {

[95.1855]

[91.3353]

sub edit :Chained('user') :Args(0) :ActionClass('REST::ForBrowsers') { }
sub edit_GET {

Replacement in src/lib/Hydra/Controller/User.pm at line 200 [91.252]

B:BD[95.2055] → [95.2055:2224]

    if ($c->request->method ne "POST") {
        $c->stash->{fullname} = $user->fullname;
        $c->stash->{emailonerror} = $user->emailonerror;
        return;
    }

[95.2055]

[95.2224]

    $c->stash->{fullname} = $user->fullname;

Replacement in src/lib/Hydra/Controller/User.pm at line 202 [91.252]

B:BD[95.2225] → [95.2225:2286]

    if (($c->request->params->{submit} // "") eq "delete") {

[95.2225]

[95.2286]

    $c->stash->{emailonerror} = $user->emailonerror;
}
sub edit_POST {
    my ($self, $c) = @_;
    my $user = $c->stash->{user};
    $c->stash->{template} = 'user.tt';
    $c->session->{referer} = $c->request->referer if !defined $c->session->{referer};
    if (($c->stash->{params}->{submit} // "") eq "delete") {

Replacement in src/lib/Hydra/Controller/User.pm at line 219 [91.252]

B:BD[95.2358] → [95.2358:2427]

    if (($c->request->params->{submit} // "") eq "reset-password") {

[95.2358]

[95.2427]

    if (($c->stash->{params}->{submit} // "") eq "reset-password") {

Replacement in src/lib/Hydra/Controller/User.pm at line 236 [91.252]
B:BD[95.3041] → [95.3041:3094]
```
    my $fullName = trim $c->req->params->{fullname};
```
[95.3041]
[95.3094]
```
    my $fullName = trim $c->stash->{params}->{fullname};
```

Replacement in src/lib/Hydra/Controller/User.pm at line 244 [91.252]

B:BD[95.3273] → [95.3273:3349]

            , emailonerror => $c->request->params->{"emailonerror"} ? 1 : 0

[95.3273]

[95.3349]

            , emailonerror => $c->stash->{params}->{"emailonerror"} ? 1 : 0

Replacement in src/lib/Hydra/Controller/User.pm at line 247 [91.252]

B:BD[95.3366] → [95.3366:3424]

        my $password = $c->req->params->{password} // "";

[95.3366]

[95.3424]

        my $password = $c->stash->{params}->{password} // "";

Replacement in src/lib/Hydra/Controller/User.pm at line 252 [91.252]

B:BD[95.3653] → [95.3653:3720]

                if $password ne trim $c->req->params->{password2};

[95.3653]

[95.3720]

                if $password ne trim $c->stash->{params}->{password2};

Replacement in src/lib/Hydra/Controller/User.pm at line 264 [91.252]

B:BD[95.3965] → [95.3965:3988]

    backToReferer($c);

[95.3965]

[91.3413]

    if ($c->request->looks_like_browser) {
        backToReferer($c);
    } else {
        $self->status_no_content($c);
    }

Replacement in src/lib/Hydra/Controller/View.pm at line 121 [98.404]

B:BD[79.1308] → [79.1308:1393]

        $c->res->redirect($c->uri_for($c->controller('Project')->action_for('view'),

[79.1308]

[79.1393]

        $c->res->redirect($c->uri_for($c->controller('Project')->action_for('project'),

Replacement in src/lib/Hydra/Controller/View.pm at line 227 [98.404]

B:BD[98.5966] → [98.5966:6062]

        return $c->res->redirect($c->uri_for($c->controller('Build')->action_for('view_build'),

[98.5966]

[98.6062]

        return $c->res->redirect($c->uri_for($c->controller('Build')->action_for('build'),

Replacement in src/lib/Hydra/Helper/CatalystUtils.pm at line 205 [33.3469]
B:BD[95.5085] → [95.5085:5127]
```
    my $x = $c->request->params->{$name};
```
[95.5085]
[95.5127]
```
    my $x = $c->stash->{params}->{$name};
```

Insertion in src/lib/Hydra/Schema/BuildInputs.pm at line 17 [100.1]

[99.31]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/BuildInputs.pm at line 171 [100.1]

B:BD[101.25] → [102.1907:2049]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-01-22 13:29:36
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:byU/SLN03zNJlSFbi/3Bcg

[101.25]

[103.151]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:tKZAybbNaRIMs9n5tHkqPw

Insertion in src/lib/Hydra/Schema/BuildOutputs.pm at line 17 [6.1]

[6.241]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/BuildOutputs.pm at line 97 [6.1]

B:BD[6.1127] → [6.1127:1269]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-01-30 16:22:11
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:UpVoKdd3OwMvlvyMjcYNVA

[6.1127]

[6.1269]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:V8MbzKvZNEaeHBJV67+ZMQ

Insertion in src/lib/Hydra/Schema/BuildProducts.pm at line 17 [87.4268]

[99.1499]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/BuildProducts.pm at line 153 [87.4268]

B:BD[87.5065] → [102.2587:2729]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-01-22 13:29:36
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:KHwh/Np40jxKXc3ijMImEQ

[87.5065]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:+0LkZiaRL5tGJvbLxnwD/g

Insertion in src/lib/Hydra/Schema/BuildStepOutputs.pm at line 17 [6.1415]

[6.1663]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/BuildStepOutputs.pm at line 122 [6.1415]

B:BD[6.3027] → [6.3027:3169]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-01-30 16:22:11
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:dC1yX7arRVu9K3wG9dAjCg

[6.3027]

[6.3169]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:A/4v3ugXYbuYoKPlOvC6mg

Insertion in src/lib/Hydra/Schema/BuildSteps.pm at line 17 [104.1675]

[99.5578]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/BuildSteps.pm at line 169 [104.1675]

B:BD[28.9976] → [28.9976:10118]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-01-30 16:36:03
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:ZiA1nv73Fpp0/DTi4sLfEQ

[28.9976]

[28.10118]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:OZsXJniZ/7EB2iSz7p5y4A

Insertion in src/lib/Hydra/Schema/Builds.pm at line 17 [87.5202]

[99.7023]

[99.7037]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/Builds.pm at line 472 [87.5202]

B:BD[105.1182] → [106.0:142]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-05-03 14:35:11
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:aYVEk+AeDsgTRi5GAqOhEw

[105.1182]

[107.3377]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:isCEXACY/PwkvgKHcXvAIg

Insertion in src/lib/Hydra/Schema/CachedBazaarInputs.pm at line 17 [108.456]

[108.644]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/CachedBazaarInputs.pm at line 86 [108.456]

B:BD[108.1677] → [109.11573:11715]

# Created by DBIx::Class::Schema::Loader v0.07014 @ 2011-12-05 14:15:43
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:ONhBo6Xhq7uwYFdEzbp3dg

[108.1677]

[108.1819]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:zvun8uhxwrr7B8EsqBoCjA

Insertion in src/lib/Hydra/Schema/CachedCVSInputs.pm at line 17 [110.1]

[99.10554]

[110.180]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/CachedCVSInputs.pm at line 102 [110.1]

B:BD[110.1055] → [109.12333:12475]

# Created by DBIx::Class::Schema::Loader v0.07014 @ 2011-12-05 14:15:43
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:IcSVN/tlfQQtX88Ix+aKnw

[110.1055]

[110.1200]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:Vi1qzjW52Lnsl0JSmGzy0w

Insertion in src/lib/Hydra/Schema/CachedGitInputs.pm at line 17 [110.1340]

[99.11351]

[110.1494]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/CachedGitInputs.pm at line 95 [110.1340]

B:BD[110.2415] → [109.13012:13154]

# Created by DBIx::Class::Schema::Loader v0.07014 @ 2011-12-05 14:15:43
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:fx3yosWMmJ+MnvL/dSWtFA

[110.2415]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:I4hI02FKRMkw76WV/KBocA

Insertion in src/lib/Hydra/Schema/CachedHgInputs.pm at line 17 [111.1]

[111.185]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/CachedHgInputs.pm at line 95 [111.1]

B:BD[111.1417] → [109.13689:13831]

# Created by DBIx::Class::Schema::Loader v0.07014 @ 2011-12-05 14:15:43
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:xFLnuCBAcJCg+N3b4aajZQ

[111.1417]

[111.1559]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:qS/eiiZXmpc7KpTHdtaT7g

Insertion in src/lib/Hydra/Schema/CachedPathInputs.pm at line 17 [112.859]

[99.12238]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/CachedPathInputs.pm at line 93 [112.859]

B:BD[112.1497] → [109.14368:14510]

# Created by DBIx::Class::Schema::Loader v0.07014 @ 2011-12-05 14:15:43
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:4KzXhMnUldVgNuuNXWIYjw

[112.1497]

[112.1639]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:28rja0vR1glJJ15hzVfjsQ

Insertion in src/lib/Hydra/Schema/CachedSubversionInputs.pm at line 17 [112.1780]

[99.12952]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/CachedSubversionInputs.pm at line 86 [112.1780]

B:BD[112.2485] → [109.14979:15121]

# Created by DBIx::Class::Schema::Loader v0.07014 @ 2011-12-05 14:15:43
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:1rjwWtZXGEowHqhfjLqjmA

[112.2485]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:3qXfnvkOVj25W94bfhQ65w

Insertion in src/lib/Hydra/Schema/Jobs.pm at line 17 [113.1454]

[99.13573]

[113.1536]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/Jobs.pm at line 141 [113.1454]

B:BD[113.2613] → [14.0:142]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-05-23 16:09:46
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:JgxEaCz/TW9YKa+HavRzXw

[113.2613]

[113.2756]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:t2CCfUjFEz/lO4szROz1AQ

Insertion in src/lib/Hydra/Schema/JobsetEvalInputs.pm at line 17 [114.378]

[114.626]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/JobsetEvalInputs.pm at line 169 [114.378]

B:BD[114.2509] → [102.4272:4414]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-01-22 13:29:36
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:ng+Q6tMX5EJMD7DxRWVy7Q

[114.2509]

[114.2651]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:1Dp8B58leBLh4GK0GPw2zg

Insertion in src/lib/Hydra/Schema/JobsetEvalMembers.pm at line 17 [105.1327]

[105.1514]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/JobsetEvalMembers.pm at line 113 [105.1327]

B:BD[109.17200] → [102.4746:4888]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-01-22 13:29:36
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:EVwSR9WBqbBdIHq1ANQMHg

[109.17200]

[105.2915]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:ccPNQe/QnSjTAC3uGWe8Ng

Insertion in src/lib/Hydra/Schema/JobsetEvals.pm at line 17 [115.65]

[99.15993]

[115.221]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/JobsetEvals.pm at line 191 [115.65]

B:BD[109.18354] → [102.5154:5296]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-01-22 13:29:36
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:qElGj6zzuI0xo426np3r1w

[109.18354]

[116.1674]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:SlEiF8oN6FBK262uSiMKiw

Insertion in src/lib/Hydra/Schema/JobsetInputAlts.pm at line 17 [117.825]

[99.14945]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/JobsetInputAlts.pm at line 124 [117.825]

B:BD[117.1974] → [102.5372:5514]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-01-22 13:29:36
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:M3pNBRLfxgSScrPj1zaajA

[117.1974]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:UUO37lIuEYm0GiR92m/fyA

Insertion in src/lib/Hydra/Schema/JobsetInputs.pm at line 17 [118.590]

[99.16929]

[99.16930]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/JobsetInputs.pm at line 145 [118.590]

B:BD[118.1825] → [102.5610:5752]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-01-22 13:29:36
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:xjioYUPo6visoLAVDkDZ0Q

[118.1825]

[109.20420]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:UXBzqO0vHPql4LYyXpgEQg

Insertion in src/lib/Hydra/Schema/Jobsets.pm at line 17 [118.1960]

[99.17859]

[99.17860]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/Jobsets.pm at line 275 [118.1960]

B:BD[118.3136] → [11.317:459]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-05-02 14:50:55
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:q4amPCWRoWMThnRa/n/y1w

[118.3136]

[109.22627]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:tsGR8MhZRIUeNwpcVczMUw

Insertion in src/lib/Hydra/Schema/NewsItems.pm at line 17 [88.2337]

[88.2516]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/NewsItems.pm at line 103 [88.2337]

B:BD[88.3800] → [102.6354:6496]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-01-22 13:29:36
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:lnA5Utkwk5WTyKA/M5mlyg

[88.3800]

[88.4112]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:3CRNsvd+YnZp9c80tuZREQ

Insertion in src/lib/Hydra/Schema/ProjectMembers.pm at line 17 [119.294]

[119.478]

[119.479]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/ProjectMembers.pm at line 106 [119.294]

B:BD[119.1559] → [102.6742:6884]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-01-22 13:29:36
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:zW87n6E7xWaShcFbgFkVuw

[119.1559]

[119.1701]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:imPoiaitrTbX0vVNlF6dPA

Insertion in src/lib/Hydra/Schema/Projects.pm at line 17 [118.3266]

[99.19826]

[99.19839]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/Projects.pm at line 270 [118.3266]

B:BD[102.7308] → [102.7308:7450]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-01-22 13:29:36
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:OCuhmxs8pZxvmk81eVLLcQ

[102.7308]

[88.4514]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:RffghAo9jAaqYk41y1Sdqw

Insertion in src/lib/Hydra/Schema/ReleaseMembers.pm at line 17 [84.1847]

[99.21504]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/ReleaseMembers.pm at line 138 [84.1847]

B:BD[84.3083] → [102.7862:8004]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-01-22 13:29:36
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:eP00w5UJp1uTtiB7D5IhTQ

[84.3083]

[99.22596]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:7M7WPlGQT6rNHKJ+82/KSA

Insertion in src/lib/Hydra/Schema/Releases.pm at line 17 [84.3220]

[99.22629]

[84.3281]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/Releases.pm at line 122 [84.3220]

B:BD[84.4209] → [102.8187:8329]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-01-22 13:29:36
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:UTUE3Hb89fT7prwnwwBgvQ

[84.4209]

[84.4355]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:qISBiwvboB8dIdinaE45mg

Insertion in src/lib/Hydra/Schema/SchemaVersion.pm at line 17 [109.27170]

[109.27412]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/SchemaVersion.pm at line 48 [109.27170]

B:BD[109.27814] → [120.5636:5778]

# Created by DBIx::Class::Schema::Loader v0.07014 @ 2012-02-29 00:47:18
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:LFD28W0GvvrOOylCM98SEQ

[109.27814]

[109.27956]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:08/7gbEQp1TqBiWFJXVY0w

Insertion in src/lib/Hydra/Schema/SystemTypes.pm at line 17 [8.170]

[8.408]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/SystemTypes.pm at line 71 [8.170]

B:BD[8.918] → [8.918:1060]

# Created by DBIx::Class::Schema::Loader v0.07014 @ 2011-12-05 14:15:43
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:zg8db3Cbi0QOv+gLJqH8cQ

[8.918]

[8.1060]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:8cC34cEw9T3+x+7uRs4KHQ

Insertion in src/lib/Hydra/Schema/UriRevMapper.pm at line 17 [121.1]

[121.183]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/UriRevMapper.pm at line 70 [121.1]

B:BD[121.768] → [109.28850:28992]

# Created by DBIx::Class::Schema::Loader v0.07014 @ 2011-12-05 14:15:43
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:hzKzGAgAiCfU0nBOiDnjWw

[121.768]

[121.910]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:G2GAF/Rb7cRkRegH94LwIA

Insertion in src/lib/Hydra/Schema/UserRoles.pm at line 17 [122.3263]

[99.23980]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/UserRoles.pm at line 90 [122.3263]

B:BD[99.24455] → [102.8405:8547]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-01-22 13:29:36
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:KArPHyemtnm/siwE4x5mGQ

[99.24455]

[99.24597]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:aS+ivlFpndqIv8U578zz9A

Insertion in src/lib/Hydra/Schema/Users.pm at line 17 [89.3258]

[88.5184]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/Users.pm at line 164 [89.3258]

B:BD[102.8787] → [102.8787:8929]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-01-22 13:29:36
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:OAUFl/teGpfeleb6D8FPlw

[102.8787]

[88.7363]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:hy3MKvFxfL+1bTc7Hcb1zA

Insertion in src/lib/Hydra/Schema/ViewJobs.pm at line 17 [123.5076]

[99.25520]

[123.5143]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/ViewJobs.pm at line 154 [123.5076]

B:BD[123.6213] → [102.9175:9317]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-01-22 13:29:36
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:cbSUw113ENPypbd/sICfgg

[123.6213]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:hz912vBfYw0rHslBPqJW2w

Insertion in src/lib/Hydra/Schema/Views.pm at line 17 [123.6351]

[99.26797]

[99.26811]


=head1 COMPONENTS LOADED
=over 4
=item * L<Hydra::Component::ToJSON>
=back
=cut
__PACKAGE__->load_components("+Hydra::Component::ToJSON");

Replacement in src/lib/Hydra/Schema/Views.pm at line 120 [123.6351]

B:BD[123.7142] → [102.9498:9640]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-01-22 13:29:36
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:Vyd2+0RAF3XGTpq3KswfAQ

[123.7142]

[123.7285]

# Created by DBIx::Class::Schema::Loader v0.07033 @ 2013-06-13 01:54:50
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:U23GZ3k5KZk2go6j2LYLHA

Insertion in src/lib/Makefile.am at line 12 [124.18139]
[12.36]
[12.36]
```
  $(wildcard Hydra/Component/*.pm)		\
```

Replacement in src/root/queue.tt at line 10 [125.1]

B:BD[125.250] → [126.1667:1750]

  [% INCLUDE renderBuildList builds=queue showSchedulingInfo=1 hideResultInfo=1 %]

[125.250]

[125.333]

  [% INCLUDE renderBuildList builds=resource showSchedulingInfo=1 hideResultInfo=1 %]

Replacement in src/root/status.tt at line 9 [94.1151]
B:BD[127.4654] → [127.4654:4686]
```
    [% FOREACH step IN steps %]
```
[127.4654]
[127.4686]
```
    [% FOREACH step IN resource %]
```

Replacement in src/root/topbar.tt at line 40 [129.6671]

∅:D[10.145] → [128.11260:11384]

∅:D[130.656] → [128.11260:11384]

B:BD[128.11260] → [128.11260:11384]

      [% INCLUDE menuItem uri = c.uri_for(c.controller('Project').action_for('view'), [project.name]) title = "Overview" %]

[10.145]

[131.81]

      [% INCLUDE menuItem uri = c.uri_for(c.controller('Project').action_for('project'), [project.name]) title = "Overview" %]

Replacement in src/root/topbar.tt at line 59 [129.6671]

∅:D[132.151] → [128.12386:12483]

B:BD[128.12386] → [128.12386:12483]

        uri = c.uri_for(c.controller('Jobset').action_for('index'), [project.name, jobset.name])

[132.151]

[128.12483]

        uri = c.uri_for(c.controller('Jobset').action_for('jobset'), [project.name, jobset.name])

Replacement in src/sql/Makefile.am at line 19 [133.3409]

B:BD[133.3735] → [109.32443:32664]

	perl -MDBIx::Class::Schema::Loader=make_schema_at,dump_to_dir:../lib -e 'make_schema_at("Hydra::Schema", { naming => { ALL => "v5" }, relationships => 1, moniker_map => sub {return "$$_";} }, ["dbi:SQLite:tmp.sqlite"])'

[133.3735]

	perl -I ../lib -MDBIx::Class::Schema::Loader=make_schema_at,dump_to_dir:../lib -e 'make_schema_at("Hydra::Schema", { naming => { ALL => "v5" }, relationships => 1, moniker_map => sub {return "$$_";}, components => [ "+Hydra::Component::ToJSON" ], }, ["dbi:SQLite:tmp.sqlite"])'

File addition: api-test.nix (----------)

[134.73]

let
  builder = builtins.toFile "builder.sh" ''
    echo -n ${builtins.readFile ./default.nix} > $out
  '';
in {
  job = derivation {
    name = "job";
    system = builtins.currentSystem;
    builder = "/bin/sh";
    args = [ builder ];
  };
}

File addition: api-test.pl (----------)