diff --git a/example-deployments/hydra/processes.nix b/example-deployments/hydra/processes.nix index 7851f5b..3a2890d 100644 --- a/example-deployments/hydra/processes.nix +++ b/example-deployments/hydra/processes.nix @@ -4,15 +4,17 @@ , runtimeDir ? "${stateDir}/run" , logDir ? "${stateDir}/log" , cacheDir ? "${stateDir}/cache" +, spoolDir ? "${stateDir}/spool" , libDir ? "${stateDir}/lib" , tmpDir ? (if stateDir == "/var" then "/tmp" else "${stateDir}/tmp") , forceDisableUserChange ? false , processManager +, includeNixDaemon ? false }: let constructors = import ../../services-agnostic/constructors.nix { - inherit pkgs stateDir runtimeDir logDir tmpDir cacheDir libDir forceDisableUserChange processManager; + inherit pkgs stateDir runtimeDir logDir tmpDir cacheDir spoolDir libDir forceDisableUserChange processManager; }; instanceSuffix = ""; @@ -20,12 +22,15 @@ let hydraInstanceName = "hydra${instanceSuffix}"; hydraQueueRunnerUser = "hydra-queue-runner${instanceSuffix}"; hydraServerUser = "hydra-www${instanceSuffix}"; -in -rec { - nix-daemon = { - pkg = constructors.nix-daemon; - }; + # This process needs to be conditionally included + nix-daemon = if includeNixDaemon then { + pkg = constructors.nix-daemon; + } else null; +in +pkgs.lib.optionalAttrs includeNixDaemon { + inherit nix-daemon; +} // rec { postgresql = rec { port = 5432; postgresqlUsername = "postgresql"; @@ -54,7 +59,7 @@ rec { port = 3000; hydraDatabase = hydraInstanceName; hydraGroup = hydraInstanceName; - baseDir = "${stateDir}/lib/${hydraInstanceName}"; + baseDir = "${libDir}/${hydraInstanceName}"; inherit hydraUser instanceSuffix; pkg = constructors.hydra-server { @@ -67,6 +72,7 @@ rec { hydra-evaluator = { pkg = constructors.hydra-evaluator { inherit nix-daemon hydra-server; + postgresqlDBMS = postgresql; }; }; @@ -74,11 +80,14 @@ rec { pkg = constructors.hydra-queue-runner { inherit nix-daemon hydra-server; user = hydraQueueRunnerUser; + postgresqlDBMS = postgresql; }; }; - apache = { + apache = rec { + port = 80; pkg = constructors.reverseProxyApache { + inherit port; dependency = hydra-server; serverAdmin = "admin@localhost"; }; diff --git a/services-agnostic/constructors.nix b/services-agnostic/constructors.nix index 67c25ea..a4c1747 100644 --- a/services-agnostic/constructors.nix +++ b/services-agnostic/constructors.nix @@ -81,6 +81,7 @@ in hydra-evaluator = import ./hydra/hydra-evaluator.nix { inherit createManagedProcess; + inherit (pkgs) lib; hydra = pkgs.hydra-unstable; }; diff --git a/services-agnostic/hydra/generate-env-vars.nix b/services-agnostic/hydra/generate-env-vars.nix index a8a63b0..fa5ee5f 100644 --- a/services-agnostic/hydra/generate-env-vars.nix +++ b/services-agnostic/hydra/generate-env-vars.nix @@ -8,5 +8,6 @@ in HYDRA_CONFIG = "${baseDir}/hydra.conf"; HYDRA_DATA = baseDir; NIX_REMOTE = "daemon"; + HOME = baseDir; # Add this to prevent the evaluator and queue runner to read from /root/.nix-defexpr PGPASSFILE = "${baseDir}/pgpass"; } diff --git a/services-agnostic/hydra/hydra-evaluator.nix b/services-agnostic/hydra/hydra-evaluator.nix index 27a7976..c4d75d7 100644 --- a/services-agnostic/hydra/hydra-evaluator.nix +++ b/services-agnostic/hydra/hydra-evaluator.nix @@ -1,5 +1,5 @@ -{createManagedProcess, hydra}: -{nix-daemon, hydra-server}: +{createManagedProcess, lib, hydra}: +{nix-daemon ? null, hydra-server, postgresqlDBMS ? null}: let instanceName = "hydra-evaluator${hydra-server.instanceSuffix}"; @@ -9,12 +9,35 @@ in createManagedProcess { inherit instanceName; - dependencies = [ nix-daemon.pkg hydra-server.pkg ]; + dependencies = [ hydra-server.pkg ] + ++ lib.optional (nix-daemon != null) nix-daemon.pkg + ++ lib.optional (postgresqlDBMS != null) postgresqlDBMS.pkg; path = [ hydra ]; environment = import ./generate-env-vars.nix { inherit (hydra-server) baseDir hydraDatabase hydraUser; }; directory = hydra-server.baseDir; + initialize = lib.optionalString (postgresqlDBMS != null) '' + count=1 + + while [ $count -lt 10 ] + do + if [ -e "${hydra-server.baseDir}/.db-created" ] + then + found=1 + break + fi + + echo "Waiting for the Hydra database to get created..." >&2 + sleep 1 + done + + if [ "$found" != "1" ] + then + echo "ERROR: Database was still not created!" >&2 + exit 1 + fi + ''; foregroundProcess = "${hydra}/bin/hydra-evaluator"; user = hydra-server.hydraUser; diff --git a/services-agnostic/hydra/hydra-queue-runner.nix b/services-agnostic/hydra/hydra-queue-runner.nix index ffe480c..a6cef94 100644 --- a/services-agnostic/hydra/hydra-queue-runner.nix +++ b/services-agnostic/hydra/hydra-queue-runner.nix @@ -1,5 +1,5 @@ {createManagedProcess, lib, hydra, nix, forceDisableUserChange}: -{nix-daemon, hydra-server, user ? null}: +{nix-daemon ? null, hydra-server, user ? null, postgresqlDBMS ? null}: # TODO: execStopPost: /bin/hydra-queue-runner --unlock @@ -19,23 +19,48 @@ createManagedProcess { user = _user; path = [ nix ]; directory = queueRunnerBaseDir; + initialize = '' - mkdir -m 0700 -p ${queueRunnerBaseDir} mkdir -m 0750 -p ${hydra-server.baseDir}/build-logs - ${lib.optionalString (!forceDisableUserChange) '' - chown ${user}:${hydra-server.hydraGroup} ${queueRunnerBaseDir} ${hydra-server.baseDir}/build-logs - ''} + '' + + lib.optionalString (!forceDisableUserChange) '' + chown ${_user}:${hydra-server.hydraGroup} ${queueRunnerBaseDir} ${hydra-server.baseDir}/build-logs + '' + # Wait for the database to be created before starting + + lib.optionalString (postgresqlDBMS != null) '' + count=1 + + while [ $count -lt 10 ] + do + if [ -e "${hydra-server.baseDir}/.db-created" ] + then + found=1 + break + fi + + echo "Waiting for the Hydra database to get created..." >&2 + sleep 1 + done + + if [ "$found" != "1" ] + then + echo "ERRORDatabase was still not created!" >&2 + exit 1 + fi ''; foregroundProcess = "${hydra}/bin/hydra-queue-runner"; args = [ "-v" ]; - dependencies = [ nix-daemon.pkg hydra-server.pkg ]; + dependencies = [ hydra-server.pkg ] + ++ lib.optional (nix-daemon != null) nix-daemon + ++ lib.optional (postgresqlDBMS != null) postgresqlDBMS.pkg; credentials = { users = { - "${user}" = { + "${_user}" = { group = hydra-server.hydraGroup; description = "Hydra queue runner"; homeDir = queueRunnerBaseDir; + createHomeDir = true; shell = "/bin/sh"; }; }; @@ -49,9 +74,7 @@ createManagedProcess { Service = { Restart = "always"; LimitCORE = "infinity"; - Environment = { - IN_SYSTEMD = "1"; - }; + "Environment=IN_SYSTEMD" = "1"; }; }; }; diff --git a/services-agnostic/hydra/hydra-server.nix b/services-agnostic/hydra/hydra-server.nix index a7b27b9..fcb83a7 100644 --- a/services-agnostic/hydra/hydra-server.nix +++ b/services-agnostic/hydra/hydra-server.nix @@ -20,7 +20,7 @@ , useSubstitutes ? true , postgresqlDBMS ? null -, nix-daemon +, nix-daemon ? null }: let @@ -32,9 +32,11 @@ let notification_sender = ${notificationSender} max_servers = 25 compress_num_threads = 0 - ${lib.optionalString (logo != null) '' - hydra_logo = ${logo} - ''} + '' + + lib.optionalString (logo != null) '' + hydra_logo = ${logo} + '' + + '' gc_roots_dir = ${gcRootsDir} use-substitutes = ${if useSubstitutes then "1" else "0"} ''; @@ -47,35 +49,37 @@ createManagedProcess { initialize = '' ln -sfn ${hydraConf} ${baseDir}/hydra.conf + chmod 750 ${baseDir} mkdir -m 0700 -p ${baseDir}/www mkdir -p ${gcRootsDir} - - ${lib.optionalString (!forceDisableUserChange) '' - chown ${user}:${hydraGroup} ${baseDir}/www - chown ${hydraUser}:${hydraGroup} ${gcRootsDir} - ''} - + '' + + lib.optionalString (!forceDisableUserChange) '' + chown ${user}:${hydraGroup} ${baseDir}/www + chown ${hydraUser}:${hydraGroup} ${gcRootsDir} + '' + + '' chmod 2775 ${gcRootsDir} + '' + # Initialize the database if a PostgreSQL DBMS is provided as a (local) process dependency + + lib.optionalString (postgresqlDBMS != null) '' + if [ ! -e ${baseDir}/.db-created ] + then + count=1 - ${lib.optionalString (postgresqlDBMS != null) '' - if [ ! -e ${baseDir}/.db-created ] - then - count=1 - - while [ ! -e ${postgresqlDBMS.socketFile} ] && [ $count -lt 10 ] - do - sleep 1 - ((count++)) - done - - ${lib.optionalString (!forceDisableUserChange) "su ${postgresqlDBMS.postgresqlUsername} -c '"}createuser ${hydraUser}${lib.optionalString (!forceDisableUserChange) "'"} - ${lib.optionalString (!forceDisableUserChange) "su ${postgresqlDBMS.postgresqlUsername} -c '"}createdb -O ${hydraUser} ${hydraDatabase}${lib.optionalString (!forceDisableUserChange) "'"} - echo "create extension if not exists pg_trgm" | ${lib.optionalString (!forceDisableUserChange) "su ${postgresqlDBMS.postgresqlUsername} -c '"}psql ${hydraDatabase}${lib.optionalString (!forceDisableUserChange) "'"} - touch ${baseDir}/.db-created - fi - ''} + while [ ! -e ${postgresqlDBMS.socketFile} ] && [ $count -lt 10 ] + do + sleep 1 + ((count++)) + done + ${lib.optionalString (!forceDisableUserChange) "su ${postgresqlDBMS.postgresqlUsername} -c '"}${postgresql}/bin/createuser ${hydraUser}${lib.optionalString (!forceDisableUserChange) "'"} + ${lib.optionalString (!forceDisableUserChange) "su ${postgresqlDBMS.postgresqlUsername} -c '"}${postgresql}/bin/createdb -O ${hydraUser} ${hydraDatabase}${lib.optionalString (!forceDisableUserChange) "'"} + echo "create extension if not exists pg_trgm" | ${lib.optionalString (!forceDisableUserChange) "su ${postgresqlDBMS.postgresqlUsername} -c '"}${postgresql}/bin/psql ${hydraDatabase}${lib.optionalString (!forceDisableUserChange) "'"} + touch ${baseDir}/.db-created + fi + '' + + '' ${hydra}/bin/hydra-init ''; foregroundProcess = "${hydra}/bin/hydra-server"; @@ -85,7 +89,8 @@ createManagedProcess { inherit baseDir dbi hydraDatabase hydraUser; }; - dependencies = [ nix-daemon.pkg ] ++ lib.optional (postgresqlDBMS != null) postgresqlDBMS.pkg; + dependencies = lib.optional (nix-daemon != null) nix-daemon.pkg + ++ lib.optional (postgresqlDBMS != null) postgresqlDBMS.pkg; credentials = { groups = { diff --git a/tests/default.nix b/tests/default.nix index 3e3d2ce..429d9f4 100644 --- a/tests/default.nix +++ b/tests/default.nix @@ -31,6 +31,10 @@ in inherit pkgs processManagers profiles testService; }; + hydra = import ./hydra { + inherit pkgs processManagers profiles testService; + }; + influxdb = import ./influxdb { inherit pkgs processManagers profiles testService; }; diff --git a/tests/hydra/default.nix b/tests/hydra/default.nix new file mode 100644 index 0000000..6f5f7ef --- /dev/null +++ b/tests/hydra/default.nix @@ -0,0 +1,165 @@ +{ pkgs, testService, processManagers, profiles }: + +let + node-hydra-connector = (import ./nodepkgs { + inherit pkgs; + inherit (pkgs.stdenv) system; + }).node-hydra-connector; + + loginParams = pkgs.writeTextFile { + name = "loginparams"; + text = '' + admin + admin + ''; + }; + + projectParams = pkgs.writeTextFile { + name = "projectparams"; + text = '' + trivial + Trivial + Trivial project + + 1 + 1 + ''; + }; + + generateTrivialProject = pkgs.writeScriptBin "generate-trivial-project" '' + #! ${pkgs.stdenv.shell} -e + mkdir -p /tmp/project + cat > /tmp/project/release.nix < $out; exit 0"]; + }; + } + EOF + ''; + + jobsetParams = pkgs.writeTextFile { + name = "jobsetparams"; + text = '' + main + Main jobset + projectPath + release.nix + admin@localhost + 1 + 1 + 1 + 1 + 1 + projectPath + path + /tmp/project + ''; + }; +in +testService { + exprFile = ../../example-deployments/hydra/processes.nix; + nixosConfig = { + virtualisation.memorySize = 1024; + virtualisation.diskSize = 8192; + virtualisation.writableStore = true; + }; + systemPackages = [ pkgs.hydra-unstable node-hydra-connector generateTrivialProject ]; + + readiness = {instanceName, instance, ...}: + pkgs.lib.optionalString (instanceName == "postgresql" || instanceName == "hydra-server" || instanceName == "apache") '' + machine.wait_for_open_port(${toString instance.port}) + ''; + + postTests = {...}: + '' + import json + import re + + # Create admin user + machine.succeed("su - hydra -c 'hydra-create-user admin --role admin --password admin'") + + # Login as admin user and extract session environment variable + loginOutput = machine.succeed( + "cat ${loginParams} | hydra-connect --url http://localhost --login" + ) + + sessionEnvVar = re.search("HYDRA_SESSION=[0-9a-zA-Z]*", loginOutput).group(0) + + # Create a project + machine.succeed( + "cat ${projectParams} | " + + sessionEnvVar + + " hydra-connect --url http://localhost --project trivial --modify >&2" + ) + + machine.succeed(sessionEnvVar + " hydra-connect --url http://localhost --projects >&2") + + # Create a jobset + machine.succeed("generate-trivial-project") + + machine.succeed( + "(cat ${jobsetParams}; sleep 3; echo; echo; echo) | " + + sessionEnvVar + + " hydra-connect --url http://localhost --project trivial --jobset main --modify >&2" + ) + + machine.succeed( + sessionEnvVar + " hydra-connect --url http://localhost --project trivial >&2" + ) + + # Wait for an evaluation to appear + + count = 0 + + while True: + machine.succeed("sleep 1") + + evalsOutput = machine.succeed( + sessionEnvVar + + " hydra-connect --url http://localhost --project trivial --jobset main --evals --json" + ) + evalsObj = json.loads(evalsOutput) + + count += 1 + + if len(evalsObj["evals"]) > 0: + break + elif count == 10: + raise Exception("Maximum number of 10 tries reached!") + + machine.succeed( + sessionEnvVar + + " hydra-connect --url http://localhost --project trivial --jobset main --evals >&2" + ) + + # Check properties of the build + + machine.succeed( + sessionEnvVar + + " hydra-connect --url http://localhost --project trivial --jobset main --build 1 >&2" + ) + + buildOutput = machine.succeed( + sessionEnvVar + + " hydra-connect --url http://localhost --project trivial --jobset main --build 1 --json" + ) + buildObj = json.loads(buildOutput) + + if buildObj["buildoutputs"]["out"]["path"].startswith("/nix/store/"): + print("Found output path: {}".format(buildObj["buildoutputs"]["out"]["path"])) + else: + raise Exception("No output path found!") + + machine.succeed( + sessionEnvVar + + " hydra-connect --url http://localhost --project trivial --jobset main --build 1 --raw-log >&2" + ) + ''; + + inherit processManagers profiles; +} diff --git a/tests/hydra/nodepkgs/default.nix b/tests/hydra/nodepkgs/default.nix new file mode 100644 index 0000000..64326c6 --- /dev/null +++ b/tests/hydra/nodepkgs/default.nix @@ -0,0 +1,17 @@ +# This file has been generated by node2nix 1.9.0. Do not edit! + +{pkgs ? import { + inherit system; + }, system ? builtins.currentSystem, nodejs ? pkgs."nodejs-12_x"}: + +let + nodeEnv = import ./node-env.nix { + inherit (pkgs) stdenv lib python2 runCommand writeTextFile; + inherit pkgs nodejs; + libtool = if pkgs.stdenv.isDarwin then pkgs.darwin.cctools else null; + }; +in +import ./node-packages.nix { + inherit (pkgs) fetchurl nix-gitignore stdenv lib fetchgit; + inherit nodeEnv; +} diff --git a/tests/hydra/nodepkgs/generate.sh b/tests/hydra/nodepkgs/generate.sh new file mode 100755 index 0000000..8bddd98 --- /dev/null +++ b/tests/hydra/nodepkgs/generate.sh @@ -0,0 +1,3 @@ +#!/bin/sh -e + +node2nix -12 -i nodepkgs.json diff --git a/tests/hydra/nodepkgs/node-env.nix b/tests/hydra/nodepkgs/node-env.nix new file mode 100644 index 0000000..c2b7231 --- /dev/null +++ b/tests/hydra/nodepkgs/node-env.nix @@ -0,0 +1,567 @@ +# This file originates from node2nix + +{lib, stdenv, nodejs, python2, pkgs, libtool, runCommand, writeTextFile}: + +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 <> $out/nix-support/hydra-build-products + ''; + }; + + includeDependencies = {dependencies}: + lib.optionalString (dependencies != []) + (lib.concatMapStrings (dependency: + '' + # Bundle the dependencies of the package + mkdir -p node_modules + cd node_modules + + # Only include dependencies if they don't exist. They may also be bundled in the package. + if [ ! -e "${dependency.name}" ] + then + ${composePackage dependency} + fi + + cd .. + '' + ) dependencies); + + # Recursively composes the dependencies of a package + composePackage = { name, packageName, src, dependencies ? [], ... }@args: + builtins.addErrorContext "while evaluating node package '${packageName}'" '' + 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 + + # Unset the stripped name to not confuse the next unpack step + unset strippedName + + # Include the dependencies of the package + cd "$DIR/${packageName}" + ${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 + , dependencies ? [] + , buildInputs ? [] + , production ? true + , npmFlags ? "" + , dontNpmInstall ? false + , bypassCache ? false + , reconstructLock ? false + , preRebuild ? "" + , dontStrip ? true + , unpackPhase ? "true" + , buildPhase ? "true" + , ... }@args: + + let + extraArgs = removeAttrs args [ "name" "dependencies" "buildInputs" "dontStrip" "dontNpmInstall" "preRebuild" "unpackPhase" "buildPhase" ]; + in + stdenv.mkDerivation ({ + name = "node_${name}-${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 = '' + # 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 + 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 + ''; + } // extraArgs); + + # Builds a node environment (a node_modules folder and a set of binaries) + buildNodeDependencies = + { name + , packageName + , version + , 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}-${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 = '' + 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 . + 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 + , src + , dependencies ? [] + , buildInputs ? [] + , production ? true + , npmFlags ? "" + , dontNpmInstall ? false + , bypassCache ? false + , reconstructLock ? false + , dontStrip ? true + , unpackPhase ? "true" + , buildPhase ? "true" + , ... }@args: + + let + nodeDependencies = buildNodeDependencies args; + in + stdenv.mkDerivation { + name = "node-shell-${name}-${version}"; + + buildInputs = [ python nodejs ] ++ lib.optional (stdenv.isLinux) utillinux ++ buildInputs; + buildCommand = '' + mkdir -p $out/bin + cat > $out/bin/shell <