2017-07-29 01:05:35 +01:00
|
|
|
{ lib }:
|
2009-11-19 17:30:21 +00:00
|
|
|
|
|
|
|
rec {
|
2009-11-19 16:43:58 +00:00
|
|
|
|
|
|
|
|
2023-01-01 21:51:54 +00:00
|
|
|
/* `overrideDerivation drv f` takes a derivation (i.e., the result
|
|
|
|
of a call to the builtin function `derivation`) and returns a new
|
2017-04-19 20:41:28 +01:00
|
|
|
derivation in which the attributes of the original are overridden
|
2023-01-01 21:51:54 +00:00
|
|
|
according to the function `f`. The function `f` is called with
|
2009-11-19 17:30:21 +00:00
|
|
|
the original derivation attributes.
|
2009-11-19 16:43:58 +00:00
|
|
|
|
2023-01-01 21:51:54 +00:00
|
|
|
`overrideDerivation` allows certain "ad-hoc" customisation
|
2017-02-01 15:03:42 +00:00
|
|
|
scenarios (e.g. in ~/.config/nixpkgs/config.nix). For instance,
|
|
|
|
if you want to "patch" the derivation returned by a package
|
|
|
|
function in Nixpkgs to build another version than what the
|
|
|
|
function itself provides, you can do something like this:
|
2009-11-19 16:43:58 +00:00
|
|
|
|
|
|
|
mySed = overrideDerivation pkgs.gnused (oldAttrs: {
|
|
|
|
name = "sed-4.2.2-pre";
|
|
|
|
src = fetchurl {
|
|
|
|
url = ftp://alpha.gnu.org/gnu/sed/sed-4.2.2-pre.tar.bz2;
|
|
|
|
sha256 = "11nq06d131y4wmf3drm0yk502d2xc6n5qy82cg88rb9nqd2lj41k";
|
|
|
|
};
|
|
|
|
patches = [];
|
|
|
|
});
|
|
|
|
|
|
|
|
For another application, see build-support/vm, where this
|
|
|
|
function is used to build arbitrary derivations inside a QEMU
|
2015-03-19 15:48:54 +00:00
|
|
|
virtual machine.
|
2022-12-06 17:51:29 +00:00
|
|
|
|
|
|
|
Note that in order to preserve evaluation errors, the new derivation's
|
|
|
|
outPath depends on the old one's, which means that this function cannot
|
|
|
|
be used in circular situations when the old derivation also depends on the
|
|
|
|
new one.
|
|
|
|
|
|
|
|
You should in general prefer `drv.overrideAttrs` over this function;
|
|
|
|
see the nixpkgs manual for more information on overriding.
|
2015-03-19 15:48:54 +00:00
|
|
|
*/
|
2009-11-19 16:43:58 +00:00
|
|
|
overrideDerivation = drv: f:
|
|
|
|
let
|
2013-05-15 05:38:03 +01:00
|
|
|
newDrv = derivation (drv.drvAttrs // (f drv));
|
2022-12-06 17:51:29 +00:00
|
|
|
in lib.flip (extendDerivation (builtins.seq drv.drvPath true)) newDrv (
|
2013-05-15 05:38:03 +01:00
|
|
|
{ meta = drv.meta or {};
|
2009-11-19 16:43:58 +00:00
|
|
|
passthru = if drv ? passthru then drv.passthru else {};
|
2012-01-19 22:29:26 +00:00
|
|
|
}
|
|
|
|
//
|
2013-05-15 05:38:03 +01:00
|
|
|
(drv.passthru or {})
|
|
|
|
//
|
2022-11-18 04:55:23 +00:00
|
|
|
# TODO(@Artturin): remove before release 23.05 and only have __spliced.
|
2022-11-18 04:54:41 +00:00
|
|
|
(lib.optionalAttrs (drv ? crossDrv && drv ? nativeDrv) {
|
|
|
|
crossDrv = overrideDerivation drv.crossDrv f;
|
|
|
|
nativeDrv = overrideDerivation drv.nativeDrv f;
|
|
|
|
})
|
|
|
|
//
|
|
|
|
lib.optionalAttrs (drv ? __spliced) {
|
|
|
|
__spliced = {} // (lib.mapAttrs (_: sDrv: overrideDerivation sDrv f) drv.__spliced);
|
|
|
|
});
|
2009-11-19 16:43:58 +00:00
|
|
|
|
|
|
|
|
2017-09-29 14:11:26 +01:00
|
|
|
/* `makeOverridable` takes a function from attribute set to attribute set and
|
2019-09-02 12:39:40 +01:00
|
|
|
injects `override` attribute which can be used to override arguments of
|
2017-09-29 14:11:26 +01:00
|
|
|
the function.
|
2017-06-24 11:42:56 +01:00
|
|
|
|
|
|
|
nix-repl> x = {a, b}: { result = a + b; }
|
|
|
|
|
|
|
|
nix-repl> y = lib.makeOverridable x { a = 1; b = 2; }
|
|
|
|
|
|
|
|
nix-repl> y
|
|
|
|
{ override = «lambda»; overrideDerivation = «lambda»; result = 3; }
|
|
|
|
|
|
|
|
nix-repl> y.override { a = 10; }
|
|
|
|
{ override = «lambda»; overrideDerivation = «lambda»; result = 12; }
|
|
|
|
|
2017-09-29 14:11:26 +01:00
|
|
|
Please refer to "Nixpkgs Contributors Guide" section
|
|
|
|
"<pkg>.overrideDerivation" to learn about `overrideDerivation` and caveats
|
|
|
|
related to its use.
|
2017-06-24 11:42:56 +01:00
|
|
|
*/
|
2017-09-29 14:11:26 +01:00
|
|
|
makeOverridable = f: origArgs:
|
2010-08-19 23:52:53 +01:00
|
|
|
let
|
2019-09-04 23:16:01 +01:00
|
|
|
result = f origArgs;
|
|
|
|
|
2019-09-04 23:13:24 +01:00
|
|
|
# Creates a functor with the same arguments as f
|
|
|
|
copyArgs = g: lib.setFunctionArgs g (lib.functionArgs f);
|
2019-09-04 23:16:01 +01:00
|
|
|
# Changes the original arguments with (potentially a function that returns) a set of new attributes
|
2018-01-31 19:02:19 +00:00
|
|
|
overrideWith = newArgs: origArgs // (if lib.isFunction newArgs then newArgs origArgs else newArgs);
|
2019-09-04 23:06:22 +01:00
|
|
|
|
|
|
|
# Re-call the function but with different arguments
|
2019-09-04 23:13:24 +01:00
|
|
|
overrideArgs = copyArgs (newArgs: makeOverridable f (overrideWith newArgs));
|
2019-09-04 23:12:05 +01:00
|
|
|
# Change the result of the function call by applying g to it
|
2019-09-04 23:13:24 +01:00
|
|
|
overrideResult = g: makeOverridable (copyArgs (args: g (f args))) origArgs;
|
2017-09-29 14:11:26 +01:00
|
|
|
in
|
2019-09-04 23:16:01 +01:00
|
|
|
if builtins.isAttrs result then
|
|
|
|
result // {
|
|
|
|
override = overrideArgs;
|
|
|
|
overrideDerivation = fdrv: overrideResult (x: overrideDerivation x fdrv);
|
|
|
|
${if result ? overrideAttrs then "overrideAttrs" else null} = fdrv:
|
|
|
|
overrideResult (x: x.overrideAttrs fdrv);
|
|
|
|
}
|
|
|
|
else if lib.isFunction result then
|
|
|
|
# Transform the result into a functor while propagating its arguments
|
|
|
|
lib.setFunctionArgs result (lib.functionArgs result) // {
|
2019-09-04 23:14:22 +01:00
|
|
|
override = overrideArgs;
|
|
|
|
}
|
2019-09-04 23:16:01 +01:00
|
|
|
else result;
|
2009-11-19 17:30:21 +00:00
|
|
|
|
2010-08-02 14:57:57 +01:00
|
|
|
|
2023-01-01 21:51:54 +00:00
|
|
|
/* Call the package function in the file `fn` with the required
|
2010-08-02 14:57:57 +01:00
|
|
|
arguments automatically. The function is called with the
|
2023-01-01 21:51:54 +00:00
|
|
|
arguments `args`, but any missing arguments are obtained from
|
|
|
|
`autoArgs`. This function is intended to be partially
|
2010-08-02 14:57:57 +01:00
|
|
|
parameterised, e.g.,
|
|
|
|
|
|
|
|
callPackage = callPackageWith pkgs;
|
|
|
|
pkgs = {
|
|
|
|
libfoo = callPackage ./foo.nix { };
|
|
|
|
libbar = callPackage ./bar.nix { };
|
|
|
|
};
|
|
|
|
|
2023-01-01 21:51:54 +00:00
|
|
|
If the `libbar` function expects an argument named `libfoo`, it is
|
2010-08-02 14:57:57 +01:00
|
|
|
automatically passed as an argument. Overrides or missing
|
2023-01-01 21:51:54 +00:00
|
|
|
arguments can be supplied in `args`, e.g.
|
2010-08-02 14:57:57 +01:00
|
|
|
|
|
|
|
libbar = callPackage ./bar.nix {
|
|
|
|
libfoo = null;
|
|
|
|
enableX11 = true;
|
|
|
|
};
|
|
|
|
*/
|
|
|
|
callPackageWith = autoArgs: fn: args:
|
2017-09-29 14:11:26 +01:00
|
|
|
let
|
2018-01-31 19:02:19 +00:00
|
|
|
f = if lib.isFunction fn then fn else import fn;
|
2020-07-25 18:54:37 +01:00
|
|
|
fargs = lib.functionArgs f;
|
|
|
|
|
|
|
|
# All arguments that will be passed to the function
|
|
|
|
# This includes automatic ones and ones passed explicitly
|
|
|
|
allArgs = builtins.intersectAttrs fargs autoArgs // args;
|
|
|
|
|
|
|
|
# A list of argument names that the function requires, but
|
|
|
|
# wouldn't be passed to it
|
|
|
|
missingArgs = lib.attrNames
|
|
|
|
# Filter out arguments that have a default value
|
|
|
|
(lib.filterAttrs (name: value: ! value)
|
|
|
|
# Filter out arguments that would be passed
|
|
|
|
(removeAttrs fargs (lib.attrNames allArgs)));
|
|
|
|
|
|
|
|
# Get a list of suggested argument names for a given missing one
|
|
|
|
getSuggestions = arg: lib.pipe (autoArgs // args) [
|
|
|
|
lib.attrNames
|
|
|
|
# Only use ones that are at most 2 edits away. While mork would work,
|
|
|
|
# levenshteinAtMost is only fast for 2 or less.
|
|
|
|
(lib.filter (lib.strings.levenshteinAtMost 2 arg))
|
|
|
|
# Put strings with shorter distance first
|
|
|
|
(lib.sort (x: y: lib.strings.levenshtein x arg < lib.strings.levenshtein y arg))
|
|
|
|
# Only take the first couple results
|
|
|
|
(lib.take 3)
|
|
|
|
# Quote all entries
|
|
|
|
(map (x: "\"" + x + "\""))
|
|
|
|
];
|
|
|
|
|
|
|
|
prettySuggestions = suggestions:
|
|
|
|
if suggestions == [] then ""
|
|
|
|
else if lib.length suggestions == 1 then ", did you mean ${lib.elemAt suggestions 0}?"
|
|
|
|
else ", did you mean ${lib.concatStringsSep ", " (lib.init suggestions)} or ${lib.last suggestions}?";
|
|
|
|
|
|
|
|
errorForArg = arg:
|
|
|
|
let
|
|
|
|
loc = builtins.unsafeGetAttrPos arg fargs;
|
|
|
|
# loc' can be removed once lib/minver.nix is >2.3.4, since that includes
|
|
|
|
# https://github.com/NixOS/nix/pull/3468 which makes loc be non-null
|
|
|
|
loc' = if loc != null then loc.file + ":" + toString loc.line
|
|
|
|
else if ! lib.isFunction fn then
|
|
|
|
toString fn + lib.optionalString (lib.sources.pathIsDirectory fn) "/default.nix"
|
|
|
|
else "<unknown location>";
|
|
|
|
in "Function called without required argument \"${arg}\" at "
|
|
|
|
+ "${loc'}${prettySuggestions (getSuggestions arg)}";
|
|
|
|
|
|
|
|
# Only show the error for the first missing argument
|
|
|
|
error = errorForArg (lib.head missingArgs);
|
|
|
|
|
|
|
|
in if missingArgs == [] then makeOverridable f allArgs else throw error;
|
2010-08-02 14:57:57 +01:00
|
|
|
|
2015-03-20 18:23:55 +00:00
|
|
|
|
2015-07-28 20:35:17 +01:00
|
|
|
/* Like callPackage, but for a function that returns an attribute
|
|
|
|
set of derivations. The override function is added to the
|
|
|
|
individual attributes. */
|
|
|
|
callPackagesWith = autoArgs: fn: args:
|
|
|
|
let
|
2018-01-31 19:02:19 +00:00
|
|
|
f = if lib.isFunction fn then fn else import fn;
|
|
|
|
auto = builtins.intersectAttrs (lib.functionArgs f) autoArgs;
|
2017-02-12 13:57:42 +00:00
|
|
|
origArgs = auto // args;
|
|
|
|
pkgs = f origArgs;
|
2019-02-03 15:30:15 +00:00
|
|
|
mkAttrOverridable = name: _: makeOverridable (newArgs: (f newArgs).${name}) origArgs;
|
2020-03-04 10:58:03 +00:00
|
|
|
in
|
|
|
|
if lib.isDerivation pkgs then throw
|
|
|
|
("function `callPackages` was called on a *single* derivation "
|
|
|
|
+ ''"${pkgs.name or "<unknown-name>"}";''
|
|
|
|
+ " did you mean to use `callPackage` instead?")
|
|
|
|
else lib.mapAttrs mkAttrOverridable pkgs;
|
2015-07-28 20:35:17 +01:00
|
|
|
|
|
|
|
|
|
|
|
/* Add attributes to each output of a derivation without changing
|
2017-12-25 18:06:49 +00:00
|
|
|
the derivation itself and check a given condition when evaluating. */
|
|
|
|
extendDerivation = condition: passthru: drv:
|
2013-03-24 12:29:10 +00:00
|
|
|
let
|
|
|
|
outputs = drv.outputs or [ "out" ];
|
|
|
|
|
2021-10-15 15:30:58 +01:00
|
|
|
commonAttrs = drv // (builtins.listToAttrs outputsList) //
|
2013-03-24 12:29:10 +00:00
|
|
|
({ all = map (x: x.value) outputsList; }) // passthru;
|
|
|
|
|
|
|
|
outputToAttrListElement = outputName:
|
|
|
|
{ name = outputName;
|
|
|
|
value = commonAttrs // {
|
2017-12-25 18:06:49 +00:00
|
|
|
inherit (drv.${outputName}) type outputName;
|
2021-10-15 15:30:58 +01:00
|
|
|
outputSpecified = true;
|
2017-12-25 18:06:49 +00:00
|
|
|
drvPath = assert condition; drv.${outputName}.drvPath;
|
|
|
|
outPath = assert condition; drv.${outputName}.outPath;
|
2022-11-19 10:40:46 +00:00
|
|
|
} //
|
|
|
|
# TODO: give the derivation control over the outputs.
|
|
|
|
# `overrideAttrs` may not be the only attribute that needs
|
|
|
|
# updating when switching outputs.
|
|
|
|
lib.optionalAttrs (passthru?overrideAttrs) {
|
|
|
|
# TODO: also add overrideAttrs when overrideAttrs is not custom, e.g. when not splicing.
|
|
|
|
overrideAttrs = f: (passthru.overrideAttrs f).${outputName};
|
|
|
|
};
|
2013-03-24 12:29:10 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
outputsList = map outputToAttrListElement outputs;
|
2017-12-25 18:06:49 +00:00
|
|
|
in commonAttrs // {
|
|
|
|
drvPath = assert condition; drv.drvPath;
|
|
|
|
outPath = assert condition; drv.outPath;
|
|
|
|
};
|
2015-03-20 18:23:55 +00:00
|
|
|
|
|
|
|
/* Strip a derivation of all non-essential attributes, returning
|
|
|
|
only those needed by hydra-eval-jobs. Also strictly evaluate the
|
|
|
|
result to ensure that there are no thunks kept alive to prevent
|
|
|
|
garbage collection. */
|
|
|
|
hydraJob = drv:
|
|
|
|
let
|
|
|
|
outputs = drv.outputs or ["out"];
|
|
|
|
|
|
|
|
commonAttrs =
|
|
|
|
{ inherit (drv) name system meta; inherit outputs; }
|
|
|
|
// lib.optionalAttrs (drv._hydraAggregate or false) {
|
|
|
|
_hydraAggregate = true;
|
|
|
|
constituents = map hydraJob (lib.flatten drv.constituents);
|
|
|
|
}
|
|
|
|
// (lib.listToAttrs outputsList);
|
|
|
|
|
|
|
|
makeOutput = outputName:
|
|
|
|
let output = drv.${outputName}; in
|
|
|
|
{ name = outputName;
|
|
|
|
value = commonAttrs // {
|
|
|
|
outPath = output.outPath;
|
|
|
|
drvPath = output.drvPath;
|
|
|
|
type = "derivation";
|
|
|
|
inherit outputName;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
outputsList = map makeOutput outputs;
|
|
|
|
|
|
|
|
drv' = (lib.head outputsList).value;
|
2023-01-29 22:39:27 +00:00
|
|
|
in if drv == null then null else
|
|
|
|
lib.deepSeq drv' drv';
|
2015-03-20 18:23:55 +00:00
|
|
|
|
2015-09-27 15:45:23 +01:00
|
|
|
/* Make a set of packages with a common scope. All packages called
|
2023-01-01 21:51:54 +00:00
|
|
|
with the provided `callPackage` will be evaluated with the same
|
2015-09-27 15:45:23 +01:00
|
|
|
arguments. Any package in the set may depend on any other. The
|
2018-09-23 16:07:35 +01:00
|
|
|
`overrideScope'` function allows subsequent modification of the package
|
2015-09-27 15:45:23 +01:00
|
|
|
set in a consistent way, i.e. all packages in the set will be
|
|
|
|
called with the overridden packages. The package sets may be
|
|
|
|
hierarchical: the packages in the set are called with the scope
|
2023-01-01 21:51:54 +00:00
|
|
|
provided by `newScope` and the set provides a `newScope` attribute
|
2015-09-27 15:45:23 +01:00
|
|
|
which can form the parent scope for later package sets. */
|
|
|
|
makeScope = newScope: f:
|
|
|
|
let self = f self // {
|
|
|
|
newScope = scope: newScope (self // scope);
|
|
|
|
callPackage = self.newScope {};
|
2018-09-23 16:07:35 +01:00
|
|
|
overrideScope = g: lib.warn
|
2018-10-11 16:23:47 +01:00
|
|
|
"`overrideScope` (from `lib.makeScope`) is deprecated. Do `overrideScope' (self: super: { … })` instead of `overrideScope (super: self: { … })`. All other overrides have the parameters in that order, including other definitions of `overrideScope`. This was the only definition violating the pattern."
|
2018-09-23 16:07:35 +01:00
|
|
|
(makeScope newScope (lib.fixedPoints.extends (lib.flip g) f));
|
|
|
|
overrideScope' = g: makeScope newScope (lib.fixedPoints.extends g f);
|
2017-02-26 00:58:53 +00:00
|
|
|
packages = f;
|
2015-09-27 15:45:23 +01:00
|
|
|
};
|
|
|
|
in self;
|
|
|
|
|
2020-11-18 17:12:34 +00:00
|
|
|
/* Like the above, but aims to support cross compilation. It's still ugly, but
|
|
|
|
hopefully it helps a little bit. */
|
2021-05-04 05:08:20 +01:00
|
|
|
makeScopeWithSplicing = splicePackages: newScope: otherSplices: keep: extra: f:
|
2020-11-18 17:12:34 +00:00
|
|
|
let
|
2021-05-04 05:08:20 +01:00
|
|
|
spliced0 = splicePackages {
|
2020-11-18 17:12:34 +00:00
|
|
|
pkgsBuildBuild = otherSplices.selfBuildBuild;
|
|
|
|
pkgsBuildHost = otherSplices.selfBuildHost;
|
|
|
|
pkgsBuildTarget = otherSplices.selfBuildTarget;
|
|
|
|
pkgsHostHost = otherSplices.selfHostHost;
|
|
|
|
pkgsHostTarget = self; # Not `otherSplices.selfHostTarget`;
|
|
|
|
pkgsTargetTarget = otherSplices.selfTargetTarget;
|
2021-05-04 05:08:20 +01:00
|
|
|
};
|
|
|
|
spliced = extra spliced0 // spliced0 // keep self;
|
2020-11-18 17:12:34 +00:00
|
|
|
self = f self // {
|
|
|
|
newScope = scope: newScope (spliced // scope);
|
|
|
|
callPackage = newScope spliced; # == self.newScope {};
|
|
|
|
# N.B. the other stages of the package set spliced in are *not*
|
|
|
|
# overridden.
|
|
|
|
overrideScope = g: makeScopeWithSplicing
|
|
|
|
splicePackages
|
|
|
|
newScope
|
|
|
|
otherSplices
|
|
|
|
keep
|
2021-05-04 05:08:20 +01:00
|
|
|
extra
|
2020-11-18 17:12:34 +00:00
|
|
|
(lib.fixedPoints.extends g f);
|
|
|
|
packages = f;
|
|
|
|
};
|
|
|
|
in self;
|
|
|
|
|
2009-11-19 16:43:58 +00:00
|
|
|
}
|