mirror of
https://github.com/NixOS/nixpkgs.git
synced 2024-12-05 13:23:17 +00:00
9137e671a2
Useful for storing generated files into Nixpkgs repo as a part of an update script to avoid a build time dependency.
159 lines
5.7 KiB
Nix
159 lines
5.7 KiB
Nix
{ lib
|
|
}:
|
|
|
|
/*
|
|
This is a set of tools to manipulate update scripts as recognized by update.nix.
|
|
It is still very experimental with **instability** almost guaranteed so any use
|
|
outside Nixpkgs is discouraged.
|
|
|
|
update.nix currently accepts the following type:
|
|
|
|
type UpdateScript
|
|
// Simple path to script to execute script
|
|
= FilePath
|
|
// Path to execute plus arguments to pass it
|
|
| [ (FilePath | String) ]
|
|
// Advanced attribue set (experimental)
|
|
| {
|
|
// Script to execute (same as basic update script above)
|
|
command : (FilePath | [ (FilePath | String) ])
|
|
// Features that the script supports
|
|
// - commit: (experimental) returns commit message in stdout
|
|
// - silent: (experimental) returns no stdout
|
|
supportedFeatures : ?[ ("commit" | "silent") ]
|
|
// Override attribute path detected by update.nix
|
|
attrPath : ?String
|
|
}
|
|
*/
|
|
|
|
let
|
|
/*
|
|
type ShellArg = String | { __rawShell : String }
|
|
*/
|
|
|
|
/*
|
|
Quotes all arguments to be safely passed to the Bourne shell.
|
|
|
|
escapeShellArgs' : [ShellArg] -> String
|
|
*/
|
|
escapeShellArgs' = lib.concatMapStringsSep " " (arg: if arg ? __rawShell then arg.__rawShell else lib.escapeShellArg arg);
|
|
|
|
/*
|
|
processArg : { maxArgIndex : Int, args : [ShellArg], paths : [FilePath] } → (String|FilePath) → { maxArgIndex : Int, args : [ShellArg], paths : [FilePath] }
|
|
Helper reducer function for building a command arguments where file paths are replaced with argv[x] reference.
|
|
*/
|
|
processArg =
|
|
{ maxArgIndex, args, paths }:
|
|
arg:
|
|
if builtins.isPath arg then {
|
|
args = args ++ [ { __rawShell = "\"\$${builtins.toString maxArgIndex}\""; } ];
|
|
maxArgIndex = maxArgIndex + 1;
|
|
paths = paths ++ [ arg ];
|
|
} else {
|
|
args = args ++ [ arg ];
|
|
inherit maxArgIndex paths;
|
|
};
|
|
/*
|
|
extractPaths : Int → [ (String|FilePath) ] → { maxArgIndex : Int, args : [ShellArg], paths : [FilePath] }
|
|
Helper function that extracts file paths from command arguments and replaces them with argv[x] references.
|
|
*/
|
|
extractPaths = maxArgIndex: command: builtins.foldl' processArg { inherit maxArgIndex; args = [ ]; paths = [ ]; } command;
|
|
/*
|
|
processCommand : { maxArgIndex : Int, commands : [[ShellArg]], paths : [FilePath] } → [ (String|FilePath) ] → { maxArgIndex : Int, commands : [[ShellArg]], paths : [FilePath] }
|
|
Helper reducer function for extracting file paths from individual commands.
|
|
*/
|
|
processCommand =
|
|
{ maxArgIndex, commands, paths }:
|
|
command:
|
|
let
|
|
new = extractPaths maxArgIndex command;
|
|
in
|
|
{
|
|
commands = commands ++ [ new.args ];
|
|
paths = paths ++ new.paths;
|
|
maxArgIndex = new.maxArgIndex;
|
|
};
|
|
/*
|
|
extractCommands : Int → [[ (String|FilePath) ]] → { maxArgIndex : Int, commands : [[ShellArg]], paths : [FilePath] }
|
|
Helper function for extracting file paths from a list of commands and replacing them with argv[x] references.
|
|
*/
|
|
extractCommands = maxArgIndex: commands: builtins.foldl' processCommand { inherit maxArgIndex; commands = [ ]; paths = [ ]; } commands;
|
|
|
|
/*
|
|
commandsToShellInvocation : [[ (String|FilePath) ]] → [ (String|FilePath) ]
|
|
Converts a list of commands into a single command by turning them into a shell script and passing them to `sh -c`.
|
|
*/
|
|
commandsToShellInvocation = commands:
|
|
let
|
|
extracted = extractCommands 0 commands;
|
|
in
|
|
[
|
|
"sh"
|
|
"-c"
|
|
(lib.concatMapStringsSep ";" escapeShellArgs' extracted.commands)
|
|
# We need paths as separate arguments so that update.nix can ensure they refer to the local directory
|
|
# rather than a store path.
|
|
] ++ extracted.paths;
|
|
in
|
|
rec {
|
|
/*
|
|
normalize : UpdateScript → UpdateScript
|
|
EXPERIMENTAL! Converts a basic update script to the experimental attribute set form.
|
|
*/
|
|
normalize = updateScript: {
|
|
command = lib.toList (updateScript.command or updateScript);
|
|
supportedFeatures = updateScript.supportedFeatures or [ ];
|
|
} // lib.optionalAttrs (updateScript ? attrPath) {
|
|
inherit (updateScript) attrPath;
|
|
};
|
|
|
|
/*
|
|
sequence : [UpdateScript] → UpdateScript
|
|
EXPERIMENTAL! Combines multiple update scripts to run in sequence.
|
|
*/
|
|
sequence =
|
|
scripts:
|
|
|
|
let
|
|
scriptsNormalized = builtins.map normalize scripts;
|
|
in
|
|
let
|
|
scripts = scriptsNormalized;
|
|
hasCommitSupport = lib.findSingle ({ supportedFeatures, ... }: supportedFeatures == [ "commit" ]) null null scripts != null;
|
|
validateFeatures =
|
|
if hasCommitSupport then
|
|
({ supportedFeatures, ... }: supportedFeatures == [ "commit" ] || supportedFeatures == [ "silent" ])
|
|
else
|
|
({ supportedFeatures, ... }: supportedFeatures == [ ]);
|
|
in
|
|
|
|
assert lib.assertMsg (lib.all validateFeatures scripts) "Combining update scripts with features enabled (other than a single script with “commit” and all other with “silent”) is currently unsupported.";
|
|
assert lib.assertMsg (builtins.length (lib.unique (builtins.map ({ attrPath ? null, ... }: attrPath) scripts)) == 1) "Combining update scripts with different attr paths is currently unsupported.";
|
|
|
|
{
|
|
command = commandsToShellInvocation (builtins.map ({ command, ... }: command) scripts);
|
|
supportedFeatures = lib.optionals hasCommitSupport [
|
|
"commit"
|
|
];
|
|
};
|
|
|
|
/*
|
|
copyAttrOutputToFile : String → FilePath → UpdateScript
|
|
EXPERIMENTAL! Simple update script that copies the output of Nix derivation built by `attr` to `path`.
|
|
*/
|
|
copyAttrOutputToFile =
|
|
attr:
|
|
path:
|
|
|
|
{
|
|
command = [
|
|
"sh"
|
|
"-c"
|
|
"cp --no-preserve=all \"$(nix-build -A ${attr})\" \"$0\" > /dev/null"
|
|
path
|
|
];
|
|
supportedFeatures = [ "silent" ];
|
|
};
|
|
|
|
}
|