maintainers/scripts/update.nix

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