package Hydra::Base::Controller::Nix;
use strict;
use warnings;
use parent 'Catalyst::Controller';
use Hydra::Helper::Nix;
use Hydra::Helper::CatalystUtils;
sub closure : Chained('nix') PathPart {
    my ($self, $c) = @_;
    $c->stash->{current_view} = 'Hydra::View::NixClosure';
    # !!! quick hack; this is to make HEAD requests return the right
    # MIME type.  This is set in the view as well, but the view isn't
    # called for HEAD requests.  There should be a cleaner solution...
    $c->response->content_type('application/x-nix-export');
}
sub manifest : Chained('nix') PathPart Args(0) {
    my ($self, $c) = @_;
    $c->stash->{current_view} = 'Hydra::View::NixManifest';
}
1;

use parent 'Catalyst::Controller';

use base 'Hydra::Base::Controller::Nix';

    
    if (!defined $c->stash->{build}) {
        error($c, "Build with ID $id doesn't exist.");
        $c->response->status(404);
        return;
    }

    notFound($c, "Build with ID $id doesn't exist.")
        if !defined $c->stash->{build};

    return error($c, "Build doesn't have a build step $stepnr.") if !defined $step;

    notFound($c, "Build doesn't have a build step $stepnr.") if !defined $step;

    return error($c, "Build didn't produce a log.") if !defined $c->stash->{build}->resultInfo->logfile;

    error($c, "Build didn't produce a log.") if !defined $c->stash->{build}->resultInfo->logfile;

    return error($c, "Build doesn't have a product $productnr.") if !defined $product;

    notFound($c, "Build doesn't have a product $productnr.") if !defined $product;

    return error($c, "Product " . $product->path . " has disappeared.") unless -e $product->path;

    error($c, "Product " . $product->path . " has disappeared.") unless -e $product->path;

        return error($c, "Invalid filename $elem.") if $elem !~ /^$pathCompRE$/;

        error($c, "Invalid filename $elem.") if $elem !~ /^$pathCompRE$/;

    if (!-e $path) {
        return error($c, "File $path does not exist.");
    }

    notFound($c, "File $path does not exist.") if !-e $path;

}
sub nix : Chained('build') PathPart('nix') CaptureArgs(0) {
    my ($self, $c) = @_;
    my $build = $c->stash->{build};
    error($c, "Build cannot be downloaded as a closure or Nix package.")
        if !$build->buildproducts->find({type => "nix-build"});
    error($c, "Path " . $build->outpath . " is no longer available.")
        unless isValidPath($build->outpath);
    
    $c->stash->{name} = $build->nixname;
    $c->stash->{storePaths} = [$build->outpath];

use parent 'Catalyst::Controller';

use base 'Catalyst::Controller';

    return error($c, "Project $projectName doesn't exist.") if !defined $project;

    notFound($c, "Project $projectName doesn't exist.") if !defined $project;

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

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

        else { return error($c, "Unknown subcommand."); }

        else { error($c, "Unknown subcommand."); }

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

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

        eval {
            my $releaseSetName = $c->request->params->{name};
            $c->model('DB')->schema->txn_do(sub {
                # Note: $releaseSetName is validated in updateProject,
                # which will abort the transaction if the name isn't
                # valid.
                my $releaseSet = $project->releasesets->create({name => $releaseSetName});
                updateReleaseSet($c, $releaseSet);
                return $c->res->redirect($c->uri_for("/releases", $projectName, $releaseSet->name));
            });
        };
        if ($@) {
            return error($c, $@);
        }

        my $releaseSetName = $c->request->params->{name};
        $c->model('DB')->schema->txn_do(sub {
            # Note: $releaseSetName is validated in updateProject,
            # which will abort the transaction if the name isn't
            # valid.
            my $releaseSet = $project->releasesets->create({name => $releaseSetName});
            updateReleaseSet($c, $releaseSet);
            return $c->res->redirect($c->uri_for("/releases", $projectName, $releaseSet->name));
        });

        return error($c, "This release set has no successful releases yet.") if !defined $latest;

        error($c, "This release set has no successful releases yet.") if !defined $latest;

    return error($c, "Release $releaseId doesn't exist.") if !defined $primaryBuild;

    error($c, "Release $releaseId doesn't exist.") if !defined $primaryBuild;

    return error($c, "Project $projectName doesn't exist.") if !defined $project;

    notFound($c, "Project $projectName doesn't exist.") if !defined $project;

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

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

            return error($c, "Unknown subcommand $subcommand.");

            error($c, "Unknown subcommand $subcommand.");

    return error($c, "Only administrators can create projects.")

    error($c, "Only administrators can create projects.")

        eval {
            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));
        };
        if ($@) {
            return error($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);
        });
        return $c->res->redirect($c->uri_for("/project", $projectName));

    return error($c, "Project $projectName doesn't exist.") if !defined $project;

    notFound($c, "Project $projectName doesn't exist.") if !defined $project;

    error($c, "Page not found.");
    $c->response->status(404);

    notFound($c, "Page not found.");

sub closure :Local {
    my ($self, $c, $buildId) = @_;

    my $build = getBuild($c, $buildId);
    return error($c, "Build $buildId doesn't exist.") if !defined $build;

    return error($c, "Build $buildId cannot be downloaded as a closure.")
        if !$build->buildproducts->find({type => "nix-build"});
    return error($c, "Path " . $build->outpath . " is no longer available.") unless isValidPath($build->outpath);
    $c->stash->{current_view} = 'Hydra::View::NixClosure';
    $c->stash->{storePath} = $build->outpath;
    $c->stash->{name} = $build->nixname;
    # !!! quick hack; this is to make HEAD requests return the right
    # MIME type.  This is set in the view as well, but the view isn't
    # called for HEAD requests.  There should be a cleaner solution...
    $c->response->content_type('application/x-nix-export');
    $c->response->header('Content-Disposition' => 'attachment; filename=' . $c->stash->{name} . '.closure.gz');
}
sub manifest :Local {
    my ($self, $c, $buildId) = @_;
    my $build = getBuild($c, $buildId);
    return error($c, "Build with ID $buildId doesn't exist.") if !defined $build;
    
    return error($c, "Path " . $build->outpath . " is no longer available.") unless isValidPath($build->outpath);
    
    $c->stash->{current_view} = 'Hydra::View::NixManifest';
    $c->stash->{storePath} = $build->outpath;
}

    return error($c, "Build $buildId doesn't exist.") if !defined $build;

    notFound($c, "Build $buildId doesn't exist.") if !defined $build;

    return error($c, "Build $buildId cannot be downloaded as a Nix package.")

    error($c, "Build $buildId cannot be downloaded as a Nix package.")

    return error($c, "Path " . $build->outpath . " is no longer available.") unless isValidPath($build->outpath);

    error($c, "Path " . $build->outpath . " is no longer available.") unless isValidPath($build->outpath);

    return error($c, "Path " . $path . " is no longer available.") unless isValidPath($path);

    error($c, "Path " . $path . " is no longer available.") unless isValidPath($path);

our @EXPORT = qw(getBuild error);

our @EXPORT = qw(getBuild error notFound);

sub notFound {
    my ($c, $msg) = @_;
    $c->response->status(404);
    error($c, $msg);
}

    my ( $self, $c ) = @_;

    my ($self, $c) = @_;

    $c->response->header('Content-Disposition' => 'attachment; filename=' . $c->stash->{name} . '.closure.gz');

    my $storePath = $c->stash->{storePath};

    my @storePaths = @{$c->stash->{storePaths}};

    open(OUTPUT, "nix-store --export `nix-store -qR $storePath` | gzip |");

    open(OUTPUT, "nix-store --export `nix-store -qR @storePaths` | gzip |");

    my $storePath = $c->stash->{storePath};

    my @storePaths = @{$c->stash->{storePaths}};

    my @paths = split '\n', `nix-store --query --requisites $storePath`
        or die "cannot query dependencies of `$storePath': $?";

    my @paths = split '\n', `nix-store --query --requisites @storePaths`
        or die "cannot query dependencies of path(s) @storePaths: $?";

        <a href="[% c.uri_for('/closure' build.id) %]">

        [% filename = "${build.nixname}.closure.gz" %]
        [% uri = c.uri_for('/build' build.id 'nix' 'closure' filename ) %]
        
        <a href="[% uri %]">

          <pre>$ gunzip &lt; [% HTML.escape(build.nixname) %].closure.gz | nix-store --import</pre>

          <pre>$ gunzip &lt; [% filename %] | nix-store --import</pre>

          <pre>$ curl [% c.uri_for('/closure' build.id) %] | gunzip | nix-store --import</pre>

          <pre>$ curl [% uri %] | gunzip | nix-store --import</pre>