mirror of
https://github.com/NixOS/nix.git
synced 2025-11-27 20:51:00 +01:00
251 lines
7.7 KiB
Perl
Executable file
251 lines
7.7 KiB
Perl
Executable file
#! @perl@ -w
|
|
|
|
use strict;
|
|
use Cwd;
|
|
use IO::Handle;
|
|
use Fcntl;
|
|
|
|
STDOUT->autoflush(1);
|
|
|
|
my $out = $ENV{"out"};
|
|
mkdir "$out", 0755 || die "error creating $out";
|
|
|
|
sub readlink_or_StateWrapper;
|
|
|
|
my $symlinks = 0;
|
|
my %path_state_identifier = ();
|
|
|
|
my %priorities;
|
|
|
|
my $nixBinDir = $ENV{"nixBinDir"};
|
|
my $nixStore = $ENV{"nixStore"};
|
|
|
|
# For each activated package, create symlinks.
|
|
|
|
sub createLinks {
|
|
my $srcDir = shift;
|
|
|
|
#Lookup each $stateIdentifiers in $path_state_identifier
|
|
#we strip $srcDir to its rootdir e.g. /nix/store/......./
|
|
my @srcDirParts = split /\// , substr($srcDir, length ($nixStore), length ($srcDir));
|
|
my $srcDirRoot = $nixStore . "/" . $srcDirParts[1];
|
|
# print "srcDirRoot $srcDirRoot \n";
|
|
|
|
my $dstDir = shift;
|
|
my $priority = shift;
|
|
my $pkgStateIdentifier = $path_state_identifier{$srcDirRoot}; # We have to look it up each time since recursion can change the $srcDir, but not the identifier
|
|
|
|
#print "createLinks $srcDir to $dstDir with iden $pkgStateIdentifier \n";
|
|
|
|
my @srcFiles = glob("$srcDir/*");
|
|
|
|
foreach my $srcFile (@srcFiles) {
|
|
my $baseName = $srcFile;
|
|
$baseName =~ s/^.*\///g; # strip directory
|
|
my $dstFile = "$dstDir/$baseName";
|
|
|
|
# Urgh, hacky...
|
|
if ($srcFile =~ /\/propagated-build-inputs$/ ||
|
|
$srcFile =~ /\/nix-support$/ ||
|
|
$srcFile =~ /\/perllocal.pod$/ ||
|
|
$srcFile =~ /\/info\/dir$/ ||
|
|
$srcFile =~ /\/log$/)
|
|
{
|
|
# Do nothing.
|
|
}
|
|
|
|
elsif (-d $srcFile) {
|
|
|
|
lstat $dstFile;
|
|
|
|
#go recursive on directorys
|
|
if (-d _) {
|
|
createLinks($srcFile, $dstFile, $priority);
|
|
}
|
|
|
|
elsif (-l _) {
|
|
my $target = readlink $dstFile or die;
|
|
if (!-d $target) {
|
|
die "collission between directory `$srcFile' and non-directory `$target'";
|
|
}
|
|
unlink $dstFile or die "error unlinking `$dstFile': $!";
|
|
mkdir $dstFile, 0755 || die "error creating directory `$dstFile': $!";
|
|
createLinks($target, $dstFile, $priorities{$dstFile});
|
|
createLinks($srcFile, $dstFile, $priority);
|
|
}
|
|
|
|
else {
|
|
|
|
#print "1ST DIR LINK $srcFile to $dstFile with iden $pkgStateIdentifier \n";
|
|
|
|
symlink($srcFile, $dstFile) ||
|
|
die "error creating link `$dstFile': $!";
|
|
$priorities{$dstFile} = $priority;
|
|
$symlinks++;
|
|
}
|
|
}
|
|
|
|
else {
|
|
|
|
# print "ELSE LINK $srcFile to $dstFile with iden $pkgStateIdentifier \n";
|
|
|
|
# if we have a state component with a identifier different then ""
|
|
if($pkgStateIdentifier ne "__NOSTATE__" && $pkgStateIdentifier ne ""){
|
|
|
|
my @pathparts = split /\// , $srcFile;
|
|
my $parentDir = $pathparts[scalar(@pathparts) - 2];
|
|
|
|
if( $parentDir eq "bin" || $parentDir eq "sbin"){ #hacky....
|
|
|
|
print "STATELINK $srcFile to $dstFile - $pkgStateIdentifier \n";
|
|
|
|
my $new_dstFile;
|
|
my $new_stateIdentifier;
|
|
if($pkgStateIdentifier eq "__EMTPY__"){
|
|
$new_dstFile = $dstFile;
|
|
$new_stateIdentifier = "";
|
|
}
|
|
else{
|
|
$new_dstFile = "$dstFile-$pkgStateIdentifier";
|
|
$new_stateIdentifier = $pkgStateIdentifier;
|
|
}
|
|
|
|
# We also check with -e if the wrapperscript-file exists, and if is it a symlink (with -l)
|
|
if (-l $new_dstFile || -e $new_dstFile) {
|
|
my $target = readlink_or_StateWrapper $new_dstFile;
|
|
die "(state) collission between `$srcFile' and `$target' (over $new_dstFile)";
|
|
}
|
|
|
|
sysopen (DSTFILEHANDLE, $new_dstFile, O_RDWR|O_EXCL|O_CREAT, 0755);
|
|
printf DSTFILEHANDLE "#! @shell@ \n";
|
|
printf DSTFILEHANDLE "$nixBinDir/nix-state --run --identifier=$new_stateIdentifier $srcFile \"\$@\" \n";
|
|
close (DSTFILEHANDLE);
|
|
}
|
|
|
|
}
|
|
elsif($pkgStateIdentifier ne "__NOSTATE__" && $pkgStateIdentifier eq ""){ #TODO we now dont create symlinks for state packages with a empty identifier
|
|
#TODO but we must do it if there is no normal non-state pacakge
|
|
}
|
|
|
|
else {
|
|
|
|
if (-l $dstFile || -e $dstFile) {
|
|
my $target = readlink_or_StateWrapper $dstFile;
|
|
my $prevPriority = $priorities{$dstFile};
|
|
die ( "Collission between `$srcFile' and `$target'. "
|
|
. "Suggested solution: use `nix-env --set-flag "
|
|
. "priority NUMBER PKGNAME' to change the priority of "
|
|
. "one of the conflicting packages.\n" )
|
|
if $prevPriority == $priority;
|
|
next if $prevPriority < $priority;
|
|
unlink $dstFile or die;
|
|
}
|
|
|
|
# print "2ND LINK $srcFile to $dstFile with iden $pkgStateIdentifier \n";
|
|
symlink($srcFile, $dstFile) ||
|
|
die "error creating link `$dstFile': $!";
|
|
$priorities{$dstFile} = $priority;
|
|
$symlinks++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
my %done;
|
|
my %postponed;
|
|
|
|
sub addPkg;
|
|
sub addPkg {
|
|
my $pkgDir = shift;
|
|
my $priority = shift;
|
|
|
|
return if (defined $done{$pkgDir});
|
|
$done{$pkgDir} = 1;
|
|
|
|
# print "symlinking $pkgDir\n";
|
|
createLinks("$pkgDir", "$out", $priority);
|
|
|
|
my $propagatedFN = "$pkgDir/nix-support/propagated-user-env-packages";
|
|
if (-e $propagatedFN) {
|
|
open PROP, "<$propagatedFN" or die;
|
|
my $propagated = <PROP>;
|
|
close PROP;
|
|
my @propagated = split ' ', $propagated;
|
|
foreach my $p (@propagated) {
|
|
$postponed{$p} = 1 unless defined $done{$p};
|
|
}
|
|
}
|
|
}
|
|
|
|
sub readlink_or_StateWrapper {
|
|
|
|
my $src = shift;
|
|
my $target;
|
|
|
|
if (-l $src)
|
|
{ $target = readlink $src; }
|
|
else{
|
|
open(DAT, $src) || die("Could not open file!");
|
|
my @raw_data=<DAT>;
|
|
close(DAT);
|
|
$target = $raw_data[1];
|
|
}
|
|
return $target
|
|
}
|
|
|
|
my @stateIdentifiers = split ' ', $ENV{"stateIdentifiers"};
|
|
my $si_counter = 0;
|
|
|
|
# Convert the stuff we get from the environment back into a coherent
|
|
# data type.
|
|
my @paths = split ' ', $ENV{"paths"};
|
|
my @active = split ' ', $ENV{"active"};
|
|
my @priority = split ' ', $ENV{"priority"};
|
|
|
|
die if scalar @paths != scalar @active;
|
|
die if scalar @paths != scalar @priority;
|
|
|
|
my %pkgs;
|
|
|
|
for (my $n = 0; $n < scalar @paths; $n++) {
|
|
$pkgs{$paths[$n]} =
|
|
{ active => $active[$n]
|
|
, priority => $priority[$n]
|
|
, stateidentifier => $stateIdentifiers[$n]
|
|
};
|
|
|
|
$path_state_identifier{$paths[$n]} = $stateIdentifiers[$n];
|
|
}
|
|
|
|
# Symlink to the packages that have been installed explicitly by the
|
|
# user.
|
|
foreach my $pkg (sort (keys %pkgs)) {
|
|
|
|
#print "SP: $pkg \n";
|
|
#print "SI: $pkgs{$pkg}->{stateidentifier} \n";
|
|
#print "PR: $pkgs{$pkg}->{priority} \n";
|
|
|
|
addPkg($pkg, $pkgs{$pkg}->{priority}) if $pkgs{$pkg}->{active} ne "false";
|
|
$si_counter++;
|
|
}
|
|
|
|
|
|
# Symlink to the packages that have been "propagated" by packages
|
|
# installed by the user (i.e., package X declares that it want Y
|
|
# installed as well). We do these later because they have a lower
|
|
# priority in case of collisions.
|
|
my $priorityCounter = 1000; # don't care about collisions
|
|
while (scalar(keys %postponed) > 0) {
|
|
|
|
my @pkgDirs = keys %postponed;
|
|
%postponed = ();
|
|
foreach my $pkgDir (sort @pkgDirs) {
|
|
addPkg($pkgDir, $priorityCounter++);
|
|
}
|
|
}
|
|
|
|
print STDERR "created $symlinks symlinks in user environment\n";
|
|
|
|
symlink($ENV{"manifest"}, "$out/manifest") or die "cannot create manifest";
|
|
|