maintainers/scripts/update.nix

   1 /*
   2   To run:
   3
   4       nix-shell maintainers/scripts/update.nix
   5
   6   See https://nixos.org/manual/nixpkgs/unstable/#var-passthru-updateScript
   7 */
   8 { package ? null
   9 , maintainer ? null
  10 , predicate ? null
  11 , path ? null
  12 , max-workers ? null
  13 , include-overlays ? false
  14 , keep-going ? null
  15 , commit ? null
  16 , skip-prompt ? null
  17 }:
  18
  19 let
  20   pkgs = import ./../../default.nix (
  21     if include-overlays == false then
  22       { overlays = []; }
  23     else if include-overlays == true then
  24       { } # Let Nixpkgs include overlays impurely.
  25     else { overlays = include-overlays; }
  26   );
  27
  28   inherit (pkgs) lib;
  29
  30   /* Remove duplicate elements from the list based on some extracted value. O(n^2) complexity.
  31    */
  32   nubOn = f: list:
  33     if list == [] then
  34       []
  35     else
  36       let
  37         x = lib.head list;
  38         xs = lib.filter (p: f x != f p) (lib.drop 1 list);
  39       in
  40         [x] ++ nubOn f xs;
  41
  42   /* Recursively find all packages (derivations) in `pkgs` matching `cond` predicate.
  43
  44     Type: packagesWithPath :: AttrPath → (AttrPath → derivation → bool) → AttrSet → List<AttrSet{attrPath :: str; package :: derivation; }>
  45           AttrPath :: [str]
  46
  47     The packages will be returned as a list of named pairs comprising of:
  48       - attrPath: stringified attribute path (based on `rootPath`)
  49       - package: corresponding derivation
  50    */
  51   packagesWithPath = rootPath: cond: pkgs:
  52     let
  53       packagesWithPathInner = path: pathContent:
  54         let
  55           result = builtins.tryEval pathContent;
  56
  57           somewhatUniqueRepresentant =
  58             { package, attrPath }: {
  59               inherit (package) updateScript;
  60               # Some updaters use the same `updateScript` value for all packages.
  61               # Also compare `meta.description`.
  62               position = package.meta.position or null;
  63               # We cannot always use `meta.position` since it might not be available
  64               # or it might be shared among multiple packages.
  65             };
  66
  67           dedupResults = lst: nubOn somewhatUniqueRepresentant (lib.concatLists lst);
  68         in
  69           if result.success then
  70             let
  71               evaluatedPathContent = result.value;
  72             in
  73               if lib.isDerivation evaluatedPathContent then
  74                 lib.optional (cond path evaluatedPathContent) { attrPath = lib.concatStringsSep "." path; package = evaluatedPathContent; }
  75               else if lib.isAttrs evaluatedPathContent then
  76                 # If user explicitly points to an attrSet or it is marked for recursion, we recur.
  77                 if path == rootPath || evaluatedPathContent.recurseForDerivations or false || evaluatedPathContent.recurseForRelease or false then
  78                   dedupResults (lib.mapAttrsToList (name: elem: packagesWithPathInner (path ++ [name]) elem) evaluatedPathContent)
  79                 else []
  80               else []
  81           else [];
  82     in
  83       packagesWithPathInner rootPath pkgs;
  84
  85   /* Recursively find all packages (derivations) in `pkgs` matching `cond` predicate.
  86    */
  87   packagesWith = packagesWithPath [];
  88
  89   /* Recursively find all packages in `pkgs` with updateScript matching given predicate.
  90    */
  91   packagesWithUpdateScriptMatchingPredicate = cond:
  92     packagesWith (path: pkg: builtins.hasAttr "updateScript" pkg && cond path pkg);
  93
  94   /* Recursively find all packages in `pkgs` with updateScript by given maintainer.
  95    */
  96   packagesWithUpdateScriptAndMaintainer = maintainer':
  97     let
  98       maintainer =
  99         if ! builtins.hasAttr maintainer' lib.maintainers then
 100           builtins.throw "Maintainer with name `${maintainer'} does not exist in `maintainers/maintainer-list.nix`."
 101         else
 102           builtins.getAttr maintainer' lib.maintainers;
 103     in
 104       packagesWithUpdateScriptMatchingPredicate (path: pkg:
 105                          (if builtins.hasAttr "maintainers" pkg.meta
 106                            then (if builtins.isList pkg.meta.maintainers
 107                                    then builtins.elem maintainer pkg.meta.maintainers
 108                                    else maintainer == pkg.meta.maintainers
 109                                 )
 110                            else false
 111                          )
 112                    );
 113
 114   /* Recursively find all packages under `path` in `pkgs` with updateScript.
 115    */
 116   packagesWithUpdateScript = path: pkgs:
 117     let
 118       prefix = lib.splitString "." path;
 119       pathContent = lib.attrByPath prefix null pkgs;
 120     in
 121       if pathContent == null then
 122         builtins.throw "Attribute path `${path}` does not exist."
 123       else
 124         packagesWithPath prefix (path: pkg: builtins.hasAttr "updateScript" pkg)
 125                        pathContent;
 126
 127   /* Find a package under `path` in `pkgs` and require that it has an updateScript.
 128    */
 129   packageByName = path: pkgs:
 130     let
 131         package = lib.attrByPath (lib.splitString "." path) null pkgs;
 132     in
 133       if package == null then
 134         builtins.throw "Package with an attribute name `${path}` does not exist."
 135       else if ! builtins.hasAttr "updateScript" package then
 136         builtins.throw "Package with an attribute name `${path}` does not have a `passthru.updateScript` attribute defined."
 137       else
 138         { attrPath = path; inherit package; };
 139
 140   /* List of packages matched based on the CLI arguments.
 141    */
 142   packages =
 143     if package != null then
 144       [ (packageByName package pkgs) ]
 145     else if predicate != null then
 146       packagesWithUpdateScriptMatchingPredicate predicate pkgs
 147     else if maintainer != null then
 148       packagesWithUpdateScriptAndMaintainer maintainer pkgs
 149     else if path != null then
 150       packagesWithUpdateScript path pkgs
 151     else
 152       builtins.throw "No arguments provided.\n\n${helpText}";
 153
 154   helpText = ''
 155     Please run:
 156
 157         % nix-shell maintainers/scripts/update.nix --argstr maintainer garbas
 158
 159     to run all update scripts for all packages that lists \`garbas\` as a maintainer
 160     and have \`updateScript\` defined, or:
 161
 162         % nix-shell maintainers/scripts/update.nix --argstr package nautilus
 163
 164     to run update script for specific package, or
 165
 166         % nix-shell maintainers/scripts/update.nix --arg predicate '(path: pkg: pkg.updateScript.name or null == "gnome-update-script")'
 167
 168     to run update script for all packages matching given predicate, or
 169
 170         % nix-shell maintainers/scripts/update.nix --argstr path gnome
 171
 172     to run update script for all package under an attribute path.
 173
 174     You can also add
 175
 176         --argstr max-workers 8
 177
 178     to increase the number of jobs in parallel, or
 179
 180         --argstr keep-going true
 181
 182     to continue running when a single update fails.
 183
 184     You can also make the updater automatically commit on your behalf from updateScripts
 185     that support it by adding
 186
 187         --argstr commit true
 188
 189     to skip prompt:
 190
 191         --argstr skip-prompt true
 192   '';
 193
 194   /* Transform a matched package into an object for update.py.
 195    */
 196   packageData = { package, attrPath }: {
 197     name = package.name;
 198     pname = lib.getName package;
 199     oldVersion = lib.getVersion package;
 200     updateScript = map builtins.toString (lib.toList (package.updateScript.command or package.updateScript));
 201     supportedFeatures = package.updateScript.supportedFeatures or [];
 202     attrPath = package.updateScript.attrPath or attrPath;
 203   };
 204
 205   /* JSON file with data for update.py.
 206    */
 207   packagesJson = pkgs.writeText "packages.json" (builtins.toJSON (map packageData packages));
 208
 209   optionalArgs =
 210     lib.optional (max-workers != null) "--max-workers=${max-workers}"
 211     ++ lib.optional (keep-going == "true") "--keep-going"
 212     ++ lib.optional (commit == "true") "--commit"
 213     ++ lib.optional (skip-prompt == "true") "--skip-prompt";
 214
 215   args = [ packagesJson ] ++ optionalArgs;
 216
 217 in pkgs.stdenv.mkDerivation {
 218   name = "nixpkgs-update-script";
 219   buildCommand = ''
 220     echo ""
 221     echo "----------------------------------------------------------------"
 222     echo ""
 223     echo "Not possible to update packages using \`nix-build\`"
 224     echo ""
 225     echo "${helpText}"
 226     echo "----------------------------------------------------------------"
 227     exit 1
 228   '';
 229   shellHook = ''
 230     unset shellHook # do not contaminate nested shells
 231     exec ${pkgs.python3.interpreter} ${./update.py} ${builtins.concatStringsSep " " args}
 232   '';
 233 }