lix-releng-staging/scripts/nix-push.in

#! @perl@ -w -I@libexecdir@/nix

use strict;
use IPC::Open2;
use POSIX qw(tmpnam);
use readmanifest;

my $tmpdir;
do { $tmpdir = tmpnam(); }
until mkdir $tmpdir, 0777;

my $nixfile = "$tmpdir/create-nars.nix";
my $manifest = "$tmpdir/MANIFEST";

END { unlink $manifest; unlink $nixfile; rmdir $tmpdir; }

my $curl = "@curl@ --fail --silent";
my $extraCurlFlags = ${ENV{'CURL_FLAGS'}};
$curl = "$curl $extraCurlFlags" if defined $extraCurlFlags;

my $binDir = $ENV{"NIX_BIN_DIR"};
$binDir = "@bindir@" unless defined $binDir;

my $dataDir = $ENV{"NIX_DATA_DIR"};
$dataDir = "@datadir@" unless defined $dataDir;


# Parse the command line.
my $localCopy;
my $localArchivesDir;
my $localManifestFile;

my $archivesPutURL;
my $archivesGetURL;
my $manifestPutURL;

if ($ARGV[0] eq "--copy") {
    die "syntax: nix-push --copy ARCHIVES_DIR MANIFEST_FILE PATHS...\n" if scalar @ARGV < 3;
    $localCopy = 1;
    shift @ARGV;
    $localArchivesDir = shift @ARGV;
    $localManifestFile = shift @ARGV;
}
else {
    die "syntax: nix-push ARCHIVES_PUT_URL ARCHIVES_GET_URL " .
        "MANIFEST_PUT_URL PATHS...\n" if scalar @ARGV < 3;
    $localCopy = 0;
    $archivesPutURL = shift @ARGV;
    $archivesGetURL = shift @ARGV;
    $manifestPutURL = shift @ARGV;
}


# From the given store paths, determine the set of requisite store
# paths, i.e, the paths required to realise them.
my %storePaths;

foreach my $path (@ARGV) {
    die unless $path =~ /^\//;

    # Get all paths referenced by the normalisation of the given 
    # Nix expression.
    my $pid = open2(\*READ, \*WRITE,
        "$binDir/nix-store --query --requisites --force-realise " .
        "--include-outputs '$path'") or die;
    close WRITE;
    
    while (<READ>) {
        chomp;
        die "bad: $_" unless /^\//;
        $storePaths{$_} = "";
    }
    close READ;
    
    waitpid $pid, 0;
    $? == 0 or die "nix-store failed";
}

my @storePaths = keys %storePaths;


# For each path, create a Nix expression that turns the path into
# a Nix archive.
open NIX, ">$nixfile";
print NIX "[";

foreach my $storePath (@storePaths) {
    die unless ($storePath =~ /\/[0-9a-z]{32}.*$/);

    # Construct a Nix expression that creates a Nix archive.
    my $nixexpr = 
        "((import $dataDir/nix/corepkgs/nar/nar.nix) " .
        "{path = \"$storePath\"; system = \"@system@\";}) ";
    
    print NIX $nixexpr;
}

print NIX "]";
close NIX;


# Instantiate store expressions from the Nix expression.
my @storeExprs;
print STDERR "instantiating store expressions...\n";
open STOREEXPRS, "$binDir/nix-instantiate $nixfile |" or die "cannot run nix-instantiate";
while (<STOREEXPRS>) {
    chomp;
    die unless /^\//;
    push @storeExprs, $_;
}
close STOREEXPRS;


# Realise the store expressions.
print STDERR "creating archives...\n";

my @narPaths;

my @tmp = @storeExprs;
while (scalar @tmp > 0) {
    my $n = scalar @tmp;
    if ($n > 256) { $n = 256 };
    my @tmp2 = @tmp[0..$n - 1];
    @tmp = @tmp[$n..scalar @tmp - 1];

    open NARPATHS, "$binDir/nix-store --realise @tmp2 |" or die "cannot run nix-store";
    while (<NARPATHS>) {
        chomp;
        die unless (/^\//);
        push @narPaths, "$_";
    }
    close NARPATHS;
}


# Create the manifest.
print STDERR "creating manifest...\n";

my %narFiles;
my %patches;

my @narArchives;
for (my $n = 0; $n < scalar @storePaths; $n++) {
    my $storePath = $storePaths[$n];
    my $narDir = $narPaths[$n];
    
    $storePath =~ /\/([^\/]*)$/;
    my $basename = $1;
    defined $basename or die;

    my $narname = "$basename.nar.bz2";

    my $narFile = "$narDir/$narname";
    (-f $narFile) or die "narfile for $storePath not found";
    push @narArchives, $narFile;

    open SHA1, "$narDir/narbz2-hash" or die "cannot open narbz2-hash";
    my $narbz2Hash = <SHA1>;
    chomp $narbz2Hash;
    $narbz2Hash =~ /^[0-9a-z]{32}$/ or die "invalid hash";
    close SHA1;

    open SHA1, "$narDir/nar-hash" or die "cannot open nar-hash";
    my $narHash = <SHA1>;
    chomp $narHash;
    $narHash =~ /^[0-9a-z]{32}$/ or die "invalid hash";
    close SHA1;
    
    my $narbz2Size = (stat $narFile)[7];

    my $references = `$binDir/nix-store --query --references '$storePath'`;
    die "cannot query references for `$storePath'" if $? != 0;
    $references = join(" ", split(" ", $references));

    my $deriver = `$binDir/nix-store --query --deriver '$storePath'`;
    die "cannot query deriver for `$storePath'" if $? != 0;
    chomp $deriver;
    $deriver = "" if $deriver eq "unknown-deriver";

    my $url;
    if ($localCopy) {
        $url = "file://$localArchivesDir/$narname";
    } else {
        $url = "$archivesGetURL/$narname";
    }
    $narFiles{$storePath} = [
        { url => $url
        , hash => $narbz2Hash
        , size => $narbz2Size
        , narHash => $narHash
        , hashAlgo => "sha1"
        , references => $references
        , deriver => $deriver
        }
    ];
}

writeManifest $manifest, \%narFiles, \%patches;


sub copyFile {
    my $src = shift;
    my $dst = shift;
    system("cp '$src' '$dst.tmp'") == 0 or die "cannot copy file";
    rename("$dst.tmp", "$dst") or die "cannot rename file";
}


# Upload the archives.
print STDERR "uploading archives...\n";

sub archiveExists {
    my $name = shift;
    print STDERR "  HEAD on $archivesGetURL/$name\n";
    return system("$curl --head $archivesGetURL/$name > /dev/null") == 0;
}

foreach my $narArchive (@narArchives) {

    $narArchive =~ /\/([^\/]*)$/;
    my $basename = $1;

    if ($localCopy) {
        if (! -f "$localArchivesDir/$basename") {
            print STDERR "  $narArchive\n";
            copyFile $narArchive, "$localArchivesDir/$basename";
        }
    }
    else {
        if (!archiveExists("$basename")) {
            print STDERR "  $narArchive\n";
            system("$curl --show-error --upload-file " .
                   "'$narArchive' '$archivesPutURL/$basename' > /dev/null") == 0 or
                   die "curl failed on $narArchive: $?";
        }
    }
}


# Upload the manifest.
print STDERR "uploading manifest...\n";
if ($localCopy) {
    copyFile $manifest, $localManifestFile;
} else {
    system("$curl  --show-error --upload-file " .
           "'$manifest' '$manifestPutURL' > /dev/null") == 0 or
           die "curl failed on $manifest: $?";
}