Something went wrong. Try again.
My nixos configuration
Something went wrong. Try again.
21 kB · 652 lines
Nix
at hyperion
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653# This file originates from node2nix{ lib, stdenv, nodejs, python2, pkgs, libtool, runCommand, writeTextFile, writeShellScript,}: let # Workaround to cope with utillinux in Nixpkgs 20.09 and util-linux in Nixpkgs master utillinux = if pkgs ? utillinux then pkgs.utillinux else pkgs.util-linux;
python = if nodejs ? python then nodejs.python else python2;
# Create a tar wrapper that filters all the 'Ignoring unknown extended header keyword' noise tarWrapper = runCommand "tarWrapper" {} '' mkdir -p $out/bin
cat > $out/bin/tar <<EOF #! ${stdenv.shell} -e $(type -p tar) "\$@" --warning=no-unknown-keyword --delay-directory-restore EOF
chmod +x $out/bin/tar '';
# Function that generates a TGZ file from a NPM project buildNodeSourceDist = { name, version, src, ... }: stdenv.mkDerivation { name = "node-tarball-${name}-${version}"; inherit src; buildInputs = [nodejs]; buildPhase = '' export HOME=$TMPDIR tgzFile=$(npm pack | tail -n 1) # Hooks to the pack command will add output (https://docs.npmjs.com/misc/scripts) ''; installPhase = '' mkdir -p $out/tarballs mv $tgzFile $out/tarballs mkdir -p $out/nix-support echo "file source-dist $out/tarballs/$tgzFile" >> $out/nix-support/hydra-build-products ''; };
# Common shell logic installPackage = writeShellScript "install-package" '' installPackage() { local packageName=$1 src=$2
local strippedName
local DIR=$PWD cd $TMPDIR
unpackFile $src
# Make the base dir in which the target dependency resides first mkdir -p "$(dirname "$DIR/$packageName")"
if [ -f "$src" ] then # Figure out what directory has been unpacked packageDir="$(find . -maxdepth 1 -type d | tail -1)"
# Restore write permissions to make building work find "$packageDir" -type d -exec chmod u+x {} \; chmod -R u+w "$packageDir"
# Move the extracted tarball into the output folder mv "$packageDir" "$DIR/$packageName" elif [ -d "$src" ] then # Get a stripped name (without hash) of the source directory. # On old nixpkgs it's already set internally. if [ -z "$strippedName" ] then strippedName="$(stripHash $src)" fi
# Restore write permissions to make building work chmod -R u+w "$strippedName"
# Move the extracted directory into the output folder mv "$strippedName" "$DIR/$packageName" fi
# Change to the package directory to install dependencies cd "$DIR/$packageName" } '';
# Bundle the dependencies of the package # # Only include dependencies if they don't exist. They may also be bundled in the package. includeDependencies = {dependencies}: lib.optionalString (dependencies != []) ( '' mkdir -p node_modules cd node_modules '' + (lib.concatMapStrings ( dependency: '' if [ ! -e "${dependency.packageName}" ]; then ${composePackage dependency} fi '' ) dependencies) + '' cd .. '' );
# Recursively composes the dependencies of a package composePackage = { name, packageName, src, dependencies ? [], ... } @ args: builtins.addErrorContext "while evaluating node package '${packageName}'" '' installPackage "${packageName}" "${src}" ${includeDependencies {inherit dependencies;}} cd .. ${lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."} '';
pinpointDependencies = { dependencies, production, }: let pinpointDependenciesFromPackageJSON = writeTextFile { name = "pinpointDependencies.js"; text = '' var fs = require('fs'); var path = require('path');
function resolveDependencyVersion(location, name) { if(location == process.env['NIX_STORE']) { return null; } else { var dependencyPackageJSON = path.join(location, "node_modules", name, "package.json");
if(fs.existsSync(dependencyPackageJSON)) { var dependencyPackageObj = JSON.parse(fs.readFileSync(dependencyPackageJSON));
if(dependencyPackageObj.name == name) { return dependencyPackageObj.version; } } else { return resolveDependencyVersion(path.resolve(location, ".."), name); } } }
function replaceDependencies(dependencies) { if(typeof dependencies == "object" && dependencies !== null) { for(var dependency in dependencies) { var resolvedVersion = resolveDependencyVersion(process.cwd(), dependency);
if(resolvedVersion === null) { process.stderr.write("WARNING: cannot pinpoint dependency: "+dependency+", context: "+process.cwd()+"\n"); } else { dependencies[dependency] = resolvedVersion; } } } }
/* Read the package.json configuration */ var packageObj = JSON.parse(fs.readFileSync('./package.json'));
/* Pinpoint all dependencies */ replaceDependencies(packageObj.dependencies); if(process.argv[2] == "development") { replaceDependencies(packageObj.devDependencies); } replaceDependencies(packageObj.optionalDependencies);
/* Write the fixed package.json file */ fs.writeFileSync("package.json", JSON.stringify(packageObj, null, 2)); ''; }; in '' node ${pinpointDependenciesFromPackageJSON} ${ if production then "production" else "development" }
${lib.optionalString (dependencies != []) '' if [ -d node_modules ] then cd node_modules ${lib.concatMapStrings (dependency: pinpointDependenciesOfPackage dependency) dependencies} cd .. fi ''} '';
# Recursively traverses all dependencies of a package and pinpoints all # dependencies in the package.json file to the versions that are actually # being used.
pinpointDependenciesOfPackage = { packageName, dependencies ? [], production ? true, ... } @ args: '' if [ -d "${packageName}" ] then cd "${packageName}" ${pinpointDependencies {inherit dependencies production;}} cd .. ${lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."} fi '';
# Extract the Node.js source code which is used to compile packages with # native bindings nodeSources = runCommand "node-sources" {} '' tar --no-same-owner --no-same-permissions -xf ${nodejs.src} mv node-* $out '';
# Script that adds _integrity fields to all package.json files to prevent NPM from consulting the cache (that is empty) addIntegrityFieldsScript = writeTextFile { name = "addintegrityfields.js"; text = '' var fs = require('fs'); var path = require('path');
function augmentDependencies(baseDir, dependencies) { for(var dependencyName in dependencies) { var dependency = dependencies[dependencyName];
// Open package.json and augment metadata fields var packageJSONDir = path.join(baseDir, "node_modules", dependencyName); var packageJSONPath = path.join(packageJSONDir, "package.json");
if(fs.existsSync(packageJSONPath)) { // Only augment packages that exist. Sometimes we may have production installs in which development dependencies can be ignored console.log("Adding metadata fields to: "+packageJSONPath); var packageObj = JSON.parse(fs.readFileSync(packageJSONPath));
if(dependency.integrity) { packageObj["_integrity"] = dependency.integrity; } else { packageObj["_integrity"] = "sha1-000000000000000000000000000="; // When no _integrity string has been provided (e.g. by Git dependencies), add a dummy one. It does not seem to harm and it bypasses downloads. }
if(dependency.resolved) { packageObj["_resolved"] = dependency.resolved; // Adopt the resolved property if one has been provided } else { packageObj["_resolved"] = dependency.version; // Set the resolved version to the version identifier. This prevents NPM from cloning Git repositories. }
if(dependency.from !== undefined) { // Adopt from property if one has been provided packageObj["_from"] = dependency.from; }
fs.writeFileSync(packageJSONPath, JSON.stringify(packageObj, null, 2)); }
// Augment transitive dependencies if(dependency.dependencies !== undefined) { augmentDependencies(packageJSONDir, dependency.dependencies); } } }
if(fs.existsSync("./package-lock.json")) { var packageLock = JSON.parse(fs.readFileSync("./package-lock.json"));
if(![1, 2].includes(packageLock.lockfileVersion)) { process.stderr.write("Sorry, I only understand lock file versions 1 and 2!\n"); process.exit(1); }
if(packageLock.dependencies !== undefined) { augmentDependencies(".", packageLock.dependencies); } } ''; };
# Reconstructs a package-lock file from the node_modules/ folder structure and package.json files with dummy sha1 hashes reconstructPackageLock = writeTextFile { name = "addintegrityfields.js"; text = '' var fs = require('fs'); var path = require('path');
var packageObj = JSON.parse(fs.readFileSync("package.json"));
var lockObj = { name: packageObj.name, version: packageObj.version, lockfileVersion: 1, requires: true, dependencies: {} };
function augmentPackageJSON(filePath, dependencies) { var packageJSON = path.join(filePath, "package.json"); if(fs.existsSync(packageJSON)) { var packageObj = JSON.parse(fs.readFileSync(packageJSON)); dependencies[packageObj.name] = { version: packageObj.version, integrity: "sha1-000000000000000000000000000=", dependencies: {} }; processDependencies(path.join(filePath, "node_modules"), dependencies[packageObj.name].dependencies); } }
function processDependencies(dir, dependencies) { if(fs.existsSync(dir)) { var files = fs.readdirSync(dir);
files.forEach(function(entry) { var filePath = path.join(dir, entry); var stats = fs.statSync(filePath);
if(stats.isDirectory()) { if(entry.substr(0, 1) == "@") { // When we encounter a namespace folder, augment all packages belonging to the scope var pkgFiles = fs.readdirSync(filePath);
pkgFiles.forEach(function(entry) { if(stats.isDirectory()) { var pkgFilePath = path.join(filePath, entry); augmentPackageJSON(pkgFilePath, dependencies); } }); } else { augmentPackageJSON(filePath, dependencies); } } }); } }
processDependencies("node_modules", lockObj.dependencies);
fs.writeFileSync("package-lock.json", JSON.stringify(lockObj, null, 2)); ''; };
prepareAndInvokeNPM = { packageName, bypassCache, reconstructLock, npmFlags, production, }: let forceOfflineFlag = if bypassCache then "--offline" else "--registry http://www.example.com"; in '' # Pinpoint the versions of all dependencies to the ones that are actually being used echo "pinpointing versions of dependencies..." source $pinpointDependenciesScriptPath
# Patch the shebangs of the bundled modules to prevent them from # calling executables outside the Nix store as much as possible patchShebangs .
# Deploy the Node.js package by running npm install. Since the # dependencies have been provided already by ourselves, it should not # attempt to install them again, which is good, because we want to make # it Nix's responsibility. If it needs to install any dependencies # anyway (e.g. because the dependency parameters are # incomplete/incorrect), it fails. # # The other responsibilities of NPM are kept -- version checks, build # steps, postprocessing etc.
export HOME=$TMPDIR cd "${packageName}" runHook preRebuild
${lib.optionalString bypassCache '' ${lib.optionalString reconstructLock '' if [ -f package-lock.json ] then echo "WARNING: Reconstruct lock option enabled, but a lock file already exists!" echo "This will most likely result in version mismatches! We will remove the lock file and regenerate it!" rm package-lock.json else echo "No package-lock.json file found, reconstructing..." fi
node ${reconstructPackageLock} ''}
node ${addIntegrityFieldsScript} ''}
npm ${forceOfflineFlag} --nodedir=${nodeSources} ${npmFlags} ${lib.optionalString production "--production"} rebuild
if [ "''${dontNpmInstall-}" != "1" ] then # NPM tries to download packages even when they already exist if npm-shrinkwrap is used. rm -f npm-shrinkwrap.json
npm ${forceOfflineFlag} --nodedir=${nodeSources} ${npmFlags} ${lib.optionalString production "--production"} install fi '';
# Builds and composes an NPM package including all its dependencies buildNodePackage = { name, packageName, version ? null, dependencies ? [], buildInputs ? [], production ? true, npmFlags ? "", dontNpmInstall ? false, bypassCache ? false, reconstructLock ? false, preRebuild ? "", dontStrip ? true, unpackPhase ? "true", buildPhase ? "true", meta ? {}, ... } @ args: let extraArgs = removeAttrs args ["name" "dependencies" "buildInputs" "dontStrip" "dontNpmInstall" "preRebuild" "unpackPhase" "buildPhase" "meta"]; in stdenv.mkDerivation ({ name = "${name}${ if version == null then "" else "-${version}" }"; buildInputs = [tarWrapper python nodejs] ++ lib.optional (stdenv.isLinux) utillinux ++ lib.optional (stdenv.isDarwin) libtool ++ buildInputs;
inherit nodejs;
inherit dontStrip; # Stripping may fail a build for some package deployments inherit dontNpmInstall preRebuild unpackPhase buildPhase;
compositionScript = composePackage args; pinpointDependenciesScript = pinpointDependenciesOfPackage args;
passAsFile = ["compositionScript" "pinpointDependenciesScript"];
installPhase = '' source ${installPackage}
# Create and enter a root node_modules/ folder mkdir -p $out/lib/node_modules cd $out/lib/node_modules
# Compose the package and all its dependencies source $compositionScriptPath
${prepareAndInvokeNPM {inherit packageName bypassCache reconstructLock npmFlags production;}}
# Create symlink to the deployed executable folder, if applicable if [ -d "$out/lib/node_modules/.bin" ] then ln -s $out/lib/node_modules/.bin $out/bin
# Patch the shebang lines of all the executables ls $out/bin/* | while read i do file="$(readlink -f "$i")" chmod u+rwx "$file" patchShebangs "$file" done fi
# Create symlinks to the deployed manual page folders, if applicable if [ -d "$out/lib/node_modules/${packageName}/man" ] then mkdir -p $out/share for dir in "$out/lib/node_modules/${packageName}/man/"* do mkdir -p $out/share/man/$(basename "$dir") for page in "$dir"/* do ln -s $page $out/share/man/$(basename "$dir") done done fi
# Run post install hook, if provided runHook postInstall '';
meta = { # default to Node.js' platforms platforms = nodejs.meta.platforms; } // meta; } // extraArgs);
# Builds a node environment (a node_modules folder and a set of binaries) buildNodeDependencies = { name, packageName, version ? null, src, dependencies ? [], buildInputs ? [], production ? true, npmFlags ? "", dontNpmInstall ? false, bypassCache ? false, reconstructLock ? false, dontStrip ? true, unpackPhase ? "true", buildPhase ? "true", ... } @ args: let extraArgs = removeAttrs args ["name" "dependencies" "buildInputs"]; in stdenv.mkDerivation ({ name = "node-dependencies-${name}${ if version == null then "" else "-${version}" }";
buildInputs = [tarWrapper python nodejs] ++ lib.optional (stdenv.isLinux) utillinux ++ lib.optional (stdenv.isDarwin) libtool ++ buildInputs;
inherit dontStrip; # Stripping may fail a build for some package deployments inherit dontNpmInstall unpackPhase buildPhase;
includeScript = includeDependencies {inherit dependencies;}; pinpointDependenciesScript = pinpointDependenciesOfPackage args;
passAsFile = ["includeScript" "pinpointDependenciesScript"];
installPhase = '' source ${installPackage}
mkdir -p $out/${packageName} cd $out/${packageName}
source $includeScriptPath
# Create fake package.json to make the npm commands work properly cp ${src}/package.json . chmod 644 package.json ${lib.optionalString bypassCache '' if [ -f ${src}/package-lock.json ] then cp ${src}/package-lock.json . chmod 644 package-lock.json fi ''}
# Go to the parent folder to make sure that all packages are pinpointed cd .. ${lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."}
${prepareAndInvokeNPM {inherit packageName bypassCache reconstructLock npmFlags production;}}
# Expose the executables that were installed cd .. ${lib.optionalString (builtins.substring 0 1 packageName == "@") "cd .."}
mv ${packageName} lib ln -s $out/lib/node_modules/.bin $out/bin ''; } // extraArgs);
# Builds a development shell buildNodeShell = { name, packageName, version ? null, src, dependencies ? [], buildInputs ? [], production ? true, npmFlags ? "", dontNpmInstall ? false, bypassCache ? false, reconstructLock ? false, dontStrip ? true, unpackPhase ? "true", buildPhase ? "true", ... } @ args: let nodeDependencies = buildNodeDependencies args; extraArgs = removeAttrs args ["name" "dependencies" "buildInputs" "dontStrip" "dontNpmInstall" "unpackPhase" "buildPhase"]; in stdenv.mkDerivation ({ name = "node-shell-${name}${ if version == null then "" else "-${version}" }";
buildInputs = [python nodejs] ++ lib.optional (stdenv.isLinux) utillinux ++ buildInputs; buildCommand = '' mkdir -p $out/bin cat > $out/bin/shell <<EOF #! ${stdenv.shell} -e $shellHook exec ${stdenv.shell} EOF chmod +x $out/bin/shell '';
# Provide the dependencies in a development shell through the NODE_PATH environment variable inherit nodeDependencies; shellHook = lib.optionalString (dependencies != []) '' export NODE_PATH=${nodeDependencies}/lib/node_modules export PATH="${nodeDependencies}/bin:$PATH" ''; } // extraArgs);in { buildNodeSourceDist = lib.makeOverridable buildNodeSourceDist; buildNodePackage = lib.makeOverridable buildNodePackage; buildNodeDependencies = lib.makeOverridable buildNodeDependencies; buildNodeShell = lib.makeOverridable buildNodeShell;}