From 7684bc838b623ea2ac44f7b87f7ea16c252f2830 Mon Sep 17 00:00:00 2001 From: Carsten Kragelund Date: Mon, 8 May 2023 04:50:12 +0200 Subject: [PATCH] Prayge for working CI now --- .github/workflows/build.yml | 17 +- default.nix | 11 +- pkgs/emacs-packages/default.nix | 2 +- pkgs/gitea-nyx/build.nix | 9 +- pkgs/gitea-nyx/node.nix | 27 - pkgs/gitea-nyx/node/default.nix | 17 + pkgs/gitea-nyx/node/node-env.nix | 689 +++++ pkgs/gitea-nyx/node/node-packages.nix | 3887 +++++++++++++++++++++++++ pkgs/rec-mono-nyx/default.nix | 30 +- pkgs/rec-mono-nyx/py/default.nix | 234 ++ 10 files changed, 4868 insertions(+), 55 deletions(-) delete mode 100644 pkgs/gitea-nyx/node.nix create mode 100644 pkgs/gitea-nyx/node/default.nix create mode 100644 pkgs/gitea-nyx/node/node-env.nix create mode 100644 pkgs/gitea-nyx/node/node-packages.nix create mode 100644 pkgs/rec-mono-nyx/py/default.nix diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index f9134e8..7e25220 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -6,8 +6,8 @@ on: - main - master schedule: - # rebuild everyday at 2:51 - # TIP: Choose a random time here so not all repositories are build at once: + # rebuild everyday at 1:50 + # [X] TIP: Choose a random time here so not all repositories are build at once: # https://www.random.org/clock-times/?num=1&earliest=01%3A00&latest=08%3A00&interval=5&format=html&rnd=new - cron: '50 1 * * *' jobs: @@ -35,7 +35,7 @@ jobs: - sanctureplicum nixPath: - nixpkgs=channel:nixos-unstable - - nixpkgs=channel:nixpkgs-unstable + # - nixpkgs=channel:nixpkgs-unstable # FIXME: Gitea on stable is using different patches. # - nixpkgs=channel:nixos-22.11 runs-on: ubuntu-latest @@ -59,9 +59,20 @@ jobs: name: ${{ matrix.cachixName }} signingKey: '${{ secrets.CACHIX_SIGNING_KEY }}' authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}' + + - name: Check evaluation + run: | + nix-env -f . -qa \* \ + --allowed-uris https://static.rust-lang.org \ + --option restrict-eval true \ + --option allow-import-from-derivation true \ + --drv-path --show-trace \ + -I nixpkgs=$(nix-instantiate --find-file nixpkgs) \ + -I $PWD - name: Build nix packages run: nix shell -f '' nix-build-uncached -c nix-build-uncached ci.nix -A cacheOutputs - name: Trigger NUR update # Don't replace here! if: ${{ matrix.nurRepo != '' }} run: curl -XPOST "https://nur-update.nix-community.org/update?repo=${{ matrix.nurRepo }}" + diff --git a/default.nix b/default.nix index cecb8cf..44d1c05 100644 --- a/default.nix +++ b/default.nix @@ -6,12 +6,14 @@ # commands such as: # nix-build -A mypackage + + { pkgs ? import { } , system ? builtins.currentSystem -, mach-nixpkgs ? import (builtins.fetchTarball "https://github.com/nixos/nixpkgs/archive/9fd0585f7dc9b85eb5d426396004cc649261e60d.tar.gz") {} -, mach-nix ? import (builtins.fetchTarball "https://github.com/davhau/mach-nix/archive/6cd3929b1561c3eef68f5fc6a08b57cf95c41ec1.tar.gz") { +, mach-nixpkgs ? import (builtins.fetchTarball { url = "https://github.com/nixos/nixpkgs/archive/9fd0585f7dc9b85eb5d426396004cc649261e60d.tar.gz"; sha256 = "sha256:0xl9mc0p63jr490hnrmlky7rm13f7zmp2hp1d9bjfyrbwafsg4dv"; }) {} +, mach-nix ? import (builtins.fetchTarball { url = "https://github.com/davhau/mach-nix/archive/6cd3929b1561c3eef68f5fc6a08b57cf95c41ec1.tar.gz"; sha256 = "sha256:1a0gny4nlq39nyhgn94kl4rhmzax3h8xyh0jl7wrv0rzg38zf705"; }) { pkgs = mach-nixpkgs; - pypiData = builtins.fetchTarball "https://github.com/davhau/pypi-deps-db/archive/e9571cac25d2f509e44fec9dc94a3703a40126ff.tar.gz"; + pypiData = builtins.fetchTarball { url = "https://github.com/davhau/pypi-deps-db/archive/e9571cac25d2f509e44fec9dc94a3703a40126ff.tar.gz"; sha256 = "sha256:1rbb0yx5kjn0j6lk0ml163227swji8abvq0krynqyi759ixirxd5"; }; } }: { # The `lib`, `modules`, and `overlay` names are special @@ -22,5 +24,6 @@ firefox-addons = pkgs.recurseIntoAttrs (pkgs.callPackage ./pkgs/firefox-addons { }); gitea-nyx = import ./pkgs/gitea-nyx { inherit pkgs; }; emacsPackages = pkgs.recurseIntoAttrs (pkgs.callPackage ./pkgs/emacs-packages { }); - rec-mono-nyx = import ./pkgs/rec-mono-nyx { inherit mach-nix mach-nixpkgs system pkgs; }; + rec-mono-nyx = pkgs.callPackage ./pkgs/rec-mono-nyx { inherit mach-nix mach-nixpkgs system; }; + libspectre = pkgs.callPackage ./pkgs/libspectre { }; } diff --git a/pkgs/emacs-packages/default.nix b/pkgs/emacs-packages/default.nix index ab224ea..9323bad 100644 --- a/pkgs/emacs-packages/default.nix +++ b/pkgs/emacs-packages/default.nix @@ -1,3 +1,3 @@ { pkgs, ... }: { - spectre-el = import ./spectre-el.nix; + spectre-el = pkgs.callPackage ./spectre-el.nix {}; } \ No newline at end of file diff --git a/pkgs/gitea-nyx/build.nix b/pkgs/gitea-nyx/build.nix index d578797..5b2a3bc 100644 --- a/pkgs/gitea-nyx/build.nix +++ b/pkgs/gitea-nyx/build.nix @@ -1,12 +1,7 @@ { pkgs, giteaVersion, ... }: let - src = pkgs.fetchgit { - url = "https://gitea.pid1.sh/sanctureplicum/gitea.git"; - rev = "refs/tags/${giteaVersion}"; - hash = "sha256-KQEBq1BFQRLJW9fJq4W1sOsAqOCfNHKY/+cT8rkXxv4="; - }; - nodeNix = (import ./node.nix { inherit pkgs giteaVersion src; }); - nodeEnv = (pkgs.callPackage (nodeNix + "/default.nix") { }); + src = pkgs.fetchgit { url = "https://gitea.pid1.sh/sanctureplicum/gitea.git"; rev = "refs/tags/${giteaVersion}"; hash = "sha256-KQEBq1BFQRLJW9fJq4W1sOsAqOCfNHKY/+cT8rkXxv4="; }; + nodeEnv = (pkgs.callPackage ./node { }); in pkgs.buildGoModule rec { pname = "gitea-build"; diff --git a/pkgs/gitea-nyx/node.nix b/pkgs/gitea-nyx/node.nix deleted file mode 100644 index cee0791..0000000 --- a/pkgs/gitea-nyx/node.nix +++ /dev/null @@ -1,27 +0,0 @@ -{ pkgs, giteaVersion, ... }: -let - escapeSlash = str: builtins.replaceStrings [ "/" ] [ "\\/"] str; -in -pkgs.stdenv.mkDerivation rec { - pname = "gitea-node-env"; - version = "${giteaVersion}-nyx"; - - src = pkgs.fetchgit { - url = "https://gitea.pid1.sh/sanctureplicum/gitea.git"; - rev = "refs/tags/${giteaVersion}"; - hash = "sha256-KQEBq1BFQRLJW9fJq4W1sOsAqOCfNHKY/+cT8rkXxv4="; - }; - - nativeBuildInputs = [ pkgs.node2nix ]; - - buildPhase = '' - mkdir nix - node2nix -i ${src}/package.json -l ${src}/package-lock.json - sed -r -i 's/src = .+?nix\/store.+?;/src = fetchgit { url = "${escapeSlash src.url}"; rev = "${escapeSlash src.rev}"; hash = "${escapeSlash src.outputHash}"; };/' node-packages.nix - ''; - - installPhase = '' - mkdir $out - cp *.nix $out - ''; -} \ No newline at end of file diff --git a/pkgs/gitea-nyx/node/default.nix b/pkgs/gitea-nyx/node/default.nix new file mode 100644 index 0000000..b795f70 --- /dev/null +++ b/pkgs/gitea-nyx/node/default.nix @@ -0,0 +1,17 @@ +# This file has been generated by node2nix 1.11.1. Do not edit! + +{pkgs ? import { + inherit system; + }, system ? builtins.currentSystem, nodejs ? pkgs."nodejs_14"}: + +let + nodeEnv = import ./node-env.nix { + inherit (pkgs) stdenv lib python2 runCommand writeTextFile writeShellScript; + 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/pkgs/gitea-nyx/node/node-env.nix b/pkgs/gitea-nyx/node/node-env.nix new file mode 100644 index 0000000..bc1e366 --- /dev/null +++ b/pkgs/gitea-nyx/node/node-env.nix @@ -0,0 +1,689 @@ +# 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 <> $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); + } + else { + packageObj.devDependencies = {}; + } + replaceDependencies(packageObj.optionalDependencies); + replaceDependencies(packageObj.peerDependencies); + + /* 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 = "reconstructpackagelock.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: 2, + requires: true, + packages: { + "": { + name: packageObj.name, + version: packageObj.version, + license: packageObj.license, + bin: packageObj.bin, + dependencies: packageObj.dependencies, + engines: packageObj.engines, + optionalDependencies: packageObj.optionalDependencies + } + }, + dependencies: {} + }; + + function augmentPackageJSON(filePath, packages, dependencies) { + var packageJSON = path.join(filePath, "package.json"); + if(fs.existsSync(packageJSON)) { + var packageObj = JSON.parse(fs.readFileSync(packageJSON)); + packages[filePath] = { + version: packageObj.version, + integrity: "sha1-000000000000000000000000000=", + dependencies: packageObj.dependencies, + engines: packageObj.engines, + optionalDependencies: packageObj.optionalDependencies + }; + dependencies[packageObj.name] = { + version: packageObj.version, + integrity: "sha1-000000000000000000000000000=", + dependencies: {} + }; + processDependencies(path.join(filePath, "node_modules"), packages, dependencies[packageObj.name].dependencies); + } + } + + function processDependencies(dir, packages, 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, packages, dependencies); + } + }); + } else { + augmentPackageJSON(filePath, packages, dependencies); + } + } + }); + } + } + + processDependencies("node_modules", lockObj.packages, lockObj.dependencies); + + fs.writeFileSync("package-lock.json", JSON.stringify(lockObj, null, 2)); + ''; + }; + + # Script that links bins defined in package.json to the node_modules bin directory + # NPM does not do this for top-level packages itself anymore as of v7 + linkBinsScript = writeTextFile { + name = "linkbins.js"; + text = '' + var fs = require('fs'); + var path = require('path'); + + var packageObj = JSON.parse(fs.readFileSync("package.json")); + + var nodeModules = Array(packageObj.name.split("/").length).fill("..").join(path.sep); + + if(packageObj.bin !== undefined) { + fs.mkdirSync(path.join(nodeModules, ".bin")) + + if(typeof packageObj.bin == "object") { + Object.keys(packageObj.bin).forEach(function(exe) { + if(fs.existsSync(packageObj.bin[exe])) { + console.log("linking bin '" + exe + "'"); + fs.symlinkSync( + path.join("..", packageObj.name, packageObj.bin[exe]), + path.join(nodeModules, ".bin", exe) + ); + } + else { + console.log("skipping non-existent bin '" + exe + "'"); + } + }) + } + else { + if(fs.existsSync(packageObj.bin)) { + console.log("linking bin '" + packageObj.bin + "'"); + fs.symlinkSync( + path.join("..", packageObj.name, packageObj.bin), + path.join(nodeModules, ".bin", packageObj.name.split("/").pop()) + ); + } + else { + console.log("skipping non-existent bin '" + packageObj.bin + "'"); + } + } + } + else if(packageObj.directories !== undefined && packageObj.directories.bin !== undefined) { + fs.mkdirSync(path.join(nodeModules, ".bin")) + + fs.readdirSync(packageObj.directories.bin).forEach(function(exe) { + if(fs.existsSync(path.join(packageObj.directories.bin, exe))) { + console.log("linking bin '" + exe + "'"); + fs.symlinkSync( + path.join("..", packageObj.name, packageObj.directories.bin, exe), + path.join(nodeModules, ".bin", exe) + ); + } + else { + console.log("skipping non-existent bin '" + exe + "'"); + } + }) + } + ''; + }; + + 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 + + runHook postRebuild + + 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} --no-bin-links --ignore-scripts ${npmFlags} ${lib.optionalString production "--production"} install + fi + + # Link executables defined in package.json + node ${linkBinsScript} + ''; + + # 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 + + # Fixup all executables + ls $out/bin/* | while read i + do + file="$(readlink -f "$i")" + chmod u+rwx "$file" + if isScript "$file" + then + sed -i 's/\r$//' "$file" # convert crlf to lf + fi + 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 <` + sha256 = "sha256-J7uKijlgDlkM+8EWEqzO8hg8rMyeVL62dWRKGcdHQ1I="; + }; + pypiFetcher = import pypi_fetcher_src { inherit pkgs; }; + fetchPypi = pypiFetcher.fetchPypi; + fetchPypiWheel = pypiFetcher.fetchPypiWheel; + pkgsData = fromJSON ''{"font-v": {"name": "font-v", "ver": "1.0.5", "build_inputs": [], "prop_build_inputs": ["fonttools", "gitpython"], "is_root": true, "provider_info": {"provider": "wheel", "wheel_fname": "font_v-1.0.5-py3-none-any.whl", "url": null, "hash": null}, "extras_selected": [], "removed_circular_deps": [], "build": null}, "fonttools": {"name": "fonttools", "ver": "4.17.0", "build_inputs": [], "prop_build_inputs": [], "is_root": true, "provider_info": {"provider": "wheel", "wheel_fname": "fonttools-4.17.0-py3-none-any.whl", "url": null, "hash": null}, "extras_selected": [], "removed_circular_deps": [], "build": null}, "gitdb": {"name": "gitdb", "ver": "4.0.10", "build_inputs": [], "prop_build_inputs": ["smmap"], "is_root": false, "provider_info": {"provider": "wheel", "wheel_fname": "gitdb-4.0.10-py3-none-any.whl", "url": null, "hash": null}, "extras_selected": [], "removed_circular_deps": [], "build": null}, "gitpython": {"name": "gitpython", "ver": "3.1.31", "build_inputs": [], "prop_build_inputs": ["gitdb"], "is_root": false, "provider_info": {"provider": "wheel", "wheel_fname": "GitPython-3.1.31-py3-none-any.whl", "url": null, "hash": null}, "extras_selected": [], "removed_circular_deps": [], "build": null}, "opentype-feature-freezer": {"name": "opentype-feature-freezer", "ver": "1.32.2", "build_inputs": [], "prop_build_inputs": ["fonttools"], "is_root": true, "provider_info": {"provider": "wheel", "wheel_fname": "opentype_feature_freezer-1.32.2-py3-none-any.whl", "url": null, "hash": null}, "extras_selected": [], "removed_circular_deps": [], "build": null}, "pyyaml": {"name": "pyyaml", "ver": "5.4.1", "build_inputs": [], "prop_build_inputs": [], "is_root": true, "provider_info": {"provider": "wheel", "wheel_fname": "PyYAML-5.4.1-cp39-cp39-manylinux1_x86_64.whl", "url": null, "hash": null}, "extras_selected": [], "removed_circular_deps": [], "build": null}, "skia-pathops": {"name": "skia-pathops", "ver": "0.7.0", "build_inputs": [], "prop_build_inputs": [], "is_root": true, "provider_info": {"provider": "wheel", "wheel_fname": "skia_pathops-0.7.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", "url": null, "hash": null}, "extras_selected": [], "removed_circular_deps": [], "build": null}, "smmap": {"name": "smmap", "ver": "5.0.0", "build_inputs": [], "prop_build_inputs": [], "is_root": false, "provider_info": {"provider": "wheel", "wheel_fname": "smmap-5.0.0-py3-none-any.whl", "url": null, "hash": null}, "extras_selected": [], "removed_circular_deps": [], "build": null}, "ttfautohint-py": {"name": "ttfautohint-py", "ver": "0.5.1", "build_inputs": [], "prop_build_inputs": [], "is_root": true, "provider_info": {"provider": "wheel", "wheel_fname": "ttfautohint_py-0.5.1-py2.py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", "url": null, "hash": null}, "extras_selected": [], "removed_circular_deps": [], "build": null}}''; + isPyModule = pkg: + isAttrs pkg && hasAttr "pythonModule" pkg; + normalizeName = name: (replaceStrings ["_"] ["-"] (toLower name)); + depNamesOther = [ + "depsBuildBuild" + "depsBuildBuildPropagated" + "nativeBuildInputs" + "propagatedNativeBuildInputs" + "depsBuildTarget" + "depsBuildTargetPropagated" + "depsHostHost" + "depsHostHostPropagated" + "depsTargetTarget" + "depsTargetTargetPropagated" + "checkInputs" + "installCheckInputs" + ]; + depNamesAll = depNamesOther ++ [ + "propagatedBuildInputs" + "buildInputs" + ]; + removeUnwantedPythonDeps = pythonSelf: pname: inputs: + # Do not remove any deps if provider is nixpkgs and actual dependencies are unknown. + # Otherwise we risk removing dependencies which are needed. + if pkgsData."${pname}".provider_info.provider == "nixpkgs" + && + (pkgsData."${pname}".build_inputs == null + || pkgsData."${pname}".prop_build_inputs == null) then + inputs + else + filter + (dep: + if ! isPyModule dep || pkgsData ? "${normalizeName (get_pname dep)}" then + true + else + trace "removing dependency ${dep.name} from ${pname}" false) + inputs; + updatePythonDeps = newPkgs: pkg: + if ! isPyModule pkg then pkg else + let + pname = normalizeName (get_pname pkg); + newP = + # All packages with a pname that already exists in our overrides must be replaced with our version. + # Otherwise we will have a collision + if newPkgs ? "${pname}" && pkg != newPkgs."${pname}" then + trace "Updated inherited nixpkgs dep ${pname} from ${pkg.version} to ${newPkgs."${pname}".version}" + newPkgs."${pname}" + else + pkg; + in + newP; + updateAndRemoveDeps = pythonSelf: name: inputs: + removeUnwantedPythonDeps pythonSelf name (map (dep: updatePythonDeps pythonSelf dep) inputs); + cleanPythonDerivationInputs = pythonSelf: name: oldAttrs: + mapAttrs (n: v: if elem n depNamesAll then updateAndRemoveDeps pythonSelf name v else v ) oldAttrs; + override = pkg: + if hasAttr "overridePythonAttrs" pkg then + pkg.overridePythonAttrs + else + pkg.overrideAttrs; + nameMap = { + pytorch = "torch"; + }; + get_pname = pkg: + let + res = tryEval ( + if pkg ? src.pname then + pkg.src.pname + else if pkg ? pname then + let pname = pkg.pname; in + if nameMap ? "${pname}" then nameMap."${pname}" else pname + else "" + ); + in + toString res.value; + get_passthru = pypi_name: nix_name: + # if pypi_name is in nixpkgs, we must pick it, otherwise risk infinite recursion. + let + python_pkgs = python.pkgs; + pname = if hasAttr "${pypi_name}" python_pkgs then pypi_name else nix_name; + in + if hasAttr "${pname}" python_pkgs then + let result = (tryEval + (if isNull python_pkgs."${pname}" then + {} + else + python_pkgs."${pname}".passthru)); + in + if result.success then result.value else {} + else {}; + allCondaDepsRec = pkg: + let directCondaDeps = + filter (p: p ? provider && p.provider == "conda") (pkg.propagatedBuildInputs or []); + in + directCondaDeps ++ filter (p: ! directCondaDeps ? p) (map (p: p.allCondaDeps) directCondaDeps); + tests_on_off = enabled: pySelf: pySuper: + let + mod = { + doCheck = enabled; + doInstallCheck = enabled; + }; + in + { + buildPythonPackage = args: pySuper.buildPythonPackage ( args // { + doCheck = enabled; + doInstallCheck = enabled; + } ); + buildPythonApplication = args: pySuper.buildPythonPackage ( args // { + doCheck = enabled; + doInstallCheck = enabled; + } ); + }; + pname_passthru_override = pySelf: pySuper: { + fetchPypi = args: (pySuper.fetchPypi args).overrideAttrs (oa: { + passthru = { inherit (args) pname; }; + }); + }; + mergeOverrides = with pkgs.lib; foldl composeExtensions (self: super: {}); + merge_with_overr = enabled: overr: + mergeOverrides [(tests_on_off enabled) pname_passthru_override overr]; + select_pkgs = ps: [ + ps."font-v" + ps."fonttools" + ps."opentype-feature-freezer" + ps."pyyaml" + ps."skia-pathops" + ps."ttfautohint-py" + ]; + overrides' = manylinux1: autoPatchelfHook: merge_with_overr false (python-self: python-super: let all = { + "font-v" = python-self.buildPythonPackage { + pname = "font-v"; + version = "1.0.5"; + src = fetchPypiWheel "font-v" "1.0.5" "font_v-1.0.5-py3-none-any.whl"; + format = "wheel"; + dontStrip = true; + passthru = (get_passthru "font-v" "font-v") // { provider = "wheel"; }; + propagatedBuildInputs = with python-self; [ fonttools gitpython ]; + }; + "fonttools" = python-self.buildPythonPackage { + pname = "fonttools"; + version = "4.17.0"; + src = fetchPypiWheel "fonttools" "4.17.0" "fonttools-4.17.0-py3-none-any.whl"; + format = "wheel"; + dontStrip = true; + passthru = (get_passthru "fonttools" "fonttools") // { provider = "wheel"; }; + }; + "gitdb" = python-self.buildPythonPackage { + pname = "gitdb"; + version = "4.0.10"; + src = fetchPypiWheel "gitdb" "4.0.10" "gitdb-4.0.10-py3-none-any.whl"; + format = "wheel"; + dontStrip = true; + passthru = (get_passthru "gitdb" "gitdb") // { provider = "wheel"; }; + propagatedBuildInputs = with python-self; [ smmap ]; + }; + "gitpython" = python-self.buildPythonPackage { + pname = "gitpython"; + version = "3.1.31"; + src = fetchPypiWheel "gitpython" "3.1.31" "GitPython-3.1.31-py3-none-any.whl"; + format = "wheel"; + dontStrip = true; + passthru = (get_passthru "gitpython" "GitPython") // { provider = "wheel"; }; + propagatedBuildInputs = with python-self; [ gitdb ]; + }; + "opentype-feature-freezer" = python-self.buildPythonPackage { + pname = "opentype-feature-freezer"; + version = "1.32.2"; + src = fetchPypiWheel "opentype-feature-freezer" "1.32.2" "opentype_feature_freezer-1.32.2-py3-none-any.whl"; + format = "wheel"; + dontStrip = true; + passthru = (get_passthru "opentype-feature-freezer" "opentype-feature-freezer") // { provider = "wheel"; }; + propagatedBuildInputs = with python-self; [ fonttools ]; + }; + "pyyaml" = python-self.buildPythonPackage { + pname = "pyyaml"; + version = "5.4.1"; + src = fetchPypiWheel "pyyaml" "5.4.1" "PyYAML-5.4.1-cp39-cp39-manylinux1_x86_64.whl"; + format = "wheel"; + dontStrip = true; + passthru = (get_passthru "pyyaml" "pyyaml") // { provider = "wheel"; }; + nativeBuildInputs = [ autoPatchelfHook ]; + autoPatchelfIgnoreMissingDeps = true; + propagatedBuildInputs = with python-self; manylinux1 ++ [ ]; + }; + "skia-pathops" = python-self.buildPythonPackage { + pname = "skia-pathops"; + version = "0.7.0"; + src = fetchPypiWheel "skia-pathops" "0.7.0" "skia_pathops-0.7.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl"; + format = "wheel"; + dontStrip = true; + passthru = (get_passthru "skia-pathops" "skia-pathops") // { provider = "wheel"; }; + nativeBuildInputs = [ autoPatchelfHook ]; + autoPatchelfIgnoreMissingDeps = true; + propagatedBuildInputs = with python-self; manylinux1 ++ [ ]; + }; + "smmap" = python-self.buildPythonPackage { + pname = "smmap"; + version = "5.0.0"; + src = fetchPypiWheel "smmap" "5.0.0" "smmap-5.0.0-py3-none-any.whl"; + format = "wheel"; + dontStrip = true; + passthru = (get_passthru "smmap" "smmap") // { provider = "wheel"; }; + }; + "ttfautohint-py" = python-self.buildPythonPackage { + pname = "ttfautohint-py"; + version = "0.5.1"; + src = fetchPypiWheel "ttfautohint-py" "0.5.1" "ttfautohint_py-0.5.1-py2.py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl"; + format = "wheel"; + dontStrip = true; + passthru = (get_passthru "ttfautohint-py" "ttfautohint-py") // { provider = "wheel"; }; + nativeBuildInputs = [ autoPatchelfHook ]; + autoPatchelfIgnoreMissingDeps = true; + propagatedBuildInputs = with python-self; manylinux1 ++ [ ]; + }; + }; in all); +in +{ + inherit select_pkgs; + overrides = overrides'; +}