Merge staging-next into staging

maintainers/maintainer-list.nix

···
     githubId = 19825977;
     name = "Hiren Shah";
   };
+  hiro98 = {
+    email = "[e-mail]";
+    github = "vale981";
+    githubId = 4025991;
+    name = "Valentin Boettcher";
+    keys = [{
+      longkeyid = "rsa2048/0xC22D4DE4D7B32D19";
+      fingerprint = "45A9 9917 578C D629 9F5F  B5B4 C22D 4DE4 D7B3 2D19";
+    }];
+  };
   hjones2199 = {
     email = "[e-mail]";
     github = "hjones2199";
···
     github = "nequissimus";
     githubId = 628342;
     name = "Tim Steinbach";
+  };
+  netcrns = {
+    email = "[e-mail]";
+    github = "netcrns";
+    githubId = 34162313;
+    name = "Jason Wing";
   };
   netixx = {
     email = "[e-mail]";

nixos/modules/services/misc/gitlab.nix

···
     GITLAB_REDIS_CONFIG_FILE = pkgs.writeText "redis.yml" (builtins.toJSON redisConfig);
     prometheus_multiproc_dir = "/run/gitlab";
     RAILS_ENV = "production";
+    MALLOC_ARENA_MAX = "2";
   };
 
   gitlab-rake = pkgs.stdenv.mkDerivation {
···
         description = "Extra configuration to merge into shell-config.yml";
       };
 
+      puma.workers = mkOption {
+        type = types.int;
+        default = 2;
+        apply = x: builtins.toString x;
+        description = ''
+          The number of worker processes Puma should spawn. This
+          controls the amount of parallel Ruby code can be
+          executed. GitLab recommends <quote>Number of CPU cores -
+          1</quote>, but at least two.
+
+          <note>
+            <para>
+              Each worker consumes quite a bit of memory, so
+              be careful when increasing this.
+            </para>
+          </note>
+        '';
+      };
+
+      puma.threadsMin = mkOption {
+        type = types.int;
+        default = 0;
+        apply = x: builtins.toString x;
+        description = ''
+          The minimum number of threads Puma should use per
+          worker.
+
+          <note>
+            <para>
+              Each thread consumes memory and contributes to Global VM
+              Lock contention, so be careful when increasing this.
+            </para>
+          </note>
+        '';
+      };
+
+      puma.threadsMax = mkOption {
+        type = types.int;
+        default = 4;
+        apply = x: builtins.toString x;
+        description = ''
+          The maximum number of threads Puma should use per
+          worker. This limits how many threads Puma will automatically
+          spawn in response to requests. In contrast to workers,
+          threads will never be able to run Ruby code in parallel, but
+          give higher IO parallelism.
+
+          <note>
+            <para>
+              Each thread consumes memory and contributes to Global VM
+              Lock contention, so be careful when increasing this.
+            </para>
+          </note>
+        '';
+      };
+
+      sidekiq.memoryKiller.enable = mkOption {
+        type = types.bool;
+        default = true;
+        description = ''
+          Whether the Sidekiq MemoryKiller should be turned
+          on. MemoryKiller kills Sidekiq when its memory consumption
+          exceeds a certain limit.
+
+          See <link xlink:href="https://docs.gitlab.com/ee/administration/operations/sidekiq_memory_killer.html"/>
+          for details.
+        '';
+      };
+
+      sidekiq.memoryKiller.maxMemory = mkOption {
+        type = types.int;
+        default = 2000;
+        apply = x: builtins.toString (x * 1024);
+        description = ''
+          The maximum amount of memory, in MiB, a Sidekiq worker is
+          allowed to consume before being killed.
+        '';
+      };
+
+      sidekiq.memoryKiller.graceTime = mkOption {
+        type = types.int;
+        default = 900;
+        apply = x: builtins.toString x;
+        description = ''
+          The time MemoryKiller waits after noticing excessive memory
+          consumption before killing Sidekiq.
+        '';
+      };
+
+      sidekiq.memoryKiller.shutdownWait = mkOption {
+        type = types.int;
+        default = 30;
+        apply = x: builtins.toString x;
+        description = ''
+          The time allowed for all jobs to finish before Sidekiq is
+          killed forcefully.
+        '';
+      };
+
       extraConfig = mkOption {
         type = types.attrs;
         default = {};
···
       ] ++ optional (cfg.databaseHost == "") "postgresql.service";
       wantedBy = [ "gitlab.target" ];
       partOf = [ "gitlab.target" ];
-      environment = gitlabEnv;
+      environment = gitlabEnv // (optionalAttrs cfg.sidekiq.memoryKiller.enable {
+        SIDEKIQ_MEMORY_KILLER_MAX_RSS = cfg.sidekiq.memoryKiller.maxMemory;
+        SIDEKIQ_MEMORY_KILLER_GRACE_TIME = cfg.sidekiq.memoryKiller.graceTime;
+        SIDEKIQ_MEMORY_KILLER_SHUTDOWN_WAIT = cfg.sidekiq.memoryKiller.shutdownWait;
+      });
       path = with pkgs; [
         postgresqlPackage
         git
···
         # Needed for GitLab project imports
         gnutar
         gzip
+
+        procps # Sidekiq MemoryKiller
       ];
       serviceConfig = {
         Type = "simple";
         User = cfg.user;
         Group = cfg.group;
         TimeoutSec = "infinity";
-        Restart = "on-failure";
+        Restart = "always";
         WorkingDirectory = "${cfg.packages.gitlab}/share/gitlab";
         ExecStart="${cfg.packages.gitlab.rubyEnv}/bin/sidekiq -C \"${cfg.packages.gitlab}/share/gitlab/config/sidekiq_queues.yml\" -e production";
       };
···
         TimeoutSec = "infinity";
         Restart = "on-failure";
         WorkingDirectory = "${cfg.packages.gitlab}/share/gitlab";
-        ExecStart = "${cfg.packages.gitlab.rubyEnv}/bin/puma -C ${cfg.statePath}/config/puma.rb -e production";
+        ExecStart = concatStringsSep " " [
+          "${cfg.packages.gitlab.rubyEnv}/bin/puma"
+          "-e production"
+          "-C ${cfg.statePath}/config/puma.rb"
+          "-w ${cfg.puma.workers}"
+          "-t ${cfg.puma.threadsMin}:${cfg.puma.threadsMax}"
+        ];
       };
 
     };

nixos/tests/all-tests.nix

···
   buildkite-agents = handleTest ./buildkite-agents.nix {};
   caddy = handleTest ./caddy.nix {};
   cadvisor = handleTestOn ["x86_64-linux"] ./cadvisor.nix {};
-  cage = handleTest ./cage.nix {};
+  cage = handleTestOn ["x86_64-linux"] ./cage.nix {};
   cagebreak = handleTest ./cagebreak.nix {};
   calibre-web = handleTest ./calibre-web.nix {};
   cassandra_2_1 = handleTest ./cassandra.nix { testPackage = pkgs.cassandra_2_1; };

nixos/tests/cage.nix

···
   testScript = { nodes, ... }: let
     user = nodes.machine.config.users.users.alice;
   in ''
+    # Need to switch to a different VGA card / GPU driver because Cage segfaults with the default one (std):
+    # machine # [   14.355893] .cage-wrapped[736]: segfault at 20 ip 00007f035fa0d8c7 sp 00007ffce9e4a2f0 error 4 in libwlroots.so.8[7f035fa07000+5a000]
+    # machine # [   14.358108] Code: 4f a8 ff ff eb aa 0f 1f 44 00 00 c3 0f 1f 80 00 00 00 00 41 54 49 89 f4 55 31 ed 53 48 89 fb 48 8d 7f 18 48 8d 83 b8 00 00 00 <80> 7f 08 00 75 0d 48 83 3f 00 0f 85 91 00 00 00 48 89 fd 48 83 c7
+    os.environ["QEMU_OPTS"] = "-vga virtio"
+
     with subtest("Wait for cage to boot up"):
         start_all()
         machine.wait_for_file("/run/user/${toString user.uid}/wayland-0.lock")

pkgs/applications/misc/josm/default.nix

···
-{ lib, stdenv, fetchurl, fetchsvn, makeWrapper, unzip, jre, libXxf86vm }:
+{ lib, stdenv, fetchurl, fetchsvn, makeWrapper, unzip, jre, libXxf86vm
+, extraJavaOpts ? "-Djosm.restart=true -Djava.net.useSystemProxies=true"
+}:
 let
   pname = "josm";
-  version = "17702";
+  version = "17833";
   srcs = {
     jar = fetchurl {
       url = "https://josm.openstreetmap.de/download/josm-snapshot-${version}.jar";
-      sha256 = "1p7p0jd87sxrs5n0r82apkilx0phgmjw7vpdg8qrr5msda4rsmpk";
+      sha256 = "sha256-i3seRVfCLXNvUkWAAPZK0XloRHuXWCNp1tqnVr7CQ7Y=";
     };
     macosx = fetchurl {
       url = "https://josm.openstreetmap.de/download/macosx/josm-macos-${version}-java16.zip";
-      sha256 = "0r17cphxm852ykb8mkil29rr7sb0bj5w69qd5wz8zf2f9djk9npk";
+      sha256 = "sha256-PM/wNXqtEwalhorWHqVHWsaiGv60SFrHXZrb1Mw/QqQ=";
     };
     pkg = fetchsvn {
       url = "https://josm.openstreetmap.de/svn/trunk/native/linux/tested";
       rev = version;
-      sha256 = "1b7dryvakph8znh2ahgywch66l4bl5rmgsr79axnz1xi12g8ac12";
+      sha256 = "sha256-IjCFngixh2+7SifrV3Ohi1BjIOP+QSWg/QjeqbbP7aw=";
     };
   };
 in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   inherit pname version;
 
   dontUnpack = true;
···
 
       # Add libXxf86vm to path because it is needed by at least Kendzi3D plugin
       makeWrapper ${jre}/bin/java $out/bin/josm \
-        --add-flags "-Djosm.restart=true -Djava.net.useSystemProxies=true" \
-        --add-flags "-jar $out/share/josm/josm.jar" \
+        --add-flags "${extraJavaOpts} -jar $out/share/josm/josm.jar" \
         --prefix LD_LIBRARY_PATH ":" '${libXxf86vm}/lib'
     '';
 

pkgs/applications/networking/browsers/firefox/common.nix

···
 , hunspell, libevent, libstartup_notification
 , libvpx_1_8
 , icu67, libpng, jemalloc, glib, pciutils
-, autoconf213, which, gnused, rustPackages, rustPackages_1_45
+, autoconf213, which, gnused, rustPackages
 , rust-cbindgen, nodejs, nasm, fetchpatch
 , gnum4
 , debugBuild ? false
···
             then "/Applications/${binaryNameCapitalized}.app/Contents/MacOS"
             else "/bin";
 
-  # 78 ESR won't build with rustc 1.47
-  inherit (if lib.versionAtLeast ffversion "82" then rustPackages else rustPackages_1_45)
-    rustc cargo;
+  inherit (rustPackages) rustc cargo;
 
   # Darwin's stdenv provides the default llvmPackages version, match that since
   # clang LTO on Darwin is broken so the stdenv is not being changed.
-  # Target the LLVM version that rustc -Vv reports it is built with for LTO.
-  # rustPackages_1_45 -> LLVM 10, rustPackages -> LLVM 11
   llvmPackages = if stdenv.isDarwin
                  then buildPackages.llvmPackages
-                 else if lib.versionAtLeast rustc.llvm.version "11"
-                      then buildPackages.llvmPackages_11
-                      else buildPackages.llvmPackages_10;
+                 else buildPackages.llvmPackages_11;
 
   # When LTO for Darwin is fixed, the following will need updating as lld
   # doesn't work on it. For now it is fine since ltoSupport implies no Darwin.

pkgs/applications/networking/browsers/google-chrome/default.nix

···
       --prefix XDG_DATA_DIRS   : "$XDG_ICON_DIRS:$GSETTINGS_SCHEMAS_PATH" \
       --add-flags ${escapeShellArg commandLineArgs}
 
-    for elf in $out/share/google/$appname/{chrome,chrome-sandbox,nacl_helper}; do
+    for elf in $out/share/google/$appname/{chrome,chrome-sandbox,crashpad_handler,nacl_helper}; do
       patchelf --set-rpath $rpath $elf
       patchelf --set-interpreter "$(cat $NIX_CC/nix-support/dynamic-linker)" $elf
     done

pkgs/applications/networking/cluster/helm/default.nix

···
 
 buildGoModule rec {
   pname = "helm";
-  version = "3.5.3";
+  version = "3.5.4";
 
   src = fetchFromGitHub {
     owner = "helm";
     repo = "helm";
     rev = "v${version}";
-    sha256 = "sha256-7xO07JDy6ujWlDF+5Xd3myRQ8ajTppCXz9fNe4yizVw=";
+    sha256 = "sha256-u8GJVOubPlIG88TFG5+OvbovMz4Q595wWo2YCwuTgG8=";
   };
-  vendorSha256 = "sha256-lpEoUgABtJczwShNdvD+zYAPDFTJqILSei2YY6mQ2mw=";
+  vendorSha256 = "sha256-zdZxGiwgx8c0zt9tQebJi7k/LNNYjhNInsVeBbxPsgE=";
 
   doCheck = false;
 

pkgs/applications/networking/dyndns/dyndnsc/default.nix

···
 
 python3Packages.buildPythonApplication rec {
   pname = "dyndnsc";
-  version = "0.5.1";
+  version = "0.6.1";
 
   src = python3Packages.fetchPypi {
     inherit pname version;
-    hash = "sha256-Sy6U0XhIQ9mPmznmWKqoyqE34vaE84fwlivouaF7Dd0=";
+    sha256 = "13078d29eea2f9a4ca01f05676c3309ead5e341dab047e0d51c46f23d4b7fbb4";
   };
 
   postPatch = ''
···
     dnspython
     netifaces
     requests
+    json-logging
     setuptools
   ];
-  checkInputs = with python3Packages; [ bottle pytestCheckHook ];
+  checkInputs = with python3Packages; [ bottle mock pytest-console-scripts pytestCheckHook ];
 
   disabledTests = [
     # dnswanip connects to an external server to discover the

pkgs/applications/version-management/yadm/default.nix

···
-{ lib, stdenv, fetchFromGitHub, git, gnupg }:
+{ lib, stdenv, fetchFromGitHub, git, gnupg, installShellFiles }:
 
-let version = "2.5.0"; in
-stdenv.mkDerivation {
+stdenv.mkDerivation rec {
   pname = "yadm";
-  inherit version;
+  version = "3.1.0";
 
   buildInputs = [ git gnupg ];
+
+  nativeBuildInputs = [ installShellFiles ];
 
   src = fetchFromGitHub {
     owner  = "TheLocehiliosan";
     repo   = "yadm";
     rev    = version;
-    sha256 = "128qlx8mp7h5ifapqqgsj3fwghn3q6x6ya0y33h5r7gnassd3njr";
+    sha256 = "0ga0p28nvqilswa07bzi93adk7wx6d5pgxlacr9wl9v1h6cds92s";
   };
 
   dontConfigure = true;
···
   installPhase = ''
     runHook preInstall
     install -Dt $out/bin yadm
-    install -Dt $out/share/man/man1 yadm.1
-    install -D completion/yadm.zsh_completion $out/share/zsh/site-functions/_yadm
-    install -D completion/yadm.bash_completion $out/share/bash-completion/completions/yadm.bash
     runHook postInstall
+  '';
+
+  postInstall = ''
+    installManPage yadm.1
+    installShellCompletion --cmd yadm \
+      --zsh completion/zsh/_yadm \
+      --bash completion/bash/yadm
   '';
 
   meta = {
···
       * Provides a way to use alternate files on a specific OS or host.
       * Supplies a method of encrypting confidential data so it can safely be stored in your repository.
     '';
-    license = lib.licenses.gpl3;
+    license = lib.licenses.gpl3Plus;
     maintainers = with lib.maintainers; [ abathur ];
     platforms = lib.platforms.unix;
   };

pkgs/applications/video/kodi-packages/inputstream-adaptive/default.nix

···
 buildKodiBinaryAddon rec {
   pname = "inputstream-adaptive";
   namespace = "inputstream.adaptive";
-  version = "2.6.13";
+  version = "2.6.14";
 
   src = fetchFromGitHub {
     owner = "xbmc";
     repo = "inputstream.adaptive";
     rev = "${version}-${rel}";
-    sha256 = "1xvinmwyx7mai84i8c394dqw86zb6ib9wnxjmv7zpky6x64lvv10";
+    sha256 = "sha256-5hYB9J4syY+2XOTdg9h7xLk8MMEG88EETIgkUmz4KOU=";
   };
 
   extraNativeBuildInputs = [ gtest ];

pkgs/applications/window-managers/cage/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "cage";
-  version = "0.1.2.1";
+  version = "0.1.3";
 
   src = fetchFromGitHub {
     owner = "Hjdskes";
     repo = "cage";
     rev = "v${version}";
-    sha256 = "1i4rm3dpmk7gkl6hfs6a7vwz76ba7yqcdp63nlrdbnq81m9cy2am";
+    sha256 = "0ixl45g0m8b75gvbjm3gf5qg0yplspgs0xpm2619wn5sygc47sb1";
   };
-
-  postPatch = ''
-    substituteInPlace meson.build --replace \
-      "0.1.2" "${version}"
-  '';
 
   nativeBuildInputs = [ meson ninja pkg-config wayland scdoc makeWrapper ];
 

pkgs/development/libraries/amdvlk/default.nix

···
 
 in stdenv.mkDerivation rec {
   pname = "amdvlk";
-  version = "2021.Q1.6";
+  version = "2021.Q2.2";
 
   src = fetchRepoProject {
     name = "${pname}-src";
     manifest = "https://github.com/GPUOpen-Drivers/AMDVLK.git";
     rev = "refs/tags/v-${version}";
-    sha256 = "FSQ/bYlvdw0Ih3Yl329o8Gizw0YcZTLtiI222Ju4M8w=";
+    sha256 = "4k9ZkBxJGuNUO44F9D+u54eUREl5/8zxjxhaShhzGv0=";
   };
 
   buildInputs = [
···
 
   installPhase = ''
     install -Dm755 -t $out/lib icd/amdvlk${suffix}.so
-    install -Dm644 -t $out/share/vulkan/icd.d ../drivers/AMDVLK/json/Redhat/amd_icd${suffix}.json
-
-    substituteInPlace $out/share/vulkan/icd.d/amd_icd${suffix}.json --replace \
-      "/usr/lib64" "$out/lib"
-    substituteInPlace $out/share/vulkan/icd.d/amd_icd${suffix}.json --replace \
-      "/usr/lib" "$out/lib"
+    install -Dm644 -t $out/share/vulkan/icd.d icd/amd_icd${suffix}.json
+    install -Dm644 -t $out/share/vulkan/implicit_layer.d icd/amd_icd${suffix}.json
 
     patchelf --set-rpath "$rpath" $out/lib/amdvlk${suffix}.so
   '';

pkgs/development/libraries/libgpiod/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "libgpiod";
-  version = "1.6.2";
+  version = "1.6.3";
 
   src = fetchurl {
     url = "https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git/snapshot/libgpiod-${version}.tar.gz";
-    sha256 = "1k8mxkzvd6y9aawxghddrjkldzskhb6607qhbwjfl9f945ns87qa";
+    sha256 = "sha256-60RgcL4URP19MtMrvKU8Lzu7CiEZPbhhmM9gULeihEE=";
   };
 
   patches = [

pkgs/development/python-modules/importlib-resources/2.nix

···
+{ lib
+, buildPythonPackage
+, fetchPypi
+, setuptools-scm
+, importlib-metadata
+, typing
+, singledispatch
+, python
+}:
+
+buildPythonPackage rec {
+  pname = "importlib-resources";
+  version = "3.3.1";
+
+  src = fetchPypi {
+    pname = "importlib_resources";
+    inherit version;
+    sha256 = "0ed250dbd291947d1a298e89f39afcc477d5a6624770503034b72588601bcc05";
+  };
+
+  nativeBuildInputs = [ setuptools-scm ];
+  propagatedBuildInputs = [
+    importlib-metadata
+    singledispatch
+    typing
+  ];
+
+  checkPhase = ''
+    ${python.interpreter} -m unittest discover
+  '';
+
+  meta = with lib; {
+    description = "Read resources from Python packages";
+    homepage = "https://importlib-resources.readthedocs.io/";
+    license = licenses.asl20;
+    maintainers = [ ];
+  };
+}

pkgs/development/python-modules/importlib-resources/default.nix

···
 { lib
 , buildPythonPackage
 , fetchPypi
-, setuptools_scm
-, toml
+, setuptools-scm
 , importlib-metadata
 , typing ? null
 , singledispatch ? null
···
 }:
 
 buildPythonPackage rec {
-  pname = "importlib_resources";
+  pname = "importlib-resources";
   version = "5.1.2";
 
   src = fetchPypi {
-    inherit pname version;
+    pname = "importlib_resources";
+    inherit version;
     sha256 = "642586fc4740bd1cad7690f836b3321309402b20b332529f25617ff18e8e1370";
   };
 
-  nativeBuildInputs = [ setuptools_scm toml ];
+  nativeBuildInputs = [ setuptools-scm ];
   propagatedBuildInputs = [
     importlib-metadata
   ] ++ lib.optional (pythonOlder "3.4") singledispatch
···
     description = "Read resources from Python packages";
     homepage = "https://importlib-resources.readthedocs.io/";
     license = licenses.asl20;
+    maintainers = [ ];
   };
 }

pkgs/development/python-modules/json-logging/default.nix

···
+{ lib
+, buildPythonPackage
+, fetchFromGitHub
+, fetchpatch
+, pytestCheckHook
+, wheel
+, flask
+, sanic
+, fastapi
+, uvicorn
+, requests
+}:
+
+buildPythonPackage rec {
+  pname = "json-logging";
+  version = "1.3.0";
+
+  src = fetchFromGitHub {
+    owner = "bobbui";
+    repo = "json-logging-python";
+    rev = version;
+    hash = "sha256-0eIhOi30r3ApyVkiBdTQps5tNj7rI+q8TjNWxTnhtMQ=";
+  };
+  patches = [
+    # Fix tests picking up test modules instead of real packages.
+    (fetchpatch {
+      url = "https://github.com/bobbui/json-logging-python/commit/6fdb64deb42fe48b0b12bda0442fd5ac5f03107f.patch";
+      sha256 = "sha256-BLfARsw2FdvY22NCaFfdFgL9wTmEZyVIi3CQpB5qU0Y=";
+    })
+  ];
+
+  # - Quart is not packaged for Nixpkgs.
+  # - FastAPI is broken, see #112701 and tiangolo/fastapi#2335.
+  checkInputs = [ wheel flask /*quart*/ sanic /*fastapi*/ uvicorn requests pytestCheckHook ];
+  disabledTests = [ "quart" "fastapi" ];
+  disabledTestPaths = [ "tests/test_fastapi.py" ];
+  # Tests spawn servers and try to connect to them.
+  __darwinAllowLocalNetworking = true;
+
+  meta = with lib; {
+    description = "Python library to emit logs in JSON format";
+    longDescription = ''
+      Python logging library to emit JSON log that can be easily indexed and searchable by logging infrastructure such as ELK, EFK, AWS Cloudwatch, GCP Stackdriver.
+    '';
+    homepage = "https://github.com/bobbui/json-logging-python";
+    license = licenses.asl20;
+    maintainers = with maintainers; [ AluisioASG ];
+  };
+}

pkgs/development/python-modules/pyface/default.nix

···
 { lib, fetchPypi, buildPythonPackage
-, setuptools, six, traits
+, importlib-metadata, importlib-resources, six, traits
 }:
 
 buildPythonPackage rec {
···
     sha256 = "a7031ec4cfff034affc822e47ff5e6c1a0272e576d79465cdbbe25f721740322";
   };
 
-  propagatedBuildInputs = [ setuptools six traits ];
+  propagatedBuildInputs = [ importlib-metadata importlib-resources six traits ];
 
   doCheck = false; # Needs X server
+
+  pythonImportsCheck = [ "pyface" ];
 
   meta = with lib; {
     description = "Traits-capable windowing framework";

pkgs/development/python-modules/pytest-console-scripts/default.nix

···
+{ lib
+, buildPythonPackage
+, fetchPypi
+, pytestCheckHook
+, python
+, mock
+, setuptools-scm
+}:
+
+buildPythonPackage rec {
+  pname = "pytest-console-scripts";
+  version = "1.2.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "4a2138d7d567bc581fe081b6a5975849a2a36b3925cb0f066d2380103e13741c";
+  };
+  postPatch = ''
+    # setuptools-scm is pinned to <6 because it dropped Python 3.5
+    # support.  That's not something that affects us.
+    substituteInPlace setup.py --replace "'setuptools_scm<6'" "'setuptools_scm'"
+    # Patch the shebang of a script generated during test.
+    substituteInPlace tests/test_run_scripts.py --replace "#!/usr/bin/env python" "#!${python.interpreter}"
+  '';
+
+  SETUPTOOLS_SCM_PRETEND_VERSION = version;
+  nativeBuildInputs = [ setuptools-scm ];
+
+  checkInputs = [ mock pytestCheckHook ];
+
+  meta = with lib; {
+    description = "Pytest plugin for testing console scripts";
+    longDescription = ''
+      Pytest-console-scripts is a pytest plugin for running python scripts from within tests.
+      It's quite similar to subprocess.run(), but it also has an in-process mode, where the scripts are executed by the interpreter that's running pytest (using some amount of sandboxing).
+    '';
+    homepage = "https://github.com/kvas-it/pytest-console-scripts";
+    license = licenses.mit;
+    maintainers = with maintainers; [ AluisioASG ];
+  };
+}

pkgs/development/python-modules/pytest-sanic/default.nix

···
     homepage = "https://github.com/yunstanford/pytest-sanic/";
     license = licenses.asl20;
     maintainers = [ maintainers.costrouc ];
+    # pytest-sanic is incompatible with Sanic 21.3, see
+    # https://github.com/sanic-org/sanic/issues/2095 and
+    # https://github.com/yunstanford/pytest-sanic/issues/50.
+    broken = lib.versionAtLeast sanic.version "21.3.0";
   };
 }

pkgs/development/python-modules/sanic-auth/default.nix

···
-{ lib, buildPythonPackage, fetchPypi, sanic, pytestCheckHook }:
+{ lib, buildPythonPackage, fetchPypi, sanic, sanic-testing, pytestCheckHook }:
 
 buildPythonPackage rec {
   pname = "Sanic-Auth";
···
 
   propagatedBuildInputs = [ sanic ];
 
-  checkInputs = [ pytestCheckHook ];
+  checkInputs = [ pytestCheckHook sanic-testing ];
 
   pythonImportsCheck = [ "sanic_auth" ];
 

pkgs/development/python-modules/sanic-routing/default.nix

···
+{ lib
+, buildPythonPackage
+, fetchFromGitHub
+, pytestCheckHook
+, pytest-asyncio
+}:
+
+buildPythonPackage rec {
+  pname = "sanic-routing";
+  version = "0.6.2";
+
+  src = fetchFromGitHub {
+    owner = "sanic-org";
+    repo = "sanic-routing";
+    rev = "v${version}";
+    hash = "sha256-ZMl8PB9E401pUfUJ4tW7nBx1TgPQQtx9erVni3zP+lo=";
+  };
+
+  checkInputs = [ pytestCheckHook pytest-asyncio ];
+  pythonImportsCheck = [ "sanic_routing" ];
+
+  meta = with lib; {
+    description = "Core routing component for the Sanic web framework";
+    homepage = "https://github.com/sanic-org/sanic-routing";
+    license = licenses.mit;
+    maintainers = with maintainers; [ AluisioASG ];
+  };
+}

pkgs/development/python-modules/sanic-testing/default.nix

···
+{ lib
+, buildPythonPackage
+, fetchFromGitHub
+, pytestCheckHook
+, httpcore
+, httpx
+, pytest-asyncio
+, sanic
+, websockets
+}:
+
+buildPythonPackage rec {
+  pname = "sanic-testing";
+  version = "0.3.1";
+
+  src = fetchFromGitHub {
+    owner = "sanic-org";
+    repo = "sanic-testing";
+    rev = "v${version}";
+    hash = "sha256-hBAq+/BKs0a01M89Nb8HaClqxB+W5PTfjVzef/m9SWs=";
+  };
+
+  propagatedBuildInputs = [ httpx sanic websockets httpcore ];
+
+  # `sanic` is explicitly set to null when building `sanic` itself
+  # to prevent infinite recursion.  In that case we skip running
+  # the package at all.
+  doCheck = sanic != null;
+  dontUsePythonImportsCheck = sanic == null;
+
+  checkInputs = [ pytestCheckHook pytest-asyncio ];
+  pythonImportsCheck = [ "sanic_testing" ];
+
+  meta = with lib; {
+    description = "Core testing clients for the Sanic web framework";
+    homepage = "https://github.com/sanic-org/sanic-testing";
+    license = licenses.mit;
+    maintainers = with maintainers; [ AluisioASG ];
+  };
+}

pkgs/development/python-modules/sanic/default.nix

···
 { lib, buildPythonPackage, fetchPypi, doCheck ? true
-, aiofiles, httptools, httpx, multidict, ujson, uvloop, websockets
-, pytestCheckHook, beautifulsoup4, gunicorn, httpcore, uvicorn
-, pytest-asyncio, pytest-benchmark, pytest-dependency, pytest-sanic, pytest-sugar, pytestcov
+, aiofiles, httptools, multidict, sanic-routing, ujson, uvloop, websockets
+, pytestCheckHook, beautifulsoup4, gunicorn, uvicorn, sanic-testing
+, pytest-benchmark, pytest-sanic, pytest-sugar, pytestcov
 }:
 
 buildPythonPackage rec {
   pname = "sanic";
-  version = "21.3.2";
+  version = "21.3.4";
 
   src = fetchPypi {
     inherit pname version;
-    sha256 = "84a04c5f12bf321bed3942597787f1854d15c18f157aebd7ced8c851ccc49e08";
+    sha256 = "1cbd12b9138b3ca69656286b0be91fff02b826e8cb72dd76a2ca8c5eb1288d8e";
   };
 
   postPatch = ''
+    # Loosen dependency requirements.
     substituteInPlace setup.py \
-      --replace '"multidict==5.0.0"' '"multidict"' \
-      --replace '"httpx==0.15.4"' '"httpx"' \
-      --replace '"httpcore==0.3.0"' '"httpcore"' \
-      --replace '"pytest==5.2.1"' '"pytest"'
+      --replace '"pytest==5.2.1"' '"pytest"' \
+      --replace '"gunicorn==20.0.4"' '"gunicorn"' \
+      --replace '"pytest-sanic",' ""
+    # Patch a request headers test to allow brotli encoding
+    # (we build httpx with brotli support, upstream doesn't).
+    substituteInPlace tests/test_headers.py \
+      --replace "deflate\r\n" "deflate, br\r\n"
   '';
 
   propagatedBuildInputs = [
-    aiofiles httptools httpx multidict ujson uvloop websockets
+    sanic-routing httptools uvloop ujson aiofiles websockets multidict
   ];
 
   checkInputs = [
-    pytestCheckHook beautifulsoup4 gunicorn httpcore uvicorn
-    pytest-asyncio pytest-benchmark pytest-dependency pytest-sanic pytest-sugar pytestcov
+    sanic-testing gunicorn pytestcov beautifulsoup4 pytest-sanic pytest-sugar
+    pytest-benchmark pytestCheckHook uvicorn
   ];
 
   inherit doCheck;
 
   disabledTests = [
     "test_gunicorn" # No "examples" directory in pypi distribution.
-    "test_logo" # Fails to filter out "DEBUG asyncio:selector_events.py:59 Using selector: EpollSelector"
     "test_zero_downtime" # No "examples.delayed_response.app" module in pypi distribution.
-    "test_reloader_live" # OSError: [Errno 98] error while attempting to bind on address ('127.0.0.1', 42104)
   ];
 
   __darwinAllowLocalNetworking = true;
···
 
   meta = with lib; {
     description = "A microframework based on uvloop, httptools, and learnings of flask";
-    homepage = "https://github.com/channelcat/sanic/";
+    homepage = "https://github.com/sanic-org/sanic/";
     license = licenses.mit;
-    maintainers = [ maintainers.costrouc ];
+    maintainers = with maintainers; [ costrouc AluisioASG ];
   };
 }

pkgs/development/tools/analysis/rizin/cutter.nix

···
 
 mkDerivation rec {
   pname = "cutter";
-  version = "2.0.1";
+  version = "2.0.2";
 
   src = fetchFromGitHub {
     owner = "rizinorg";
     repo = "cutter";
     rev = "v${version}";
-    sha256 = "sha256-IQCJOUgefSdMSa27E6I/CL35Kx5pHq/u+5Q0FHUAR1E=";
+    sha256 = "sha256-CVVUXx6wt9vH3B7NrrlRGnOIrhXQPjV7GmX3O+KtMSM=";
     fetchSubmodules = true;
   };
 

pkgs/development/tools/analysis/rizin/default.nix

···
 
 stdenv.mkDerivation rec {
   pname = "rizin";
-  version = "0.2.0";
+  version = "0.2.1";
 
   src = fetchurl {
     url = "https://github.com/rizinorg/rizin/releases/download/v${version}/rizin-src-v${version}.tar.xz";
-    sha256 = "sha256-CGHeo247syha+rVtiAQz0XkEYK9p4DHTnLK2FhBOvE8=";
+    sha256 = "sha256-lxVsPI+qLenZ0pelvxtHlQ6fhWdQeqoEEHrUGZ5Rdmg=";
   };
 
   mesonFlags = [

pkgs/development/tools/database/movine/default.nix

···
+{ rustPlatform
+, fetchFromGitHub
+, lib
+, stdenv
+, pkg-config
+, postgresql
+, sqlite
+, openssl
+, Security
+, libiconv
+}:
+
+rustPlatform.buildRustPackage rec {
+  pname = "movine";
+  version = "0.11.0";
+
+  src = fetchFromGitHub {
+    owner = "byronwasti";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "0rms8np8zd23xzrd5avhp2q1ndhdc8f49lfwpff9h0slw4rnzfnj";
+  };
+
+  cargoSha256 = "sha256-4ghfenwmauR4Ft9n7dvBflwIMXPdFq1vh6FpIegHnZk=";
+
+  nativeBuildInputs = [ pkg-config ];
+  buildInputs = [ postgresql sqlite ] ++ (
+    if !stdenv.isDarwin then [ openssl ] else [ Security libiconv ]
+  );
+
+  meta = with lib; {
+    description = "A migration manager written in Rust, that attempts to be smart yet minimal";
+    homepage = "https://github.com/byronwasti/movine";
+    license = licenses.mit;
+    longDescription = ''
+      Movine is a simple database migration manager that aims to be compatible
+      with real-world migration work. Many migration managers get confused
+      with complicated development strategies for migrations. Oftentimes
+      migration managers do not warn you if the SQL saved in git differs from
+      what was actually run on the database. Movine solves this issue by
+      keeping track of the unique hashes for the <literal>up.sql</literal> and
+      <literal>down.sql</literal> for each migration, and provides tools for
+      fixing issues. This allows users to easily keep track of whether their
+      local migration history matches the one on the database.
+
+      This project is currently in early stages.
+
+      Movine does not aim to be an ORM.
+      Consider <link xling:href="https://diesel.rs/">diesel</link> instead if
+      you want an ORM.
+    '';
+    maintainers = with maintainers; [ netcrns ];
+  };
+}

pkgs/development/tools/roswell/default.nix

···
+{ lib, stdenv, fetchFromGitHub, curl, autoconf, automake, makeWrapper, sbcl }:
+
+stdenv.mkDerivation rec {
+  pname = "roswell";
+  version = "21.01.14.108";
+
+  src = fetchFromGitHub {
+    owner = "roswell";
+    repo = pname;
+    rev = "v${version}";
+    sha256 = "1hj9q3ig7naky3pb3jkl9yjc9xkg0k7js3glxicv0aqffx9hkp3p";
+  };
+
+  preConfigure = ''
+    sh bootstrap
+  '';
+
+  configureFlags = [ "--prefix=${placeholder "out"}" ];
+
+  postInstall = ''
+    wrapProgram $out/bin/ros \
+      --add-flags 'lisp=sbcl-bin/system sbcl-bin.version=system' \
+      --prefix PATH : ${lib.makeBinPath [ sbcl ]} --argv0 ros
+  '';
+
+  nativeBuildInputs = [ autoconf automake makeWrapper ];
+
+  buildInputs = [ sbcl curl ];
+
+  meta = with lib; {
+    description = "Roswell is a Lisp implementation installer/manager, launcher, and much more";
+    license = licenses.mit;
+    maintainers = with maintainers; [ hiro98 ];
+    platforms = platforms.linux;
+    homepage = "https://github.com/roswell/roswell";
+    mainProgram = "ros";
+  };
+}

pkgs/os-specific/linux/firmware/sof-firmware/default.nix

···
 with lib;
 stdenv.mkDerivation rec {
   pname = "sof-firmware";
-  version = "1.6";
+  version = "1.7";
 
   src = fetchFromGitHub {
     owner = "thesofproject";
     repo = "sof-bin";
-    rev = "cbdec6963b2c2d58b0080955d3c11b96ff4c92f0";
-    sha256 = "0la2pw1zpv50cywiqcfb00cxqvjc73drxwjchyzi54l508817nxh";
+    rev = "v${version}";
+    sha256 = "sha256-Z0Z4HLsIIuW8E1kFNhAECmzj1HkJVfbEw13B8V7PZLk=";
   };
 
-  phases = [ "unpackPhase" "installPhase" ];
+  dontFixup = true; # binaries must not be stripped or patchelfed
 
   installPhase = ''
-    mkdir -p $out/lib/firmware
-
-    patchShebangs go.sh
-    ROOT=$out SOF_VERSION=v${version} ./go.sh
+    mkdir -p $out/lib/firmware/intel/
+    cp -a sof-v${version} $out/lib/firmware/intel/sof
+    cp -a sof-tplg-v${version} $out/lib/firmware/intel/sof-tplg
   '';
 
   meta = with lib; {
     description = "Sound Open Firmware";
     homepage = "https://www.sofproject.org/";
     license = with licenses; [ bsd3 isc ];
-    maintainers = with maintainers; [ lblasc evenbrenden ];
+    maintainers = with maintainers; [ lblasc evenbrenden hmenke ];
     platforms = with platforms; linux;
   };
 }

pkgs/os-specific/linux/fuse/common.nix

···
 { version, sha256Hash }:
 
 { lib, stdenv, fetchFromGitHub, fetchpatch
-, fusePackages, util-linux, gettext
+, fusePackages, util-linux, gettext, shadow
 , meson, ninja, pkg-config
 , autoreconfHook
 , python3Packages, which
···
     # $PATH, so it should also work on non-NixOS systems.
     export NIX_CFLAGS_COMPILE="-DFUSERMOUNT_DIR=\"/run/wrappers/bin\""
 
-    sed -e 's@/bin/@${util-linux}/bin/@g' -i lib/mount_util.c
+    substituteInPlace lib/mount_util.c --replace "/bin/" "${util-linux}/bin/"
     '' + (if isFuse3 then ''
       # The configure phase will delete these files (temporary workaround for
       # ./fuse3-install_man.patch)
       install -D -m444 doc/fusermount3.1 $out/share/man/man1/fusermount3.1
       install -D -m444 doc/mount.fuse3.8 $out/share/man/man8/mount.fuse3.8
     '' else ''
+      substituteInPlace util/mount.fuse.c --replace '"su"' '"${shadow.su}/bin/su"'
       sed -e 's@CONFIG_RPATH=/usr/share/gettext/config.rpath@CONFIG_RPATH=${gettext}/share/gettext/config.rpath@' -i makeconf.sh
       ./makeconf.sh
     '');

pkgs/os-specific/linux/nvidia-x11/default.nix

···
     else legacy_390;
 
   beta = generic {
-    version = "460.27.04";
-    sha256_64bit = "plTqtc5QZQwM0f3MeMZV0N5XOiuSXCCDklL/qyy8HM8=";
-    settingsSha256 = "hU9J0VSrLXs7N14zq6U5LbBLZXEIyTfih/Bj6eFcMf0=";
-    persistencedSha256 = "PmqhoPskqhJe2FxMrQh9zX1BWQCR2kkfDwvA89+XALA=";
+    version = "465.27";
+    sha256_64bit = "fmn/qFve5qqqa26n4dsoOwGZ+ash5Bon3JBI8kncMXE=";
+    settingsSha256 = "3BFLCx0dcrQY4Mv1joMsiVPwTPyufgsNT5pFgp1Mk/A=";
+    persistencedSha256 = "HtoFGTiBnAeQyRTOMlve5poaQh63LHRD+DHJxZO+c90=";
   };
 
   # Vulkan developer beta driver

pkgs/servers/http/gitlab-pages/default.nix

···
 
 buildGoModule rec {
   pname = "gitlab-pages";
-  version = "1.35.0";
+  version = "1.38.0";
 
   src = fetchFromGitLab {
     owner = "gitlab-org";
     repo = "gitlab-pages";
     rev = "v${version}";
-    sha256 = "sha256-5AkzbOutBXy59XvMwfyH6A8ETwjP2QokG/Rz31/nCpk=";
+    sha256 = "sha256-QaqZGTkNAzQEqlwccAWPDP91BSc9vRDEsCBca/lEXW4=";
   };
 
-  vendorSha256 = "sha256-g8FDWpZmbZSkJAzoEiI8/JZLTTgG7uJ4sS35axaEXLY=";
+  vendorSha256 = "sha256-uuwuiGQWLIQ5UJuCKDBEvCPo2+AXtJ54ARK431qiakc=";
   subPackages = [ "." ];
-  doCheck = false; # Broken
 
   meta = with lib; {
     description = "Daemon used to serve static websites for GitLab users";
     homepage = "https://gitlab.com/gitlab-org/gitlab-pages";
+    changelog = "https://gitlab.com/gitlab-org/gitlab-pages/-/blob/v${version}/CHANGELOG.md";
     license = licenses.mit;
-    maintainers = with maintainers; [ das_j ];
+    maintainers = with maintainers; [ ajs124 das_j ];
   };
 }

pkgs/tools/misc/ffsend/default.nix

···
 { lib, stdenv, fetchFromGitLab, rustPlatform, cmake, pkg-config, openssl
-, darwin, installShellFiles
+, installShellFiles
+, CoreFoundation, CoreServices, Security, AppKit, libiconv
 
 , x11Support ? stdenv.isLinux || stdenv.hostPlatform.isBSD
 , xclip ? null, xsel ? null
···
 
   nativeBuildInputs = [ cmake pkg-config installShellFiles ];
   buildInputs =
-    if stdenv.isDarwin then (with darwin.apple_sdk.frameworks; [ CoreFoundation CoreServices Security AppKit ])
+    if stdenv.isDarwin then [ libiconv CoreFoundation CoreServices Security AppKit ]
     else [ openssl ];
 
   preBuild = lib.optionalString (x11Support && usesX11) (

pkgs/tools/networking/fastd/default.nix

···
-{ lib, stdenv, fetchFromGitHub, bison, meson, ninja, pkg-config
-, libuecc, libsodium, libcap, json_c, openssl }:
+{ lib
+, stdenv
+, fetchFromGitHub
+, bison
+, meson
+, ninja
+, pkg-config
+, libuecc
+, libsodium
+, libcap
+, json_c
+, openssl
+}:
 
 stdenv.mkDerivation rec {
   pname = "fastd";
···
     sha256 = "1p4k50dk8byrghbr0fwmgwps8df6rlkgcd603r14i71m5g27z5gw";
   };
 
-  nativeBuildInputs = [ pkg-config bison meson ninja ];
-  buildInputs = [ libuecc libsodium libcap json_c openssl ];
+  nativeBuildInputs = [
+    bison
+    meson
+    ninja
+    pkg-config
+  ];
+
+  buildInputs = [
+    json_c
+    libcap
+    libsodium
+    libuecc
+    openssl
+  ];
+
+  # some options are only available on x86
+  mesonFlags = lib.optionals (!stdenv.isx86_64 && !stdenv.isi686) [
+    "-Dcipher_salsa20_xmm=disabled"
+    "-Dcipher_salsa2012_xmm=disabled"
+    "-Dmac_ghash_pclmulqdq=disabled"
+  ];
 
   enableParallelBuilding = true;
 

pkgs/top-level/all-packages.nix

···
 
   ferm = callPackage ../tools/networking/ferm { };
 
-  ffsend = callPackage ../tools/misc/ffsend { };
+  ffsend = callPackage ../tools/misc/ffsend {
+    inherit (darwin.apple_sdk.frameworks) CoreFoundation CoreServices Security AppKit;
+  };
 
   fgallery = callPackage ../tools/graphics/fgallery { };
 
···
   sbcl_2_1_2 = callPackage ../development/compilers/sbcl/2.1.2.nix {};
   sbcl = sbcl_2_1_2;
 
+  roswell = callPackage ../development/tools/roswell/default.nix { };
+
   scala_2_10 = callPackage ../development/compilers/scala/2.x.nix { majorVersion = "2.10"; jre = jdk8; };
   scala_2_11 = callPackage ../development/compilers/scala/2.x.nix { majorVersion = "2.11"; jre = jdk8; };
   scala_2_12 = callPackage ../development/compilers/scala/2.x.nix { majorVersion = "2.12"; jre = jdk8; };
···
 
   mono-addins = callPackage ../development/libraries/mono-addins { };
 
+  movine = callPackage ../development/tools/database/movine {
+    inherit (darwin.apple_sdk.frameworks) Security;
+  };
+
   movit = callPackage ../development/libraries/movit { };
 
   mosquitto = callPackage ../servers/mqtt/mosquitto { };
···
 
   caerbannog = callPackage ../applications/misc/caerbannog { };
 
-  cage = callPackage ../applications/window-managers/cage {
-    wlroots = wlroots_0_12;
-  };
+  cage = callPackage ../applications/window-managers/cage { };
 
   calf = callPackage ../applications/audio/calf {
       inherit (gnome2) libglade;

pkgs/top-level/python-packages.nix

···
 
   jsonlines = callPackage ../development/python-modules/jsonlines { };
 
+  json-logging = callPackage ../development/python-modules/json-logging { };
+
   jsonmerge = callPackage ../development/python-modules/jsonmerge { };
 
   json-merge-patch = callPackage ../development/python-modules/json-merge-patch { };
···
 
   pytest-click = callPackage ../development/python-modules/pytest-click { };
 
+  pytest-console-scripts = callPackage ../development/python-modules/pytest-console-scripts { };
+
   pytest-cov = self.pytestcov; # self 2021-01-04
   pytestcov = callPackage ../development/python-modules/pytest-cov { };
 
···
 
   samsungtvws = callPackage ../development/python-modules/samsungtvws { };
 
+  sanic = callPackage ../development/python-modules/sanic {
+    # pytest-sanic is doing ok for the sole purpose of testing Sanic.
+    pytest-sanic = self.pytest-sanic.overridePythonAttrs (oldAttrs: {
+      doCheck = false;
+      meta.broken = false;
+    });
+    # Don't pass any `sanic` to avoid dependency loops.  `sanic-testing`
+    # has special logic to disable tests when this is the case.
+    sanic-testing = self.sanic-testing.override { sanic = null; };
+  };
+
   sanic-auth = callPackage ../development/python-modules/sanic-auth { };
 
-  sanic = callPackage ../development/python-modules/sanic { };
+  sanic-routing = callPackage ../development/python-modules/sanic-routing { };
+
+  sanic-testing = callPackage ../development/python-modules/sanic-testing { };
 
   sapi-python-client = callPackage ../development/python-modules/sapi-python-client { };
 

pkgs/top-level/python2-packages.nix

···
 
   importlib-metadata = callPackage ../development/python-modules/importlib-metadata/2.nix { };
 
+  importlib-resources = callPackage ../development/python-modules/importlib-resources/2.nix { };
+
   ipaddr = callPackage ../development/python-modules/ipaddr { };
 
   ipykernel = callPackage ../development/python-modules/ipykernel/4.nix { };