lix/scripts/nix-push.in

268 lines
7 KiB
Plaintext
Raw Normal View History

#! @perl@ -w -I@libexecdir@/nix
use strict;
use POSIX qw(tmpnam);
2004-12-28 21:11:28 +00:00
use readmanifest;
2005-03-15 11:12:48 +00:00
my $hashAlgo = "sha256";
my $tmpdir;
do { $tmpdir = tmpnam(); }
until mkdir $tmpdir, 0777;
2003-11-22 20:39:51 +00:00
my $nixfile = "$tmpdir/create-nars.nix";
my $manifest = "$tmpdir/MANIFEST";
2003-12-01 16:34:35 +00:00
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 $targetArchivesDir;
2005-02-24 14:06:18 +00:00
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;
if ($ARGV[0] eq "--target") {
shift @ARGV;
$targetArchivesDir = shift @ARGV;
}
else {
$targetArchivesDir = $localArchivesDir;
}
}
else {
die "syntax: nix-push ARCHIVES_PUT_URL ARCHIVES_GET_URL " .
"MANIFEST_PUT_URL PATHS...\n" if scalar @ARGV < 3;
$localCopy = 0;
2005-02-24 14:06:18 +00:00
$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.
2004-12-28 21:11:28 +00:00
my %storePaths;
foreach my $path (@ARGV) {
die unless $path =~ /^\//;
# Get all paths referenced by the normalisation of the given
# Nix expression.
2005-09-21 17:14:52 +00:00
my $pid = open(READ,
"$binDir/nix-store --query --requisites --force-realise " .
2005-09-21 17:14:52 +00:00
"--include-outputs '$path'|") or die;
while (<READ>) {
2003-07-10 19:27:46 +00:00
chomp;
die "bad: $_" unless /^\//;
2004-12-28 21:11:28 +00:00
$storePaths{$_} = "";
}
2005-09-21 17:14:52 +00:00
close READ or die "nix-store failed: $?";
2003-12-01 16:34:35 +00:00
}
2004-12-28 21:11:28 +00:00
my @storePaths = keys %storePaths;
2003-12-01 16:34:35 +00:00
# For each path, create a Nix expression that turns the path into
# a Nix archive.
open NIX, ">$nixfile";
print NIX "[";
2004-12-28 21:11:28 +00:00
foreach my $storePath (@storePaths) {
die unless ($storePath =~ /\/[0-9a-z]{32}.*$/);
2003-12-01 16:34:35 +00:00
# Construct a Nix expression that creates a Nix archive.
# !!! the string reference to `$storePath' is impure! We could
# also pass it as a normal input, but that would cause it to be
# copied, and its name would be expanded (e.g.,
# /nix/store/HASH1-HASH2-symname). nix-instantiate should be
# smart enough to add store paths as direct references of the Nix
# expression.
2003-12-01 16:34:35 +00:00
my $nixexpr =
"((import $dataDir/nix/corepkgs/nar/nar.nix) " .
2005-03-15 11:12:48 +00:00
"{path = \"$storePath\"; system = \"@system@\"; hashAlgo = \"$hashAlgo\";}) ";
2003-12-01 16:34:35 +00:00
print NIX $nixexpr;
2003-08-05 12:30:06 +00:00
}
2003-11-22 20:39:51 +00:00
print NIX "]";
close NIX;
2003-08-05 12:30:06 +00:00
# Instantiate store expressions from the Nix expression.
2005-02-24 14:06:18 +00:00
my @storeExprs;
print STDERR "instantiating store expressions...\n";
2005-09-21 17:14:52 +00:00
my $pid = open(READ, "$binDir/nix-instantiate $nixfile|")
2005-03-15 11:12:48 +00:00
or die "cannot run nix-instantiate";
while (<READ>) {
2003-08-05 12:30:06 +00:00
chomp;
die unless /^\//;
2005-02-24 14:06:18 +00:00
push @storeExprs, $_;
2003-08-05 12:30:06 +00:00
}
2005-09-21 17:14:52 +00:00
close READ or die "nix-instantiate failed: $?";
# Realise the store expressions.
2003-08-05 12:30:06 +00:00
print STDERR "creating archives...\n";
2005-02-24 14:06:18 +00:00
my @narPaths;
2005-02-24 14:06:18 +00:00
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];
# Note: we disable build hooks because of the impure path
# reference (see above). Even if that is fixed, using a hook
# probably wouldn't make that much sense; pumping lots of data
# around just to compress them won't gain that much.
2005-11-17 13:58:23 +00:00
$ENV{"NIX_BUILD_HOOK"} = "";
my $pid = open(READ, "$binDir/nix-store --realise @tmp2|")
2005-03-15 11:12:48 +00:00
or die "cannot run nix-store";
while (<READ>) {
chomp;
die unless (/^\//);
2005-02-24 14:06:18 +00:00
push @narPaths, "$_";
}
2005-09-21 17:14:52 +00:00
close READ or die "nix-store failed: $?";
}
# Create the manifest.
print STDERR "creating manifest...\n";
2004-12-28 21:11:28 +00:00
my %narFiles;
my %patches;
2005-02-24 14:06:18 +00:00
my @narArchives;
2004-12-28 21:11:28 +00:00
for (my $n = 0; $n < scalar @storePaths; $n++) {
my $storePath = $storePaths[$n];
2005-02-24 14:06:18 +00:00
my $narDir = $narPaths[$n];
2004-12-28 21:11:28 +00:00
$storePath =~ /\/([^\/]*)$/;
my $basename = $1;
defined $basename or die;
2005-03-15 11:12:48 +00:00
open HASH, "$narDir/narbz2-hash" or die "cannot open narbz2-hash";
my $narbz2Hash = <HASH>;
chomp $narbz2Hash;
2005-03-15 11:12:48 +00:00
$narbz2Hash =~ /^[0-9a-z]+$/ or die "invalid hash";
close HASH;
2005-03-15 11:12:48 +00:00
open HASH, "$narDir/nar-hash" or die "cannot open nar-hash";
my $narHash = <HASH>;
chomp $narHash;
2005-03-15 11:12:48 +00:00
$narHash =~ /^[0-9a-z]+$/ or die "invalid hash";
close HASH;
my $narName = "$narbz2Hash.nar.bz2";
my $narFile = "$narDir/$narName";
(-f $narFile) or die "narfile for $storePath not found";
push @narArchives, $narFile;
2005-02-24 14:06:18 +00:00
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://$targetArchivesDir/$narName";
} else {
$url = "$archivesGetURL/$narName";
}
2004-12-28 21:11:28 +00:00
$narFiles{$storePath} = [
{ url => $url
2005-03-15 11:12:48 +00:00
, hash => "$hashAlgo:$narbz2Hash"
2004-12-28 21:11:28 +00:00
, size => $narbz2Size
2005-03-15 11:12:48 +00:00
, narHash => "$hashAlgo:$narHash"
, references => $references
, deriver => $deriver
2004-12-28 21:11:28 +00:00
}
];
}
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";
2005-02-24 14:06:18 +00:00
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") {
2005-02-24 14:06:18 +00:00
print STDERR " $narArchive\n";
copyFile $narArchive, "$localArchivesDir/$basename";
}
}
else {
2005-02-24 14:06:18 +00:00
if (!archiveExists("$basename")) {
print STDERR " $narArchive\n";
system("$curl --show-error --upload-file " .
2005-02-24 14:06:18 +00:00
"'$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 " .
2005-02-24 14:06:18 +00:00
"'$manifest' '$manifestPutURL' > /dev/null") == 0 or
die "curl failed on $manifest: $?";
}