Merge branch 'master' into staging

lib/maintainers.nix

···
   ivan-tkatchev = "Ivan Tkatchev <[e-mail]>";
   j-keck = "Jürgen Keck <[e-mail]>";
   jagajaga = "Arseniy Seroka <[e-mail]>";
+  jammerful = "jammerful <[e-mail]>";
   jansol = "Jan Solanti <[e-mail]>";
   javaguirre = "Javier Aguirre <[e-mail]>";
   jb55 = "William Casarin <[e-mail]>";
···
   msackman = "Matthew Sackman <[e-mail]>";
   mschristiansen = "Mikkel Christiansen <[e-mail]>";
   msteen = "Matthijs Steen <[e-mail]>";
+  mt-caret = "Masayuki Takeda <[e-mail]>";
   mtreskin = "Max Treskin <[e-mail]>";
   mudri = "James Wood <[e-mail]>";
   muflax = "Stefan Dorn <[e-mail]>";

nixos/modules/config/sysctl.nix

···
 
     # Hide kernel pointers (e.g. in /proc/modules) for unprivileged
     # users as these make it easier to exploit kernel vulnerabilities.
-    #
-    # Removed under grsecurity.
-    boot.kernel.sysctl."kernel.kptr_restrict" =
-      if (config.boot.kernelPackages.kernel.features.grsecurity or false) then null else 1;
+    boot.kernel.sysctl."kernel.kptr_restrict" = 1;
 
     # Disable YAMA by default to allow easy debugging.
     boot.kernel.sysctl."kernel.yama.ptrace_scope" = mkDefault 0;

nixos/modules/installer/cd-dvd/sd-image-aarch64.nix

···
 in
 {
   imports = [
-    ../../profiles/minimal.nix
     ../../profiles/installation-device.nix
     ./sd-image.nix
   ];

nixos/modules/installer/cd-dvd/sd-image-armv7l-multiplatform.nix

···
 in
 {
   imports = [
-    ../../profiles/minimal.nix
     ../../profiles/installation-device.nix
     ./sd-image.nix
   ];

nixos/modules/installer/cd-dvd/sd-image-raspberrypi.nix

···
 in
 {
   imports = [
-    ../../profiles/minimal.nix
     ../../profiles/installation-device.nix
     ./sd-image.nix
   ];

nixos/modules/programs/ssh.nix

···
 
   knownHosts = map (h: getAttr h cfg.knownHosts) (attrNames cfg.knownHosts);
 
-  knownHostsText = flip (concatMapStringsSep "\n") knownHosts
+  knownHostsText = (flip (concatMapStringsSep "\n") knownHosts
     (h: assert h.hostNames != [];
       concatStringsSep "," h.hostNames + " "
       + (if h.publicKey != null then h.publicKey else readFile h.publicKeyFile)
-    );
+    )) + "\n";
 
 in
 {

nixos/modules/services/continuous-integration/gitlab-runner.nix

···
 let
   cfg = config.services.gitlab-runner;
   configFile = pkgs.writeText "config.toml" cfg.configText;
+  hasDocker = config.virtualisation.docker.enable;
 in
 {
   options.services.gitlab-runner = {
···
   config = mkIf cfg.enable {
     systemd.services.gitlab-runner = {
       description = "Gitlab Runner";
-      after = [ "network.target" "docker.service" ];
-      requires = [ "docker.service" ];
+      after = [ "network.target" ]
+        ++ optional hasDocker "docker.service";
+      requires = optional hasDocker "docker.service";
       wantedBy = [ "multi-user.target" ];
       serviceConfig = {
         ExecStart = ''${cfg.package.bin}/bin/gitlab-runner run \
···
 
     users.extraUsers.gitlab-runner = {
       group = "gitlab-runner";
-      extraGroups = [ "docker" ];
+      extraGroups = optional hasDocker "docker";
       uid = config.ids.uids.gitlab-runner;
       home = cfg.workDir;
       createHome = true;

nixos/modules/services/networking/nsd.nix

···
       cd $out/zones
 
       for zoneFile in *; do
+        echo "|- checking zone '$out/zones/$zoneFile'"
         ${nsdPkg}/sbin/nsd-checkzone "$zoneFile" "$zoneFile" || {
           if grep -q \\\\\\$ "$zoneFile"; then
             echo zone "$zoneFile" contains escaped dollar signes \\\$

nixos/modules/services/security/shibboleth-sp.nix

···
       };
     };
   };
+
+  meta.maintainers = with lib.maintainers; [ jammerful ];
 }

nixos/modules/system/boot/luksroot.nix

···
       #!$out/bin/sh -e
       if [ -e /.luksopen_args ]; then
         cryptsetup \$(cat /.luksopen_args)
-        killall cryptsetup
+        killall -q cryptsetup
       else
         echo "Passphrase is not requested now"
         exit 1

nixos/modules/tasks/powertop.nix

···
 with lib;
 
 let
-  cfg = config.powerManagment.powertop;
+  cfg = config.powerManagement.powertop;
 in {
   ###### interface
 
-  options.powerManagment.powertop.enable = mkEnableOption "powertop auto tuning on startup";
+  options.powerManagement.powertop.enable = mkEnableOption "powertop auto tuning on startup";
 
   ###### implementation
 

pkgs/applications/altcoins/default.nix

···
 
   ethabi = callPackage ./ethabi.nix { };
   ethrun = callPackage ./ethrun.nix { };
+  seth = callPackage ./seth.nix { };
 
   primecoin  = callPackage ./primecoin.nix { withGui = true; };
   primecoind = callPackage ./primecoin.nix { withGui = false; };

pkgs/applications/altcoins/seth.nix

···
+{ stdenv, makeWrapper, lib, fetchFromGitHub
+, bc, coreutils, curl, ethabi, git, gnused, jshon, solc, which }:
+
+stdenv.mkDerivation rec {
+  name = "seth-${version}";
+  version = "0.5.0";
+
+  src = fetchFromGitHub {
+    owner = "dapphub";
+    repo = "seth";
+    rev = "v${version}";
+    sha256 = "0bgygvilhbabb0y9pv9cn8cx7cj513w9is4vh6v69h2czknrjmgz";
+  };
+
+  nativeBuildInputs = [makeWrapper];
+  buildPhase = "true";
+  makeFlags = ["prefix=$(out)"];
+  postInstall = let path = lib.makeBinPath [
+    bc coreutils curl ethabi git gnused jshon solc which
+  ]; in ''
+    wrapProgram "$out/bin/seth" --prefix PATH : "${path}"
+  '';
+
+  meta = {
+    description = "Command-line client for talking to Ethereum nodes";
+    homepage = https://github.com/dapphub/seth/;
+    maintainers = [stdenv.lib.maintainers.dbrock];
+    license = lib.licenses.gpl3;
+    inherit version;
+  };
+}

pkgs/applications/graphics/sxiv/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "sxiv-${version}";
-  version = "v1.3.2";
-  #https://github.com/muennich/sxiv/archive/v1.3.2.zip
+  version = "1.3.2";
+
   src = fetchFromGitHub {
     owner = "muennich";
     repo = "sxiv";
-    rev = version;
+    rev = "v${version}";
     sha256 = "1f4gz1qjhb44bbb3q5fqk439zyipkwnr19zhg89yq2pgmzzzqr2h";
   };
 

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

···
     "--enable-system-sqlite"
     #"--enable-system-cairo"
     "--enable-startup-notification"
-    "--enable-content-sandbox" # available since 26.0, but not much info available
+    #"--enable-content-sandbox" # TODO: probably enable after 54
     "--disable-tests"
     "--disable-necko-wifi" # maybe we want to enable this at some point
     "--disable-updater"

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

···
          then "linux-amd64"
          else "darwin-amd64";
   checksum = if stdenv.isLinux
-             then "17fya0d1v2w44df5n5xb99vr8qjbnbfjvicsi9p7yz4iz2mcymd6"
-             else "0299ffws37d60wim8kvdp4xrvqxa93sggrprgrsiclcp8bab0dcr";
+             then "0vjkcilxzwvkgcczcbq58nl2j17ddqiysxm5yl13agnmxzvxw6r2"
+             else "1ga9gxzji48vhbaa0pkxd03h89zgjsbikbki9xla1qbvyvqjnw5g";
+
+  pname = "helm";
+  version = "2.4.1";
 in
-stdenv.mkDerivation rec {
-  pname = "helm";
-  version = "2.3.1";
+stdenv.mkDerivation {
   name = "${pname}-${version}";
 
   src = fetchurl {
     url = "https://kubernetes-helm.storage.googleapis.com/helm-v${version}-${arch}.tar.gz";
-    sha256 = "${checksum}";
+    sha256 = checksum;
   };
 
   preferLocalBuild = true;

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

···
     rev    = "v${version}";
     owner  = "gruntwork-io";
     repo   = "terragrunt";
-    sha256 = "1khmxqzhhkr6km4zfn0q3zm55wgc92hrayvqkf9snzr816c1qzp3";
+    sha256 = "07xxk7r9wvjv3v0l95g7sy5yphypfxmlymxzi7yv3b8dznifwm0y";
   };
 
   goDeps = ./deps.nix;

pkgs/applications/networking/instant-messengers/dino/default.nix

···
  }:
 
 stdenv.mkDerivation rec {
-  name = "dino-unstable-2017-04-24";
+  name = "dino-unstable-2017-05-11";
 
   src = fetchFromGitHub {
     owner = "dino";
     repo = "dino";
-    rev = "3eb9aa0fa79ea9fcebb5f702f81c2e54aafdc8cc";
-    sha256 = "0z9ql419q53f20bw4pfwsafxl4qqnz0ip91qibsf9jn5d56kcdwv";
+    rev = "b09a056a13de131a4f2f072ffa2f795a0bb2abe7";
+    sha256 = "1dis1kgaqb1925anmxlcy9n722zzyn5wvq8lmczi6h2h3j7wnnmz";
     fetchSubmodules = true;
   };
 
···
     glib_networking
     glib
     gnome3.libgee
+    gnome3.defaultIconTheme
     sqlite
     gdk_pixbuf
     gtk3

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

···
+{lib, python2Packages, git, mercurial}:
+
+with python2Packages;
+buildPythonApplication rec {
+  name = "${pname}-${version}";
+  version = "0.3.0";
+  pname = "nbstripout";
+
+  # Mercurial should be added as a build input but because it's a Python
+  # application, it would mess up the Python environment. Thus, don't add it
+  # here, instead add it to PATH when running unit tests
+  buildInputs = [ pytest pytest-flake8 pytest-cram git pytestrunner ];
+  propagatedBuildInputs = [ ipython nbformat ];
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "126xhjma4a0k7gq58hbqglhb3rai0a576azz7g8gmqjr3kl0264v";
+  };
+
+  # ignore flake8 tests for the nix wrapped setup.py
+  checkPhase = ''
+    PATH=$PATH:$out/bin:${mercurial}/bin pytest --ignore=nix_run_setup.py .
+  '';
+
+  meta = {
+    inherit version;
+    description = "Strip output from Jupyter and IPython notebooks";
+    homepage = https://github.com/kynan/nbstripout;
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ jluttine ];
+  };
+}

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

···
-{ stdenv, fetchurl, fetchFromGitHub, luaPackages, cairo, cmake, imagemagick, pkgconfig, gdk_pixbuf
+{ stdenv, fetchurl, fetchFromGitHub, luaPackages, cairo, librsvg, cmake, imagemagick, pkgconfig, gdk_pixbuf
 , xorg, libstartup_notification, libxdg_basedir, libpthreadstubs
 , xcb-util-cursor, makeWrapper, pango, gobjectIntrospection, unclutter
 , compton, procps, iproute, coreutils, curl, alsaUtils, findutils, xterm
···
   ];
    
   propagatedUserEnvPkgs = [ hicolor_icon_theme ];
-  buildInputs = [ cairo dbus gdk_pixbuf gobjectIntrospection
+  buildInputs = [ cairo librsvg dbus gdk_pixbuf gobjectIntrospection
                   git lgi libpthreadstubs libstartup_notification
                   libxdg_basedir lua nettools pango xcb-util-cursor
                   xorg.libXau xorg.libXdmcp xorg.libxcb xorg.libxshmfence
···
 
   postInstall = ''
     wrapProgram $out/bin/awesome \
+      --set GDK_PIXBUF_MODULE_FILE "$GDK_PIXBUF_MODULE_FILE" \
       --prefix LUA_CPATH ";" '"${lgi}/lib/lua/${lua.luaversion}/?.so"' \
       --prefix LUA_PATH ";" '"${lgi}/share/lua/${lua.luaversion}/?.lua;${lgi}/share/lua/${lua.luaversion}/lgi/?.lua"' \
       --prefix GI_TYPELIB_PATH : "$GI_TYPELIB_PATH" \

pkgs/data/fonts/fira-code/symbols.nix

···
+{ stdenv, runCommand, fetchurl, unzip }:
+
+runCommand "fira-code-symbols-20160811" {
+  src = fetchurl {
+    url = "https://github.com/tonsky/FiraCode/files/412440/FiraCode-Regular-Symbol.zip";
+    sha256 = "01sk8cmm50xg2vwf0ff212yi5gd2sxcb5l4i9g004alfrp7qaqxg";
+  };
+  buildInputs = [ unzip ];
+
+  meta = with stdenv.lib; {
+    description = "FiraCode unicode ligature glyphs in private use area";
+    longDescription = ''
+      FiraCode uses ligatures, which some editors don’t support.
+      This addition adds them as glyphs to the private unicode use area.
+      See https://github.com/tonsky/FiraCode/issues/211.
+    '';
+    license = licenses.ofl;
+    maintainers = [ maintainers.profpatsch ];
+    homepage = "https://github.com/tonsky/FiraCode/issues/211#issuecomment-239058632";
+  };
+} ''
+  mkdir -p $out/share/fonts/opentype
+  unzip "$src" -d $out/share/fonts/opentype
+''

pkgs/development/haskell-modules/hackage-packages.nix

···
      }:
      mkDerivation {
        pname = "GPipe";
-       version = "2.2";
-       sha256 = "960ef739287f3e3078a3257adbb9c74c22df6ea69ab269f5a365da0133c6245c";
+       version = "2.2.1";
+       sha256 = "8f8c2391b49dab16ae4b241ff7e4728f1c61c275ff422d42fc326c779508a7bc";
        libraryHaskellDepends = [
          base Boolean containers exception-transformers gl hashtables linear
          transformers
···
     ({ mkDerivation, async, base, containers, GLFW-b, GPipe, stm }:
      mkDerivation {
        pname = "GPipe-GLFW";
-       version = "1.4.0";
-       sha256 = "5409922cc181e2f7d943afe63b6154a65799ee6eba318a6201f303987c1eb529";
+       version = "1.4.1";
+       sha256 = "6b86172c72c254c203a6bbab0848375538a52d90dc888ca1c517199d51714647";
        libraryHaskellDepends = [ async base containers GLFW-b GPipe stm ];
        homepage = "https://github.com/plredmond/GPipe-GLFW";
        description = "GLFW OpenGL context creation for GPipe";
···
        license = "GPL";
      }) {};
 
+  "Villefort" = callPackage
+    ({ mkDerivation, base, FindBin, HDBC, HDBC-sqlite3, mtl, scotty
+     , split, text, time
+     }:
+     mkDerivation {
+       pname = "Villefort";
+       version = "0.1.0.6";
+       sha256 = "1d3f0293e020c48206f6ca6cdabbca4042edbc1a9ae1c14484f5c00087d247f8";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base FindBin HDBC HDBC-sqlite3 mtl split time
+       ];
+       executableHaskellDepends = [
+         base HDBC HDBC-sqlite3 scotty split text time
+       ];
+       testHaskellDepends = [ base ];
+       homepage = "https://github.com/Chrisr850/Villefort#readme";
+       description = "Villefort is a task manager and time tracker written in haskell";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "Vulkan" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "acme-cofunctor";
-       version = "0.1.0.0";
-       sha256 = "d5ecbe477dd579fec0c6f6ad5d8f05d884de65af6570d519703896ecfe08311a";
+       version = "0.1.1.0";
+       sha256 = "9d3c87320b56a20b5d22c77f8ee7add4c725a44ea517352253b0d0b5c0b5b479";
        libraryHaskellDepends = [ base ];
        homepage = "https://github.com/jaspervdj/acme-cofunctor";
        description = "A Cofunctor is a structure from category theory dual to Functor";
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
-  "aeson_0_11_3_0" = callPackage
-    ({ mkDerivation, attoparsec, base, base-orphans, bytestring
-     , containers, deepseq, dlist, fail, ghc-prim, hashable, HUnit, mtl
-     , QuickCheck, quickcheck-instances, scientific, syb, tagged
-     , template-haskell, test-framework, test-framework-hunit
-     , test-framework-quickcheck2, text, time, transformers
-     , unordered-containers, vector
-     }:
-     mkDerivation {
-       pname = "aeson";
-       version = "0.11.3.0";
-       sha256 = "f326fac57881c228d91f610a2c92f083a60e3830d9c7d35dfb0a16925c95ece9";
-       libraryHaskellDepends = [
-         attoparsec base bytestring containers deepseq dlist fail ghc-prim
-         hashable mtl scientific syb tagged template-haskell text time
-         transformers unordered-containers vector
-       ];
-       testHaskellDepends = [
-         attoparsec base base-orphans bytestring containers ghc-prim
-         hashable HUnit QuickCheck quickcheck-instances tagged
-         template-haskell test-framework test-framework-hunit
-         test-framework-quickcheck2 text time unordered-containers vector
-       ];
-       homepage = "https://github.com/bos/aeson";
-       description = "Fast JSON parsing and encoding";
-       license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-     }) {};
-
   "aeson" = callPackage
     ({ mkDerivation, attoparsec, base, base-compat, base-orphans
      , base16-bytestring, bytestring, containers, deepseq, dlist
···
      }:
      mkDerivation {
        pname = "atlassian-connect-core";
-       version = "0.7.0.2";
-       sha256 = "6872f0ca4a70c50942b239828621fda3923a3763921130150be20c568c40ff50";
+       version = "0.7.2.0";
+       sha256 = "25cc9902cc87845a569f48ec7b379d5ceb83b7fcf9751f2908e69b00aec3db39";
        libraryHaskellDepends = [
          aeson atlassian-connect-descriptor base base64-bytestring
          bytestring case-insensitive cipher-aes configurator containers
···
      }:
      mkDerivation {
        pname = "atlassian-connect-descriptor";
-       version = "0.4.4.2";
-       sha256 = "9352e134c720358694b7e839c5056ce62334303d0db9cb94e151c086da123598";
+       version = "0.4.5.0";
+       sha256 = "a05e750e20af9f0cf32ddd154215550a6fda5b44b8f9b120c3fd71158ee7fa37";
        libraryHaskellDepends = [
          aeson base cases network network-uri text time-units
          unordered-containers
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "base-feature-macros" = callPackage
+    ({ mkDerivation, base }:
+     mkDerivation {
+       pname = "base-feature-macros";
+       version = "0.1";
+       sha256 = "be1ba0e207be3558f5b061785dd363fd63613034e00488b022be7655561d39ab";
+       revision = "1";
+       editedCabalFile = "d92172580179ae9338cb58504d1b05c058ce0d593ef4f67a88dbef842f693ae6";
+       libraryHaskellDepends = [ base ];
+       doHaddock = false;
+       description = "Semantic CPP feature macros for base";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "base-generics" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        pname = "blank-canvas";
        version = "0.6";
        sha256 = "2a0e5c4fc50b1ce43e56b1a11056186c21d565e225da36f90c58f8c0a70f48b3";
-       revision = "10";
-       editedCabalFile = "b3fca3e52b9662881d181fa39c63b5b5095f77f83f0fd223c2a4cfeffa05a486";
+       revision = "11";
+       editedCabalFile = "06e4ddd08f0655253a5e5129eeb8790e5667f679c8c806cd1133b3998870bad8";
        libraryHaskellDepends = [
          aeson base base-compat base64-bytestring bytestring colour
          containers data-default-class http-types kansas-comet mime-types
···
      }) {};
 
   "bound" = callPackage
-    ({ mkDerivation, base, bifunctors, binary, bytes, cereal, comonad
-     , directory, doctest, filepath, hashable, hashable-extras
-     , prelude-extras, profunctors, template-haskell, transformers
-     , vector
+    ({ mkDerivation, base, bifunctors, binary, bytes, Cabal
+     , cabal-doctest, cereal, comonad, deepseq, deriving-compat, doctest
+     , functor-classes-compat, hashable, mmorph, profunctors
+     , template-haskell, transformers, transformers-compat, vector, void
      }:
      mkDerivation {
        pname = "bound";
-       version = "1.0.7";
-       sha256 = "ad0388ade83ca0b3cf02b182e663f553a83b3a8116ada8f39543318bf516340e";
+       version = "2";
+       sha256 = "5d08b02ae1f17764ced96d497510a60cb9937ecf2b1faf3fdf791039a799c37c";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
-         base bifunctors binary bytes cereal comonad hashable
-         hashable-extras prelude-extras profunctors template-haskell
-         transformers
+         base bifunctors binary bytes cereal comonad deepseq hashable mmorph
+         profunctors template-haskell transformers transformers-compat
        ];
        testHaskellDepends = [
-         base directory doctest filepath prelude-extras transformers vector
+         base deriving-compat doctest functor-classes-compat transformers
+         transformers-compat vector void
        ];
        homepage = "http://github.com/ekmett/bound/";
        description = "Making de Bruijn Succ Less";
···
      }:
      mkDerivation {
        pname = "cabal-info";
-       version = "0.1.0.0";
-       sha256 = "d7623ce69cdf180f3266cc14fcf4e53f4d5b2c4d9cb359f145a730878096fc6d";
+       version = "0.2.1";
+       sha256 = "9484ab621cf0b502edea1430966919005cf323b30ad83c8aac8912930072c4bd";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd2;
      }) {};
 
+  "concurrent-output_1_9_0" = callPackage
+    ({ mkDerivation, ansi-terminal, async, base, directory, exceptions
+     , process, stm, terminal-size, text, transformers, unix
+     }:
+     mkDerivation {
+       pname = "concurrent-output";
+       version = "1.9.0";
+       sha256 = "2341d06e2bc51963a4f8d035c7cd7c7e9cf02f3d92001aa5ee586e3f00a64b72";
+       libraryHaskellDepends = [
+         ansi-terminal async base directory exceptions process stm
+         terminal-size text transformers unix
+       ];
+       description = "Ungarble output from several threads or commands";
+       license = stdenv.lib.licenses.bsd2;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "concurrent-rpc" = callPackage
     ({ mkDerivation, base }:
      mkDerivation {
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "crdt" = callPackage
+    ({ mkDerivation, base, derive, QuickCheck, tasty, tasty-quickcheck
+     , vector
+     }:
+     mkDerivation {
+       pname = "crdt";
+       version = "0.1";
+       sha256 = "86de73b5c2f2c597de3203c7724ae9a73bb2db6b6d67daac24137c3a05b19880";
+       libraryHaskellDepends = [ base vector ];
+       testHaskellDepends = [
+         base derive QuickCheck tasty tasty-quickcheck vector
+       ];
+       homepage = "https://github.com/cblp/crdt#readme";
+       description = "Conflict-free replicated data types";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "creatur" = callPackage
     ({ mkDerivation, array, base, binary, bytestring, cereal, cond
      , directory, exceptions, filepath, gray-extended, hdaemonize
···
        license = stdenv.lib.licenses.bsd3;
      }) {inherit (pkgs) openssl;};
 
+  "cryptonite-openssl_0_6" = callPackage
+    ({ mkDerivation, base, bytestring, cryptonite, memory, openssl
+     , tasty, tasty-hunit, tasty-kat, tasty-quickcheck
+     }:
+     mkDerivation {
+       pname = "cryptonite-openssl";
+       version = "0.6";
+       sha256 = "a8cb97c96bfb3e7b7ff8d59629317882dbf3cea12ba978d8475c96a6c28750a6";
+       libraryHaskellDepends = [ base bytestring cryptonite memory ];
+       librarySystemDepends = [ openssl ];
+       testHaskellDepends = [
+         base bytestring cryptonite tasty tasty-hunit tasty-kat
+         tasty-quickcheck
+       ];
+       homepage = "https://github.com/haskell-crypto/cryptonite-openssl";
+       description = "Crypto stuff using OpenSSL cryptographic library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {inherit (pkgs) openssl;};
+
   "cryptsy-api" = callPackage
     ({ mkDerivation, aeson, base, bytestring, deepseq, either
      , http-client, http-client-tls, old-locale, pipes-attoparsec
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "czipwith" = callPackage
+    ({ mkDerivation, base, template-haskell, transformers }:
+     mkDerivation {
+       pname = "czipwith";
+       version = "1.0.0.0";
+       sha256 = "45a2af0fd73f4cb7968c382465d8c5c6f4807d195d85e5b35bccef8f5e7c2ce1";
+       libraryHaskellDepends = [ base template-haskell ];
+       testHaskellDepends = [ base transformers ];
+       homepage = "https://github.com/lspitzner/czipwith/";
+       description = "CZipWith class and deriving via TH";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "d-bus" = callPackage
     ({ mkDerivation, async, attoparsec, base, binary, blaze-builder
      , bytestring, conduit, conduit-extra, containers
···
        homepage = "https://github.com/mvv/data-dword";
        description = "Stick two binary words together to get a bigger one";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "data-dword_0_3_1_1" = callPackage
+    ({ mkDerivation, base, data-bword, ghc-prim, hashable, tasty
+     , tasty-quickcheck, template-haskell
+     }:
+     mkDerivation {
+       pname = "data-dword";
+       version = "0.3.1.1";
+       sha256 = "f77cd3c4cad022a7d229f96511fbd88eb8b0f2c9a40b67dc8c971dbd3d18fa35";
+       libraryHaskellDepends = [
+         base data-bword ghc-prim hashable template-haskell
+       ];
+       testHaskellDepends = [ base tasty tasty-quickcheck ];
+       homepage = "https://github.com/mvv/data-dword";
+       description = "Stick two binary words together to get a bigger one";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "data-easy" = callPackage
···
        pname = "deepseq-generics";
        version = "0.2.0.0";
        sha256 = "b0b3ef5546c0768ef9194519a90c629f8f2ba0348487e620bb89d512187c7c9d";
+       revision = "1";
+       editedCabalFile = "023d1de7ad38dc0f72f0e77c7620a036fc632a6ac5c07e9f9229a8834948b514";
        libraryHaskellDepends = [ base deepseq ghc-prim ];
        testHaskellDepends = [
          base deepseq ghc-prim HUnit test-framework test-framework-hunit
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "ersatz_0_4" = callPackage
+    ({ mkDerivation, array, attoparsec, base, bytestring, Cabal
+     , cabal-doctest, containers, data-default, directory, doctest
+     , filepath, lens, mtl, parsec, process, temporary, transformers
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "ersatz";
+       version = "0.4";
+       sha256 = "8e9d11bb90e191eae3a4f4fc4a332ac5e0e4fb996889030c46a2ecb5db38739c";
+       isLibrary = true;
+       isExecutable = true;
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         array attoparsec base bytestring containers data-default lens mtl
+         process temporary transformers unordered-containers
+       ];
+       executableHaskellDepends = [
+         array base containers lens mtl parsec
+       ];
+       testHaskellDepends = [ array base directory doctest filepath mtl ];
+       homepage = "http://github.com/ekmett/ersatz";
+       description = "A monad for expressing SAT or QSAT problems using observable sharing";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "ersatz-toysat" = callPackage
     ({ mkDerivation, array, base, containers, ersatz, toysolver
      , transformers
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "eventful-core" = callPackage
+    ({ mkDerivation, aeson, base, containers, hlint, hspec
+     , http-api-data, HUnit, path-pieces, template-haskell, text
+     , transformers, uuid
+     }:
+     mkDerivation {
+       pname = "eventful-core";
+       version = "0.1.1";
+       sha256 = "ea7d123dd9510d72f651b4197cbc35d34dd4d737b4e567fc1f16571518c64583";
+       libraryHaskellDepends = [
+         aeson base containers http-api-data path-pieces template-haskell
+         text transformers uuid
+       ];
+       testHaskellDepends = [
+         aeson base containers hlint hspec http-api-data HUnit path-pieces
+         template-haskell text transformers uuid
+       ];
+       homepage = "https://github.com/jdreaver/eventful#readme";
+       description = "Core module for eventful";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "eventful-dynamodb" = callPackage
+    ({ mkDerivation, aeson, amazonka, amazonka-dynamodb, base
+     , bytestring, conduit, eventful-core, eventful-test-helpers, hlint
+     , hspec, HUnit, lens, QuickCheck, quickcheck-instances, safe, text
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "eventful-dynamodb";
+       version = "0.1.1";
+       sha256 = "3431f60159b7c7dc6b3994c5fd3aa87e48d43cf54ea499d07b363cf79b39cc91";
+       libraryHaskellDepends = [
+         aeson amazonka amazonka-dynamodb base bytestring conduit
+         eventful-core lens safe text unordered-containers vector
+       ];
+       testHaskellDepends = [
+         aeson amazonka amazonka-dynamodb base bytestring conduit
+         eventful-core eventful-test-helpers hlint hspec HUnit lens
+         QuickCheck quickcheck-instances safe text unordered-containers
+         vector
+       ];
+       homepage = "https://github.com/jdreaver/eventful#readme";
+       description = "Library for eventful DynamoDB event stores";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "eventful-memory" = callPackage
+    ({ mkDerivation, async, base, containers, eventful-core
+     , eventful-test-helpers, hlint, hspec, HUnit, mtl, safe, stm
+     }:
+     mkDerivation {
+       pname = "eventful-memory";
+       version = "0.1.1";
+       sha256 = "efd3b19092571ac0d669f511da8c2f5559277255f6f783de5473669c388442e6";
+       libraryHaskellDepends = [
+         async base containers eventful-core mtl safe stm
+       ];
+       testHaskellDepends = [
+         async base containers eventful-core eventful-test-helpers hlint
+         hspec HUnit mtl safe stm
+       ];
+       homepage = "https://github.com/jdreaver/eventful#readme";
+       description = "In-memory implementations for eventful";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "eventful-postgresql" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, eventful-core
+     , eventful-sql-common, eventful-test-helpers, hlint, hspec, HUnit
+     , mtl, persistent, persistent-postgresql, text
+     }:
+     mkDerivation {
+       pname = "eventful-postgresql";
+       version = "0.1.1";
+       sha256 = "9a2adf281dad1040204303dae81d3bfcf620626c54f6337209b24b1860da2c92";
+       libraryHaskellDepends = [
+         aeson base bytestring eventful-core eventful-sql-common mtl
+         persistent persistent-postgresql text
+       ];
+       testHaskellDepends = [
+         aeson base bytestring eventful-core eventful-sql-common
+         eventful-test-helpers hlint hspec HUnit mtl persistent
+         persistent-postgresql text
+       ];
+       homepage = "https://github.com/jdreaver/eventful#readme";
+       description = "Postgres implementations for eventful";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "eventful-sql-common" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, eventful-core, mtl
+     , persistent, persistent-template, split, text, uuid
+     }:
+     mkDerivation {
+       pname = "eventful-sql-common";
+       version = "0.1.1";
+       sha256 = "60a1bcc0643a088697856a4962ee0ab99e65fd69ef1e598f5ab981c6c98866f6";
+       libraryHaskellDepends = [
+         aeson base bytestring eventful-core mtl persistent
+         persistent-template split text uuid
+       ];
+       homepage = "https://github.com/jdreaver/eventful#readme";
+       description = "Common library for SQL event stores";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "eventful-sqlite" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, eventful-core
+     , eventful-sql-common, eventful-test-helpers, hlint, hspec, HUnit
+     , mtl, persistent, persistent-sqlite, text, uuid
+     }:
+     mkDerivation {
+       pname = "eventful-sqlite";
+       version = "0.1.1";
+       sha256 = "e4ebd1e761f60e1cadd033f44070fab21c96c43e923c2b22f292c96cd0dcdc2e";
+       libraryHaskellDepends = [
+         aeson base bytestring eventful-core eventful-sql-common mtl
+         persistent persistent-sqlite text uuid
+       ];
+       testHaskellDepends = [
+         aeson base bytestring eventful-core eventful-sql-common
+         eventful-test-helpers hlint hspec HUnit mtl persistent
+         persistent-sqlite text uuid
+       ];
+       homepage = "https://github.com/jdreaver/eventful#readme";
+       description = "SQLite implementations for eventful";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "eventful-test-helpers" = callPackage
+    ({ mkDerivation, aeson, aeson-casing, base, eventful-core, extra
+     , hspec, monad-logger
+     }:
+     mkDerivation {
+       pname = "eventful-test-helpers";
+       version = "0.1.1";
+       sha256 = "2fe935a290a66f7ecc5a52c33df06b1aa75e90fdf4212c4aa68c584b6a654356";
+       libraryHaskellDepends = [
+         aeson aeson-casing base eventful-core extra hspec monad-logger
+       ];
+       homepage = "https://github.com/jdreaver/eventful#readme";
+       description = "Common module used for eventful tests";
+       license = stdenv.lib.licenses.mit;
+     }) {};
+
   "eventloop" = callPackage
     ({ mkDerivation, aeson, base, bytestring, concurrent-utilities
      , deepseq, network, stm, suspend, text, timers, websockets
···
      }:
      mkDerivation {
        pname = "forest";
-       version = "0.1";
-       sha256 = "4de243b4eddddc534881617c6335e0658496ad67c2ebc65ba148b2965fe64460";
+       version = "0.1.1.1";
+       sha256 = "177b321ada64b8f396b643c1e9ada0e721ec7a02d408dda65d522a88e1fb243c";
        libraryHaskellDepends = [
          aeson base bifunctors deepseq hashable profunctors semigroupoids
        ];
···
      }) {};
 
   "haskeline-repl" = callPackage
-    ({ mkDerivation, ansi-terminal, base, haskeline, mtl }:
+    ({ mkDerivation, ansi-terminal, base, haskeline, mtl, safe }:
      mkDerivation {
        pname = "haskeline-repl";
-       version = "0.3.0.0";
-       sha256 = "0de972adbe908b3a6b3b2b681f5f3de0d4bb3deaa112179c643d4736e675e961";
-       libraryHaskellDepends = [ ansi-terminal base haskeline mtl ];
+       version = "0.4.0.0";
+       sha256 = "ee1fa50e447997eebc0a2218a1b6cb85e379054d22c016f6e248d7d6615e722d";
+       libraryHaskellDepends = [ ansi-terminal base haskeline mtl safe ];
        homepage = "https://github.com/githubuser/haskeline-repl#readme";
        license = stdenv.lib.licenses.bsd3;
      }) {};
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "haven" = callPackage
+    ({ mkDerivation, base, bytestring, containers, http-conduit
+     , http-types, mtl, SHA, xml
+     }:
+     mkDerivation {
+       pname = "haven";
+       version = "0.1.0.0";
+       sha256 = "0f1a0ae54594429d11fd11b6975aa2f115d0063f4687992a30048c8c75153598";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         base bytestring containers http-conduit http-types mtl SHA xml
+       ];
+       description = "Recursively retrieve maven dependencies";
+       license = stdenv.lib.licenses.bsd3;
+     }) {};
+
   "haverer" = callPackage
     ({ mkDerivation, base, basic-prelude, containers, errors, lens
      , MonadRandom, mtl, random-shuffle, tasty, tasty-hunit
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "hdaemonize_0_5_3" = callPackage
+    ({ mkDerivation, base, bytestring, extensible-exceptions, filepath
+     , hsyslog, mtl, unix
+     }:
+     mkDerivation {
+       pname = "hdaemonize";
+       version = "0.5.3";
+       sha256 = "a1884c7444ed11b86f4776dbfbabe42adff8a91de0a261747c30778ea50c6118";
+       libraryHaskellDepends = [
+         base bytestring extensible-exceptions filepath hsyslog mtl unix
+       ];
+       homepage = "http://github.com/greydot/hdaemonize";
+       description = "Library to handle the details of writing daemons for UNIX";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "hdaemonize-buildfix" = callPackage
     ({ mkDerivation, base, extensible-exceptions, filepath, hsyslog
      , mtl, unix
···
      }:
      mkDerivation {
        pname = "hdo";
-       version = "0.4";
-       sha256 = "b15832e660ec0072d50aea07fab0324a107b090d221446961dce20babffd69d0";
+       version = "0.5";
+       sha256 = "5a55fbb3a92c1d98656ac9cb62218a68ba760d699eeaf874c005d44b24b43d5a";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hexpat-lens";
-       version = "0.1.4";
-       sha256 = "35783e1bb8654ac74866b7910f7f58385a78d0005d05c26bc7efd36ca9827978";
+       version = "0.1.5";
+       sha256 = "cae65e389dbf69932e313cd45fec7fc2f7c45551c583773bc27059856a2f268d";
        libraryHaskellDepends = [
          base bytestring deepseq hexpat hexpat-tagsoup lens
        ];
···
 
   "hookup" = callPackage
     ({ mkDerivation, base, bytestring, HsOpenSSL, HsOpenSSL-x509-system
-     , network, openssl, socks, template-haskell
+     , network, openssl, socks
      }:
      mkDerivation {
        pname = "hookup";
-       version = "0.1.0.0";
-       sha256 = "0b321b470cb66f8b0d1611cbe26ec6d0c8904f984456bd2fbe292fb2efd8a580";
-       revision = "1";
-       editedCabalFile = "85316f17f206fc4fbff16d40ef7c50029b9abb1f1674298869be468b1d7eb7e3";
+       version = "0.1.1.0";
+       sha256 = "e5f0384d832304e4398b3fe7859962acbddbfbf5f2bd9d31ae5331cc459aeb85";
        libraryHaskellDepends = [
          base bytestring HsOpenSSL HsOpenSSL-x509-system network socks
-         template-haskell
        ];
        librarySystemDepends = [ openssl ];
        homepage = "https://github.com/glguy/irc-core";
···
      }:
      mkDerivation {
        pname = "hpack-convert";
-       version = "0.14.6";
-       sha256 = "80a439b06603e48f338ad4a08b0ffc54c0f0f97584a265f5fab5b31d8c03cb1c";
+       version = "1.0.0";
+       sha256 = "b551821123c5ce2d96d97f2ca7a763cb742ea6d8efc051ccf68501eb0cd32051";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "hpc-coveralls";
        version = "1.0.9";
        sha256 = "43ab8bda2e874cfc5690bca938ab3c84688fa332d2a70b390a490ea47bb73e74";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring Cabal cmdargs containers curl directory
+         directory-tree hpc process pureMD5 retry safe split transformers
+       ];
+       executableHaskellDepends = [
+         aeson async base bytestring Cabal cmdargs containers curl directory
+         directory-tree hpc process pureMD5 regex-posix retry safe split
+         transformers
+       ];
+       testHaskellDepends = [ base HUnit ];
+       homepage = "https://github.com/guillaume-nargeot/hpc-coveralls";
+       description = "Coveralls.io support for Haskell.";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "hpc-coveralls_1_0_10" = callPackage
+    ({ mkDerivation, aeson, async, base, bytestring, Cabal, cmdargs
+     , containers, curl, directory, directory-tree, hpc, HUnit, process
+     , pureMD5, regex-posix, retry, safe, split, transformers
+     }:
+     mkDerivation {
+       pname = "hpc-coveralls";
+       version = "1.0.10";
+       sha256 = "e222c0d36a6d266205957d0c71e1baeb1581847e79b0b5b9d883a4ef7381d0d9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "hsudoku";
-       version = "0.1.0.0";
-       sha256 = "d4f82611b75c8da0c9ac4ede33c2e22bd23853e54fd09362adc4911047139e29";
+       version = "0.1.0.1";
+       sha256 = "867bbfeb6660321e5a2927091db581f160805315fac22d4a47a43da4e8aa49ac";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        homepage = "http://github.com/peti/hsyslog";
        description = "FFI interface to syslog(3) from POSIX.1-2001";
        license = stdenv.lib.licenses.bsd3;
+       maintainers = with stdenv.lib.maintainers; [ peti ];
+     }) {};
+
+  "hsyslog_5" = callPackage
+    ({ mkDerivation, base, doctest }:
+     mkDerivation {
+       pname = "hsyslog";
+       version = "5";
+       sha256 = "4d2fca67cec22c14379e35b3d03d5dd09ced4aefd253ef0c7489cb964e58f91a";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base doctest ];
+       homepage = "http://github.com/peti/hsyslog";
+       description = "FFI interface to syslog(3) from POSIX.1-2001";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
        maintainers = with stdenv.lib.maintainers; [ peti ];
      }) {};
 
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
-  "http-client_0_4_31_2" = callPackage
-    ({ mkDerivation, array, async, base, base64-bytestring
-     , blaze-builder, bytestring, case-insensitive, containers, cookie
-     , data-default-class, deepseq, directory, exceptions, filepath
-     , ghc-prim, hspec, http-types, mime-types, monad-control, network
-     , network-uri, random, streaming-commons, text, time, transformers
-     , zlib
-     }:
-     mkDerivation {
-       pname = "http-client";
-       version = "0.4.31.2";
-       sha256 = "16410148a9705677cdd89510192caf1abd3460db2a17ce0c2fafd7bd0c15d88b";
-       libraryHaskellDepends = [
-         array base base64-bytestring blaze-builder bytestring
-         case-insensitive containers cookie data-default-class deepseq
-         exceptions filepath ghc-prim http-types mime-types network
-         network-uri random streaming-commons text time transformers
-       ];
-       testHaskellDepends = [
-         async base base64-bytestring blaze-builder bytestring
-         case-insensitive containers deepseq directory hspec http-types
-         monad-control network network-uri streaming-commons text time
-         transformers zlib
-       ];
-       doCheck = false;
-       homepage = "https://github.com/snoyberg/http-client";
-       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
-       license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
-     }) {};
-
   "http-client" = callPackage
     ({ mkDerivation, array, async, base, base64-bytestring
      , blaze-builder, bytestring, case-insensitive, containers, cookie
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
-  "http-client-tls_0_2_4_1" = callPackage
-    ({ mkDerivation, base, bytestring, connection, data-default-class
-     , hspec, http-client, http-types, network, tls
+  "http-client-tls" = callPackage
+    ({ mkDerivation, base, bytestring, case-insensitive, connection
+     , containers, criterion, cryptonite, data-default-class, exceptions
+     , hspec, http-client, http-types, memory, network, network-uri
+     , text, tls, transformers
      }:
      mkDerivation {
        pname = "http-client-tls";
-       version = "0.2.4.1";
-       sha256 = "8dc85884e15cd32f59a47e11861d78566c6ccb202e8d317403b784278f628ba3";
-       revision = "1";
-       editedCabalFile = "26f1b0cf1b449df4fce7c4531444ff06ccfacae528d20c5470461ecc4058f56c";
+       version = "0.3.4.1";
+       sha256 = "b08fed2f18a03eeac5e2db6caf15fd8922032cd9dd50412b67146948ac6b7cd5";
        libraryHaskellDepends = [
-         base bytestring connection data-default-class http-client network
-         tls
+         base bytestring case-insensitive connection containers cryptonite
+         data-default-class exceptions http-client http-types memory network
+         network-uri text tls transformers
        ];
        testHaskellDepends = [ base hspec http-client http-types ];
+       benchmarkHaskellDepends = [ base criterion http-client ];
        doCheck = false;
        homepage = "https://github.com/snoyberg/http-client";
        description = "http-client backend using the connection package and tls library";
        license = stdenv.lib.licenses.mit;
-       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
-  "http-client-tls" = callPackage
+  "http-client-tls_0_3_4_2" = callPackage
     ({ mkDerivation, base, bytestring, case-insensitive, connection
      , containers, criterion, cryptonite, data-default-class, exceptions
      , hspec, http-client, http-types, memory, network, network-uri
···
      }:
      mkDerivation {
        pname = "http-client-tls";
-       version = "0.3.4.1";
-       sha256 = "b08fed2f18a03eeac5e2db6caf15fd8922032cd9dd50412b67146948ac6b7cd5";
+       version = "0.3.4.2";
+       sha256 = "e8bf82330a3c6bd802cc25ff142fb950a1f48eec3f7ad5b4a000445499fdfd4b";
        libraryHaskellDepends = [
          base bytestring case-insensitive connection containers cryptonite
          data-default-class exceptions http-client http-types memory network
···
        homepage = "https://github.com/snoyberg/http-client";
        description = "http-client backend using the connection package and tls library";
        license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "http-common" = callPackage
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "http-streams_0_8_5_3" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, attoparsec, base
+     , base64-bytestring, blaze-builder, bytestring, Cabal
+     , case-insensitive, directory, ghc-prim, HsOpenSSL, hspec
+     , hspec-expectations, http-common, HUnit, io-streams, lifted-base
+     , mtl, network, network-uri, openssl-streams, snap-core
+     , snap-server, system-fileio, system-filepath, text, transformers
+     , unordered-containers
+     }:
+     mkDerivation {
+       pname = "http-streams";
+       version = "0.8.5.3";
+       sha256 = "cadaf4f52af24bf14bc0b0991c1d040e315622301796db30000da5f67b2ee5e3";
+       setupHaskellDepends = [ base Cabal ];
+       libraryHaskellDepends = [
+         aeson attoparsec base base64-bytestring blaze-builder bytestring
+         case-insensitive directory HsOpenSSL http-common io-streams mtl
+         network network-uri openssl-streams text transformers
+         unordered-containers
+       ];
+       testHaskellDepends = [
+         aeson aeson-pretty attoparsec base base64-bytestring blaze-builder
+         bytestring case-insensitive directory ghc-prim HsOpenSSL hspec
+         hspec-expectations http-common HUnit io-streams lifted-base mtl
+         network network-uri openssl-streams snap-core snap-server
+         system-fileio system-filepath text transformers
+         unordered-containers
+       ];
+       homepage = "http://github.com/afcowie/http-streams/";
+       description = "An HTTP client using io-streams";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "http-test" = callPackage
     ({ mkDerivation, aeson, base, bytestring, http-client, lens
      , lens-aeson, mtl, tasty, tasty-hunit, text, time, wreq
···
      }:
      mkDerivation {
        pname = "irc-core";
-       version = "2.2.0.1";
-       sha256 = "6c160d1073ee40b12d294f1e4dbb4691aedb73150eebf027475db05ce1efa20a";
-       revision = "3";
-       editedCabalFile = "25efc74edbc492b37b04370b493ff942fc3d4223d3e1c2368d85c2ad3e166604";
+       version = "2.2.1";
+       sha256 = "ec6275f2076203b7060eb3dfed9b852849efbdf9aa791d1e59b341b5044b52e0";
        libraryHaskellDepends = [
          attoparsec base base64-bytestring bytestring hashable primitive
          text time vector
···
 
   "jenga" = callPackage
     ({ mkDerivation, aeson, base, bytestring, Cabal, containers
-     , http-conduit, http-types, text
+     , http-conduit, http-types, optparse-applicative, text, yaml
      }:
      mkDerivation {
        pname = "jenga";
-       version = "0.1.0.0";
-       sha256 = "4468d8a1c55009b146b8294ab9ed677b5c7a5e3d0fbae1825a5aebcd509412d0";
+       version = "0.1.1.0";
+       sha256 = "1339d5148f1715f9437ec839ffc3714e653005bd707db6a03e044f99f1971629";
+       revision = "1";
+       editedCabalFile = "641105037f2a906a5caa2779b29761381cbfffd522f92988a0743583d425e604";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson base bytestring Cabal containers http-conduit http-types text
+         yaml
        ];
-       executableHaskellDepends = [ base text ];
+       executableHaskellDepends = [ base optparse-applicative text ];
        homepage = "https://github.com/erikd/jenga";
        description = "Generate a cabal freeze file from a stack.yaml";
        license = stdenv.lib.licenses.bsd2;
···
        license = stdenv.lib.licenses.gpl3;
      }) {};
 
+  "language-dockerfile_0_3_6_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, directory, filepath, free
+     , Glob, hspec, HUnit, mtl, parsec, pretty, process, QuickCheck
+     , ShellCheck, split, template-haskell, test-framework
+     , test-framework-hunit, text, th-lift, th-lift-instances
+     , transformers, unordered-containers, yaml
+     }:
+     mkDerivation {
+       pname = "language-dockerfile";
+       version = "0.3.6.0";
+       sha256 = "f68edd01fdc2d779d7defd6c33663b7c7358c489988eae075b4a2d1cd0b71bb7";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring directory filepath free Glob mtl parsec
+         pretty ShellCheck split template-haskell text th-lift
+         th-lift-instances transformers unordered-containers yaml
+       ];
+       testHaskellDepends = [
+         aeson base bytestring directory filepath free Glob hspec HUnit mtl
+         parsec pretty process QuickCheck ShellCheck split template-haskell
+         test-framework test-framework-hunit text th-lift th-lift-instances
+         transformers unordered-containers yaml
+       ];
+       homepage = "https://github.com/beijaflor-io/language-dockerfile#readme";
+       description = "Dockerfile linter, parser, pretty-printer and embedded DSL";
+       license = stdenv.lib.licenses.gpl3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "language-dot" = callPackage
     ({ mkDerivation, base, mtl, parsec, pretty }:
      mkDerivation {
···
      }:
      mkDerivation {
        sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
-       version = "0.2.0";
-       sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
+       version = "0.2.1";
+       sha256 = "84cceef3f6c66ed3065fc7b82093790e46defb0d92e80d87faa321d7201d1101";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
-       version = "0.2.0";
-       sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
+       version = "0.2.1";
+       sha256 = "e88815835e1390970416e60e0f42a982a7abb891a992ba569c67f8db956fc448";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "microformats2-parser_1_0_1_7" = callPackage
+       sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
+       sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
+       sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
+       sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
+       sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
+     , scotty, tagsoup, template-haskell, text, time, transformers
+     , unordered-containers, vector, wai-cli, wai-extra, xml-lens
+       sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
+     }:
+     mkDerivation {
+       sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
+       version = "1.0.1.7";
+       sha256 = "def0a462fcfaa344629ee05ced7a93593bad2749148873b4f4c63e3f0c6758f1";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+       sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
+       sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
+       sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
+       sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
+       ];
+       executableHaskellDepends = [
+       sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
+         data-default network network-uri options scotty text wai-cli
+         wai-extra
+       ];
+       testHaskellDepends = [
+       sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
+       sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
+       sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
+       ];
+       sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
+       sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
+       license = stdenv.lib.licenses.publicDomain;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
        sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
        sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
        sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "monad-logger-syslog_0_1_4_0" = callPackage
+    ({ mkDerivation, base, bytestring, fast-logger, hsyslog
+     , monad-logger, text, transformers
+     }:
+     mkDerivation {
+       pname = "monad-logger-syslog";
+       version = "0.1.4.0";
+       sha256 = "052c3e13e235e7fb31caecc117e3ab4629e85bbfd3b35ec03f74d732acbc9ccb";
+       libraryHaskellDepends = [
+         base bytestring fast-logger hsyslog monad-logger text transformers
+       ];
+       homepage = "https://github.com/fpco/monad-logger-syslog";
+       description = "syslog output for monad-logger";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "monad-loops" = callPackage
     ({ mkDerivation, base, tasty, tasty-hunit }:
      mkDerivation {
···
        libraryHaskellDepends = [ base ];
        description = "list mount points";
        license = "LGPL";
+     }) {};
+
+  "moving-averages" = callPackage
+    ({ mkDerivation, base, hspec }:
+     mkDerivation {
+       pname = "moving-averages";
+       version = "0.2.0.0";
+       sha256 = "368915f86b19a3328ebd14adb2a0822670b5e3aa3dd4a6c07543dd602ae7798b";
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [ base hspec ];
+       homepage = "https://github.com/joshuaclayton/moving-averages#readme";
+       description = "This is a library for calculating moving averages on lists of numbers";
+       license = stdenv.lib.licenses.mit;
      }) {};
 
   "mp" = callPackage
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
+  "mustache_2_1_4" = callPackage
+    ({ mkDerivation, aeson, base, base-unicode-symbols, bytestring
+     , cmdargs, containers, directory, either, filepath, hspec, lens
+     , mtl, parsec, process, scientific, tar, template-haskell
+     , temporary, text, th-lift, unordered-containers, vector, wreq
+     , yaml, zlib
+     }:
+     mkDerivation {
+       pname = "mustache";
+       version = "2.1.4";
+       sha256 = "1c574cb80701a0acf91d65d8921f26cdc3228b747b7fb351a16da74d10f05cdb";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring containers directory either filepath mtl
+         parsec scientific template-haskell text th-lift
+         unordered-containers vector
+       ];
+       executableHaskellDepends = [
+         aeson base bytestring cmdargs filepath text yaml
+       ];
+       testHaskellDepends = [
+         aeson base base-unicode-symbols bytestring directory filepath hspec
+         lens process tar temporary text unordered-containers wreq yaml zlib
+       ];
+       homepage = "https://github.com/JustusAdam/mustache";
+       description = "A mustache template parser library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "mustache-haskell" = callPackage
     ({ mkDerivation, aeson, base, bytestring, directory
      , optparse-applicative, parsec, pretty-show, scientific, text
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
-  "optparse-applicative_0_13_1_0" = callPackage
-    ({ mkDerivation, ansi-wl-pprint, base, process, QuickCheck
-     , transformers, transformers-compat
-     }:
-     mkDerivation {
-       pname = "optparse-applicative";
-       version = "0.13.1.0";
-       sha256 = "f1fcf9d7e78ddf14083a07d8fe1aa65d75c5102e0d44df981585bce54c5c2a2b";
-       libraryHaskellDepends = [
-         ansi-wl-pprint base process transformers transformers-compat
-       ];
-       testHaskellDepends = [ base QuickCheck ];
-       homepage = "https://github.com/pcapriotti/optparse-applicative";
-       description = "Utilities and combinators for parsing command line options";
-       license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-     }) {};
-
   "optparse-applicative" = callPackage
     ({ mkDerivation, ansi-wl-pprint, base, process, QuickCheck
      , transformers, transformers-compat
···
        ];
        description = "Auto-generate a command-line parser for your datatype";
        license = stdenv.lib.licenses.bsd3;
+     }) {};
+
+  "optparse-generic_1_2_0" = callPackage
+    ({ mkDerivation, base, bytestring, optparse-applicative, semigroups
+     , system-filepath, text, time, transformers, void
+     }:
+     mkDerivation {
+       pname = "optparse-generic";
+       version = "1.2.0";
+       sha256 = "879295b1aa56f63079b7a776c132e4047d088d21a0120f5dd1d4429619cf1bfe";
+       libraryHaskellDepends = [
+         base bytestring optparse-applicative semigroups system-filepath
+         text time transformers void
+       ];
+       description = "Auto-generate a command-line parser for your datatype";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "optparse-helper" = callPackage
···
        sha256 = "f6ee216db7be14d497c428562c83423a5d2579c86b70b822996bde28c196569c";
        revision = "1";
        editedCabalFile = "dc27254b2fb36077e39a78632a392c4dc5beca2b9dcc536fea0ee2532a453263";
+       libraryHaskellDepends = [ base template-haskell ];
+       homepage = "http://www.informatik.uni-marburg.de/~rendel/unparse";
+       description = "Partial isomorphisms";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "partial-isomorphisms_0_2_2_1" = callPackage
+    ({ mkDerivation, base, template-haskell }:
+     mkDerivation {
+       pname = "partial-isomorphisms";
+       version = "0.2.2.1";
+       sha256 = "4c551fa69119e87de1ba0ec7b854f6ed13fb2fe2768db4afff2f8468f0f4a164";
        libraryHaskellDepends = [ base template-haskell ];
        homepage = "http://www.informatik.uni-marburg.de/~rendel/unparse";
        description = "Partial isomorphisms";
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "pinch_0_3_1_0" = callPackage
+    ({ mkDerivation, array, base, bytestring, containers, deepseq
+     , ghc-prim, hashable, hspec, hspec-discover, QuickCheck, text
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "pinch";
+       version = "0.3.1.0";
+       sha256 = "6f8baa41a26fbe46b66a9b8b24886db7e7883e9cf175eb5690cdd043135d85bf";
+       libraryHaskellDepends = [
+         array base bytestring containers deepseq ghc-prim hashable text
+         unordered-containers vector
+       ];
+       testHaskellDepends = [
+         base bytestring containers hspec hspec-discover QuickCheck text
+         unordered-containers vector
+       ];
+       homepage = "https://github.com/abhinav/pinch#readme";
+       description = "An alternative implementation of Thrift for Haskell";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "pinchot" = callPackage
     ({ mkDerivation, base, containers, Earley, lens, pretty-show
      , semigroups, template-haskell, transformers
···
        license = stdenv.lib.licenses.bsd2;
      }) {};
 
-  "pipes_4_2_0" = callPackage
-    ({ mkDerivation, base, criterion, mmorph, mtl, optparse-applicative
-     , QuickCheck, test-framework, test-framework-quickcheck2
-     , transformers
-     }:
-     mkDerivation {
-       pname = "pipes";
-       version = "4.2.0";
-       sha256 = "1e407197e94c3c8642fd2c7b4f8e5a3e537844dff2780c396464a47ae0ec0124";
-       revision = "1";
-       editedCabalFile = "1ce0aac0a280be337215bcf2a8b73b081a948bfb93e24045a7e3a3c3e6adfad0";
-       libraryHaskellDepends = [ base mmorph mtl transformers ];
-       testHaskellDepends = [
-         base mtl QuickCheck test-framework test-framework-quickcheck2
-         transformers
-       ];
-       benchmarkHaskellDepends = [
-         base criterion mtl optparse-applicative transformers
-       ];
-       description = "Compositional pipelines";
-       license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-     }) {};
-
   "pipes" = callPackage
     ({ mkDerivation, base, criterion, exceptions, mmorph, mtl
      , optparse-applicative, QuickCheck, test-framework
···
      }:
      mkDerivation {
        pname = "pipes-lzma";
-       version = "0.1.1.0";
-       sha256 = "8d5af5806d20ac9b8e0b416a0c36cb6b8039ac55c0cb2831252a8f6c75da01f2";
+       version = "0.1.1.1";
+       sha256 = "24a78698af0437d6b7061141d50cd9ac83b98a81c1d42b5f32a214e87297cd26";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [ base bytestring lzma pipes ];
···
      }:
      mkDerivation {
        pname = "postgrest-ws";
-       version = "0.2.0.0";
-       sha256 = "a774a73c7c0bb3ef10e5b96c66749323a9b9244d1e46bcdc3cbd513b9887d42a";
+       version = "0.3.1.0";
+       sha256 = "8216b0f87486335192bc7811dde9564527f03f8c24893af57e916f3b91c07881";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
-  "relational-query-HDBC_0_6_1_0" = callPackage
+  "relational-query-HDBC_0_6_2_0" = callPackage
     ({ mkDerivation, base, containers, convertible, dlist, HDBC
      , HDBC-session, names-th, persistable-record, relational-query
      , relational-schemas, template-haskell, th-data-compat
···
      }:
      mkDerivation {
        pname = "relational-query-HDBC";
-       version = "0.6.1.0";
-       sha256 = "377ce34c521df92099a82915a16b776aa14e9dc0a5c1e644a91150a0d3e29d0c";
+       version = "0.6.2.0";
+       sha256 = "23f792a3249de1dc516be8fa45f0302b7a06139788a423745c2cb1168b983871";
        libraryHaskellDepends = [
          base containers convertible dlist HDBC HDBC-session names-th
          persistable-record relational-query relational-schemas
···
      }:
      mkDerivation {
        pname = "sbp";
-       version = "2.2.0";
-       sha256 = "4964d3c77c2b9ddc0da60a2cbd26820628f796f463ca41d6fc243e3c93ad69bd";
+       version = "2.2.1";
+       sha256 = "1976f73f04b3115d765a475a10d1e92e936077cf484757210fc65ab0bffc49e1";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
+  "search-algorithms_0_2_0" = callPackage
+    ({ mkDerivation, base, containers, doctest, hspec }:
+     mkDerivation {
+       pname = "search-algorithms";
+       version = "0.2.0";
+       sha256 = "73839172aa5cd99e99e39edada80126fc131f05069e46d0d31c9f3a9441988cf";
+       libraryHaskellDepends = [ base containers ];
+       testHaskellDepends = [ base containers doctest hspec ];
+       homepage = "https://github.com/devonhollowood/search-algorithms#readme";
+       description = "Common graph search algorithms";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "sec" = callPackage
     ({ mkDerivation, base, template-haskell }:
      mkDerivation {
···
        pname = "selda";
        version = "0.1.6.0";
        sha256 = "f9c615d3f37deb2eb2169d9a901198cb1216ceef576128f9f9b0e0363dd434bd";
-       revision = "1";
-       editedCabalFile = "2adda3c7bbe009fad6df92f2dee2384356e24d2ed0f05ef8c37608635167ab4d";
+       revision = "2";
+       editedCabalFile = "1984c9def6f245d8c7e20f578bbe0dd4217059dcd65901a36b298251f70ecb3f";
        libraryHaskellDepends = [
          base exceptions hashable mtl psqueues text time
          unordered-containers
···
        pname = "servant-js";
        version = "0.9.3";
        sha256 = "086905a2c5d8903910b415b71f007c28cb6de9bccc4ab273e7ed944ceeca2cc2";
-       revision = "1";
-       editedCabalFile = "d1012bbe974704eef8d067abd6051846b8262290911c54f87fb1f10f1d9e6dcf";
+       revision = "2";
+       editedCabalFile = "fc952cd50824cfaa61027f1b3addae7659f6ad4a757f1a07cbbce68284d28d54";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "Bindings to the Pushbullet API using servant-client";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "servant-py" = callPackage
+    ({ mkDerivation, aeson, base, base-compat, bytestring, charset
+     , hspec, hspec-expectations, lens, QuickCheck, servant
+     , servant-foreign, text
+     }:
+     mkDerivation {
+       pname = "servant-py";
+       version = "0.1.0.4";
+       sha256 = "a6fb12ea493ea42fb26bfec0c6fa6db6292a1eb38876ad20e311f8e02d678431";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson base bytestring charset lens servant servant-foreign text
+       ];
+       testHaskellDepends = [
+         aeson base base-compat bytestring hspec hspec-expectations lens
+         QuickCheck servant servant-foreign text
+       ];
+       homepage = "https://github.com/pellagic-puffbomb/servant-py#readme";
+       description = "Automatically derive python functions to query servant webservices";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "servant-quickcheck" = callPackage
···
 
   "stack-run" = callPackage
     ({ mkDerivation, ansi-terminal, async, base, bytestring, Cabal
-     , conduit, conduit-extra, directory, filepath, MissingH
-     , projectroot, stm, terminal-size, time, vty
+     , conduit, conduit-extra, directory, filepath, MissingH, stm
+     , terminal-size, time, vty
      }:
      mkDerivation {
        pname = "stack-run";
-       version = "0.1.1.3";
-       sha256 = "5e70f11916ca2fe00e86b78ba0aa0762b8fe98b34881247035d25273f41ecaf7";
+       version = "0.1.1.4";
+       sha256 = "7366bb6519949fd7e929a8a6ba04b2877b0fa7a5a1aa1e594ebf0ac59b06ac9b";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
          ansi-terminal async base bytestring Cabal conduit conduit-extra
-         directory filepath MissingH projectroot stm terminal-size time vty
+         directory filepath MissingH stm terminal-size time vty
        ];
        homepage = "https://github.com/yamadapc/stack-run";
        description = "An equivalent to cabal run for stack";
···
      }:
      mkDerivation {
        pname = "staversion";
-       version = "0.1.4.0";
-       sha256 = "f09fd5ad180ddac974201de99eaf74ff6d63cc172857f9d41379eb1707eda09a";
+       version = "0.2.0.0";
+       sha256 = "f95cbd5547606c56f31dec76f89a2e33de8c8663fe36cbd55bfb8aa085a9a56b";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }) {};
 
   "structs" = callPackage
-    ({ mkDerivation, base, deepseq, directory, doctest, filepath
-     , ghc-prim, hlint, parallel, primitive
+    ({ mkDerivation, base, Cabal, cabal-doctest, deepseq, directory
+     , doctest, filepath, ghc-prim, hlint, parallel, primitive
+     , template-haskell
      }:
      mkDerivation {
        pname = "structs";
-       version = "0";
-       sha256 = "4ba635175f9db39b13d7ba7ecb2158c1c4228f33d0831e9dd48e5e247cda3970";
-       libraryHaskellDepends = [ base deepseq ghc-prim primitive ];
+       version = "0.1";
+       sha256 = "1f0a20e43bed6a0a0c1e05e442a2f2ce0bd67c277b5e380aac2e17332e834f41";
+       setupHaskellDepends = [ base Cabal cabal-doctest ];
+       libraryHaskellDepends = [
+         base deepseq ghc-prim primitive template-haskell
+       ];
        testHaskellDepends = [
          base directory doctest filepath hlint parallel
        ];
···
      }) {};
 
   "threepenny-editors" = callPackage
-    ({ mkDerivation, base, profunctors, threepenny-gui }:
+    ({ mkDerivation, base, data-default, generics-sop, profunctors
+     , threepenny-gui
+     }:
      mkDerivation {
        pname = "threepenny-editors";
-       version = "0.2.0.2";
-       sha256 = "cbcfa4cea3f4f72c95fc334b02bda6e3c5657d0b8378b0e307feeb7f9237c95a";
+       version = "0.2.0.5";
+       sha256 = "905090859bd221d51aeba34b691ad84fb9193d52ddd98659093acba16fd5d970";
        isLibrary = true;
        isExecutable = true;
-       libraryHaskellDepends = [ base profunctors threepenny-gui ];
+       libraryHaskellDepends = [
+         base data-default generics-sop profunctors threepenny-gui
+       ];
        homepage = "https://github.com/pepeiborra/threepenny-editors";
        description = "Composable algebraic editors";
        license = stdenv.lib.licenses.bsd3;
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
-  "time_1_8_0_1" = callPackage
+  "time_1_8_0_2" = callPackage
     ({ mkDerivation, base, deepseq, QuickCheck, random, tasty
      , tasty-hunit, tasty-quickcheck, unix
      }:
      mkDerivation {
        pname = "time";
-       version = "1.8.0.1";
-       sha256 = "2baa9fdc280604413ecaf9761f7fd3443fe69019eec6fdc3e0333501fe701701";
+       version = "1.8.0.2";
+       sha256 = "40642d965caca8c18950f0812e88ae061aa670fc2b3a8bf70e95b74927f11095";
        libraryHaskellDepends = [ base deepseq ];
        testHaskellDepends = [
          base deepseq QuickCheck random tasty tasty-hunit tasty-quickcheck
···
      }:
      mkDerivation {
        pname = "tmapchan";
-       version = "0.0.1";
-       sha256 = "c9c5c7547d8cd430c118a64b794fdb0726284e5ac8b135f87dbf89e1ca514f03";
+       version = "0.0.3";
+       sha256 = "e86db4c2e6cdd373b0cbe91e01d2a223c95d5d36930f5a6c484c1586ae5011e0";
        libraryHaskellDepends = [
          base containers hashable stm unordered-containers
        ];
        homepage = "https://github.com/athanclark/tmapchan#readme";
-       description = "A time-ordered multimap which consumes values as you lookup";
+       description = "An insert-ordered multimap (indexed FIFO) which consumes values as you lookup";
        license = stdenv.lib.licenses.bsd3;
      }) {};
 
···
        hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
-  "websockets_0_9_8_2" = callPackage
-    ({ mkDerivation, attoparsec, base, base64-bytestring, binary
-     , blaze-builder, bytestring, case-insensitive, containers, entropy
-     , HUnit, network, QuickCheck, random, SHA, test-framework
-     , test-framework-hunit, test-framework-quickcheck2, text
-     }:
-     mkDerivation {
-       pname = "websockets";
-       version = "0.9.8.2";
-       sha256 = "09ec17dfbf9f07da27575ce7853b0c80d87ad959c2b271f27be4c4e54615eca2";
-       isLibrary = true;
-       isExecutable = true;
-       libraryHaskellDepends = [
-         attoparsec base base64-bytestring binary blaze-builder bytestring
-         case-insensitive containers entropy network random SHA text
-       ];
-       testHaskellDepends = [
-         attoparsec base base64-bytestring binary blaze-builder bytestring
-         case-insensitive containers entropy HUnit network QuickCheck random
-         SHA test-framework test-framework-hunit test-framework-quickcheck2
-         text
-       ];
-       doCheck = false;
-       homepage = "http://jaspervdj.be/websockets";
-       description = "A sensible and clean way to write WebSocket-capable servers in Haskell";
-       license = stdenv.lib.licenses.bsd3;
-       hydraPlatforms = stdenv.lib.platforms.none;
-     }) {};
-
   "websockets" = callPackage
     ({ mkDerivation, attoparsec, base, base64-bytestring, binary
      , blaze-builder, bytestring, case-insensitive, containers, entropy
···
 
   "websockets-simple" = callPackage
     ({ mkDerivation, aeson, async, base, bytestring, every, exceptions
-     , monad-control, stm, wai-transformers, websockets
+     , hspec, monad-control, stm, tasty, tasty-hspec, wai-transformers
+     , websockets
      }:
      mkDerivation {
        pname = "websockets-simple";
-       version = "0.0.5";
-       sha256 = "5cfcbd9d6d5fe4f6420d8e677dcd3761da53254f6267f6d480fc85ab87191a97";
+       version = "0.0.6";
+       sha256 = "dc1cc1b45c86f6448ff8b1749b6916f32cc2deef547389c27bbd55f5395798f8";
        libraryHaskellDepends = [
          aeson async base bytestring every exceptions monad-control stm
          wai-transformers websockets
        ];
+       testHaskellDepends = [ base hspec stm tasty tasty-hspec ];
        homepage = "https://github.com/athanclark/websockets-simple#readme";
        description = "Simpler interface to the websockets api";
        license = stdenv.lib.licenses.bsd3;
···
        pname = "websockets-snap";
        version = "0.10.2.1";
        sha256 = "4264992c29f800b9623632fc366094ebbfe6353fb0e346f0a51519afed3586af";
+       libraryHaskellDepends = [
+         base bytestring bytestring-builder io-streams mtl snap-core
+         snap-server websockets
+       ];
+       description = "Snap integration for the websockets library";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "websockets-snap_0_10_2_2" = callPackage
+    ({ mkDerivation, base, bytestring, bytestring-builder, io-streams
+     , mtl, snap-core, snap-server, websockets
+     }:
+     mkDerivation {
+       pname = "websockets-snap";
+       version = "0.10.2.2";
+       sha256 = "bcc3bbb7117a7ced50f83b6ddc31aeb9a1a4df6d1ce0d95662c45a3c577678d8";
        libraryHaskellDepends = [
          base bytestring bytestring-builder io-streams mtl snap-core
          snap-server websockets
···
        pname = "xdcc";
        version = "1.1.4";
        sha256 = "a9c4f4c904bb6d4c634b224eb0587babc60cbee51a9d7ed6a487f138df266464";
+       revision = "1";
+       editedCabalFile = "adf70fcc1a9a57f95976fd6a6b38671e939fb02b8c6f1a73740687e02d27e27e";
        isLibrary = false;
        isExecutable = true;
        executableHaskellDepends = [
···
        license = stdenv.lib.licenses.bsd3;
      }) {inherit (pkgs) libyaml;};
 
+  "yaml_0_8_22_1" = callPackage
+    ({ mkDerivation, aeson, aeson-qq, attoparsec, base, base-compat
+     , bytestring, conduit, containers, directory, filepath, hspec
+     , HUnit, libyaml, mockery, resourcet, scientific, semigroups
+     , template-haskell, temporary, text, transformers
+     , unordered-containers, vector
+     }:
+     mkDerivation {
+       pname = "yaml";
+       version = "0.8.22.1";
+       sha256 = "dd6c0ae5a641e7fbd1fd9b157a6c1bb9cac2db4701eaef6acbbbf6f41a807b6b";
+       configureFlags = [ "-fsystem-libyaml" ];
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson attoparsec base bytestring conduit containers directory
+         filepath resourcet scientific semigroups template-haskell text
+         transformers unordered-containers vector
+       ];
+       libraryPkgconfigDepends = [ libyaml ];
+       executableHaskellDepends = [ aeson base bytestring ];
+       testHaskellDepends = [
+         aeson aeson-qq base base-compat bytestring conduit directory hspec
+         HUnit mockery resourcet temporary text transformers
+         unordered-containers vector
+       ];
+       homepage = "http://github.com/snoyberg/yaml/";
+       description = "Support for parsing and rendering YAML documents";
+       license = stdenv.lib.licenses.bsd3;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {inherit (pkgs) libyaml;};
+
   "yaml-combinators" = callPackage
     ({ mkDerivation, aeson, base, bytestring, doctest, generics-sop
      , scientific, tasty, tasty-hunit, text, transformers
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "yesod-auth_1_4_17_1" = callPackage
+    ({ mkDerivation, aeson, authenticate, base, base16-bytestring
+     , base64-bytestring, binary, blaze-builder, blaze-html
+     , blaze-markup, byteable, bytestring, conduit, conduit-extra
+     , containers, cryptohash, data-default, email-validate, file-embed
+     , http-client, http-conduit, http-types, lifted-base, mime-mail
+     , network-uri, nonce, persistent, persistent-template, random
+     , resourcet, safe, shakespeare, template-haskell, text, time
+     , transformers, unordered-containers, wai, yesod-core, yesod-form
+     , yesod-persistent
+     }:
+     mkDerivation {
+       pname = "yesod-auth";
+       version = "1.4.17.1";
+       sha256 = "f8787f7aa8550b7b60f0fbf8798a0be644a06fb3b8a47d1aa06bdccecfe43535";
+       libraryHaskellDepends = [
+         aeson authenticate base base16-bytestring base64-bytestring binary
+         blaze-builder blaze-html blaze-markup byteable bytestring conduit
+         conduit-extra containers cryptohash data-default email-validate
+         file-embed http-client http-conduit http-types lifted-base
+         mime-mail network-uri nonce persistent persistent-template random
+         resourcet safe shakespeare template-haskell text time transformers
+         unordered-containers wai yesod-core yesod-form yesod-persistent
+       ];
+       homepage = "http://www.yesodweb.com/";
+       description = "Authentication for Yesod";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "yesod-auth-account" = callPackage
     ({ mkDerivation, base, blaze-html, bytestring, hspec, monad-logger
      , mtl, nonce, persistent, persistent-sqlite, pwstore-fast
···
        license = stdenv.lib.licenses.mit;
      }) {};
 
+  "yesod-bin_1_5_2_3" = callPackage
+    ({ mkDerivation, async, attoparsec, base, base64-bytestring
+     , blaze-builder, bytestring, Cabal, conduit, conduit-extra
+     , containers, data-default-class, deepseq, directory, file-embed
+     , filepath, fsnotify, http-client, http-client-tls
+     , http-reverse-proxy, http-types, lifted-base, network
+     , optparse-applicative, parsec, process, project-template
+     , resourcet, safe-exceptions, say, shakespeare, split, stm
+     , streaming-commons, tar, template-haskell, text, time
+     , transformers, transformers-compat, typed-process, unix-compat
+     , unordered-containers, wai, wai-extra, warp, warp-tls, yaml, zlib
+     }:
+     mkDerivation {
+       pname = "yesod-bin";
+       version = "1.5.2.3";
+       sha256 = "eeabc3579d7834c6fc0890c5bdf27c52f84cc2bd3b44b4153f4a9320d3d123f6";
+       isLibrary = false;
+       isExecutable = true;
+       executableHaskellDepends = [
+         async attoparsec base base64-bytestring blaze-builder bytestring
+         Cabal conduit conduit-extra containers data-default-class deepseq
+         directory file-embed filepath fsnotify http-client http-client-tls
+         http-reverse-proxy http-types lifted-base network
+         optparse-applicative parsec process project-template resourcet
+         safe-exceptions say shakespeare split stm streaming-commons tar
+         template-haskell text time transformers transformers-compat
+         typed-process unix-compat unordered-containers wai wai-extra warp
+         warp-tls yaml zlib
+       ];
+       homepage = "http://www.yesodweb.com/";
+       description = "The yesod helper executable";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
   "yesod-bootstrap" = callPackage
     ({ mkDerivation, base, blaze-html, blaze-markup, bootstrap-types
      , shakespeare, text, transformers, yesod-core, yesod-elements
···
        homepage = "http://www.yesodweb.com/";
        description = "Form handling support for Yesod Web Framework";
        license = stdenv.lib.licenses.mit;
+     }) {};
+
+  "yesod-form_1_4_12" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, blaze-html
+     , blaze-markup, byteable, bytestring, containers, data-default
+     , email-validate, hspec, network-uri, persistent, resourcet
+     , semigroups, shakespeare, template-haskell, text, time
+     , transformers, wai, xss-sanitize, yesod-core, yesod-persistent
+     }:
+     mkDerivation {
+       pname = "yesod-form";
+       version = "1.4.12";
+       sha256 = "731638c1541b112f78ffeef05e11a57f518b6a6a15aa306779f6840e989b8a51";
+       libraryHaskellDepends = [
+         aeson attoparsec base blaze-builder blaze-html blaze-markup
+         byteable bytestring containers data-default email-validate
+         network-uri persistent resourcet semigroups shakespeare
+         template-haskell text time transformers wai xss-sanitize yesod-core
+         yesod-persistent
+       ];
+       testHaskellDepends = [ base hspec text time ];
+       homepage = "http://www.yesodweb.com/";
+       description = "Form handling support for Yesod Web Framework";
+       license = stdenv.lib.licenses.mit;
+       hydraPlatforms = stdenv.lib.platforms.none;
      }) {};
 
   "yesod-form-json" = callPackage
···
        description = "Working with zip archives via conduits";
        license = stdenv.lib.licenses.bsd3;
        hydraPlatforms = stdenv.lib.platforms.none;
+     }) {};
+
+  "zip-stream" = callPackage
+    ({ mkDerivation, base, binary, binary-conduit, bytestring, conduit
+     , conduit-extra, digest, directory, exceptions, filepath, mtl
+     , primitive, resourcet, time, transformers-base, zlib
+     }:
+     mkDerivation {
+       pname = "zip-stream";
+       version = "0.1";
+       sha256 = "9225a4cf754fad3e7ba96c589bd8fddc50dda42948e70981b1b4b784dba10e17";
+       revision = "1";
+       editedCabalFile = "575cbce9074afa5785c15eeac758e8d50614fb90eb36cb2150ee3e208fb3e979";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base binary binary-conduit bytestring conduit conduit-extra digest
+         exceptions mtl primitive resourcet time transformers-base zlib
+       ];
+       executableHaskellDepends = [
+         base bytestring conduit conduit-extra directory filepath resourcet
+         time
+       ];
+       description = "ZIP archive streaming using conduits";
+       license = stdenv.lib.licenses.bsd3;
      }) {};
 
   "zipedit" = callPackage

pkgs/development/interpreters/elixir/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "elixir-${version}";
-  version = "1.4.2";
+  version = "1.4.4";
 
   src = fetchFromGitHub {
     owner = "elixir-lang";
     repo = "elixir";
     rev = "v${version}";
-    sha256 = "0jqww3l5jgqvlqpp6lh8i55v23a5imw4giarr05gsl7imv2qqshz";
+    sha256 = "0m51cirkv1dahw4z2jlmz58cwmpy0dya88myx4wykq0v5bh1xbq8";
   };
 
   buildInputs = [ erlang rebar makeWrapper ];

pkgs/development/libraries/accelio/default.nix

···
     maintainers = with maintainers; [ wkennington ];
     # kernel 4.2 is the most recent supported kernel
     broken = kernel != null &&
-      (builtins.compareVersions kernel.version "4.2" == 1 ||
-       (kernel.features.grsecurity or false));
+      (builtins.compareVersions kernel.version "4.2" == 1);
   };
 }

pkgs/development/libraries/log4shib/default.nix

···
 
   nativeBuildInputs = [ autoreconfHook ];
 
-  meta = {
+  meta = with stdenv.lib; {
     description = "A forked version of log4cpp that has been created for the Shibboleth project";
+    maintainers = [ maintainers.jammerful ];
   };
 }

pkgs/development/libraries/opensaml-cpp/default.nix

···
     description = "A low-level library written in C++ that provides support for producing and consuming SAML messages";
     platforms   = platforms.unix;
     license     = licenses.asl20;
+    maintainers = [ maintainers.jammerful ];
   };
 }

pkgs/development/libraries/qt-5/5.6/qtbase/default.nix

···
         -importdir $out/lib/qt5/imports \
         -qmldir $out/lib/qt5/qml \
         -docdir $out/share/doc/qt5"
+
+    NIX_CFLAGS_COMPILE+=" -DNIXPKGS_QPA_PLATFORM_PLUGIN_PATH=\"''${!outputLib}/lib/qt5/plugins/platforms\""
   '';
 
   prefixKey = "-prefix ";

pkgs/development/libraries/qt-5/5.6/qtbase/nix-profiles-library-paths.patch

···
+Index: qtbase-opensource-src-5.6.2/src/corelib/kernel/qcoreapplication.cpp
+===================================================================
+--- qtbase-opensource-src-5.6.2.orig/src/corelib/kernel/qcoreapplication.cpp
++++ qtbase-opensource-src-5.6.2/src/corelib/kernel/qcoreapplication.cpp
+@@ -2533,6 +2533,15 @@ QStringList QCoreApplication::libraryPat
+         QStringList *app_libpaths = new QStringList;
+         coreappdata()->app_libpaths.reset(app_libpaths);
+ 
++        // Add library paths derived from NIX_PROFILES.
++        const QByteArrayList profiles = qgetenv("NIX_PROFILES").split(' ');
++        const QString plugindir = QString::fromLatin1("/lib/qt5/plugins");
++        for (const QByteArray &profile: profiles) {
++            if (!profile.isEmpty()) {
++                app_libpaths->append(QFile::decodeName(profile) + plugindir);
++            }
++        }
++
+         const QByteArray libPathEnv = qgetenv("QT_PLUGIN_PATH");
+         if (!libPathEnv.isEmpty()) {
+             QStringList paths = QFile::decodeName(libPathEnv).split(QDir::listSeparator(), QString::SkipEmptyParts);

pkgs/development/libraries/qt-5/5.6/qtbase/qpa-platform-plugin-path.patch

···
+Index: qtbase-opensource-src-5.6.2/src/gui/kernel/qplatformintegrationfactory.cpp
+===================================================================
+--- qtbase-opensource-src-5.6.2.orig/src/gui/kernel/qplatformintegrationfactory.cpp
++++ qtbase-opensource-src-5.6.2/src/gui/kernel/qplatformintegrationfactory.cpp
+@@ -67,9 +67,10 @@ QPlatformIntegration *QPlatformIntegrati
+     // Try loading the plugin from platformPluginPath first:
+     if (!platformPluginPath.isEmpty()) {
+         QCoreApplication::addLibraryPath(platformPluginPath);
+-        if (QPlatformIntegration *ret = loadIntegration(directLoader(), platform, paramList, argc, argv))
+-            return ret;
+     }
++    QCoreApplication::addLibraryPath(QStringLiteral(NIXPKGS_QPA_PLATFORM_PLUGIN_PATH));
++    if (QPlatformIntegration *ret = loadIntegration(directLoader(), platform, paramList, argc, argv))
++        return ret;
+     if (QPlatformIntegration *ret = loadIntegration(loader(), platform, paramList, argc, argv))
+         return ret;
+ #else
+@@ -95,15 +96,16 @@ QStringList QPlatformIntegrationFactory:
+     QStringList list;
+     if (!platformPluginPath.isEmpty()) {
+         QCoreApplication::addLibraryPath(platformPluginPath);
+-        list = directLoader()->keyMap().values();
+-        if (!list.isEmpty()) {
+-            const QString postFix = QStringLiteral(" (from ")
+-                                    + QDir::toNativeSeparators(platformPluginPath)
+-                                    + QLatin1Char(')');
+-            const QStringList::iterator end = list.end();
+-            for (QStringList::iterator it = list.begin(); it != end; ++it)
+-                (*it).append(postFix);
+-        }
++    }
++    QCoreApplication::addLibraryPath(QStringLiteral(NIXPKGS_QPA_PLATFORM_PLUGIN_PATH));
++    list = directLoader()->keyMap().values();
++    if (!list.isEmpty()) {
++        const QString postFix = QStringLiteral(" (from ")
++            + QDir::toNativeSeparators(platformPluginPath)
++            + QLatin1Char(')');
++        const QStringList::iterator end = list.end();
++        for (QStringList::iterator it = list.begin(); it != end; ++it)
++            (*it).append(postFix);
+     }
+     list.append(loader()->keyMap().values());
+     return list;

pkgs/development/libraries/qt-5/5.6/qtbase/series

···
 dlopen-openssl.patch
 dlopen-dbus.patch
 xdg-config-dirs.patch
+nix-profiles-library-paths.patch
 compose-search-path.patch
 libressl.patch
+qpa-platform-plugin-path.patch

pkgs/development/libraries/qt-5/5.8/qtbase/default.nix

···
       AGL AppKit ApplicationServices Carbon Cocoa
       CoreAudio CoreBluetooth CoreLocation CoreServices
       DiskArbitration Foundation OpenGL
-      darwin.cf-private darwin.apple_sdk.sdk darwin.libobjc libiconv
+      darwin.cf-private darwin.libobjc libiconv
     ]);
 
   buildInputs = [ ]
···
         -qmldir $out/lib/qt5/qml \
         -docdir $out/share/doc/qt5"
 
-    NIX_CFLAGS_COMPILE+=" -DNIXPKGS_QPA_PLATFORM_PLUGIN_PATH=\"''${!outputLib}/lib/qt5/plugins\""
+    NIX_CFLAGS_COMPILE+=" -DNIXPKGS_QPA_PLATFORM_PLUGIN_PATH=\"''${!outputLib}/lib/qt5/plugins/platforms\""
   '';
 
 

pkgs/development/libraries/qt-5/5.8/qtbase/nix-profiles-library-paths.patch

···
+Index: qtbase-opensource-src-5.8.0/src/corelib/kernel/qcoreapplication.cpp
+===================================================================
+--- qtbase-opensource-src-5.8.0.orig/src/corelib/kernel/qcoreapplication.cpp
++++ qtbase-opensource-src-5.8.0/src/corelib/kernel/qcoreapplication.cpp
+@@ -2476,6 +2476,15 @@ QStringList QCoreApplication::libraryPat
+         QStringList *app_libpaths = new QStringList;
+         coreappdata()->app_libpaths.reset(app_libpaths);
+ 
++        // Add library paths derived from NIX_PROFILES.
++        const QByteArrayList profiles = qgetenv("NIX_PROFILES").split(' ');
++        const QString plugindir = QString::fromLatin1("/lib/qt5/plugins");
++        for (const QByteArray &profile: profiles) {
++            if (!profile.isEmpty()) {
++                app_libpaths->append(QFile::decodeName(profile) + plugindir);
++            }
++        }
++
+         const QByteArray libPathEnv = qgetenv("QT_PLUGIN_PATH");
+         if (!libPathEnv.isEmpty()) {
+             QStringList paths = QFile::decodeName(libPathEnv).split(QDir::listSeparator(), QString::SkipEmptyParts);

pkgs/development/libraries/qt-5/5.8/qtbase/qpa-platform-plugin-path.patch

···
+Index: qtbase-opensource-src-5.8.0/src/gui/kernel/qplatformintegrationfactory.cpp
+===================================================================
+--- qtbase-opensource-src-5.8.0.orig/src/gui/kernel/qplatformintegrationfactory.cpp
++++ qtbase-opensource-src-5.8.0/src/gui/kernel/qplatformintegrationfactory.cpp
+@@ -62,9 +62,10 @@ QPlatformIntegration *QPlatformIntegrati
+     // Try loading the plugin from platformPluginPath first:
+     if (!platformPluginPath.isEmpty()) {
+         QCoreApplication::addLibraryPath(platformPluginPath);
+-        if (QPlatformIntegration *ret = qLoadPlugin<QPlatformIntegration, QPlatformIntegrationPlugin>(directLoader(), platform, paramList, argc, argv))
+-            return ret;
+     }
++    QCoreApplication::addLibraryPath(QStringLiteral(NIXPKGS_QPA_PLATFORM_PLUGIN_PATH));
++    if (QPlatformIntegration *ret = qLoadPlugin<QPlatformIntegration, QPlatformIntegrationPlugin>(directLoader(), platform, paramList, argc, argv))
++        return ret;
+ #else
+     Q_UNUSED(platformPluginPath);
+ #endif
+@@ -84,15 +85,16 @@ QStringList QPlatformIntegrationFactory:
+ #ifndef QT_NO_LIBRARY
+     if (!platformPluginPath.isEmpty()) {
+         QCoreApplication::addLibraryPath(platformPluginPath);
+-        list = directLoader()->keyMap().values();
+-        if (!list.isEmpty()) {
+-            const QString postFix = QLatin1String(" (from ")
+-                                    + QDir::toNativeSeparators(platformPluginPath)
+-                                    + QLatin1Char(')');
+-            const QStringList::iterator end = list.end();
+-            for (QStringList::iterator it = list.begin(); it != end; ++it)
+-                (*it).append(postFix);
+-        }
++    }
++    QCoreApplication::addLibraryPath(QStringLiteral(NIXPKGS_QPA_PLATFORM_PLUGIN_PATH));
++    list = directLoader()->keyMap().values();
++    if (!list.isEmpty()) {
++        const QString postFix = QLatin1String(" (from ")
++            + QDir::toNativeSeparators(platformPluginPath)
++            + QLatin1Char(')');
++        const QStringList::iterator end = list.end();
++        for (QStringList::iterator it = list.begin(); it != end; ++it)
++            (*it).append(postFix);
+     }
+ #else
+     Q_UNUSED(platformPluginPath);

pkgs/development/libraries/qt-5/5.8/qtbase/qpa-plugin-path.patch

···
-Index: qtbase-opensource-src-5.8.0/src/gui/kernel/qguiapplication.cpp
-===================================================================
---- qtbase-opensource-src-5.8.0.orig/src/gui/kernel/qguiapplication.cpp
-+++ qtbase-opensource-src-5.8.0/src/gui/kernel/qguiapplication.cpp
-@@ -1217,6 +1217,10 @@ void QGuiApplicationPrivate::createPlatf
- 
-     // Load the platform integration
-     QString platformPluginPath = QString::fromLocal8Bit(qgetenv("QT_QPA_PLATFORM_PLUGIN_PATH"));
-+    if (!platformPluginPath.isEmpty()) {
-+        platformPluginPath.append(QStringLiteral(":"));
-+    }
-+    platformPluginPath.append(QStringLiteral(NIXPKGS_QPA_PLATFORM_PLUGIN_PATH));
- 
- 
-     QByteArray platformName;

pkgs/development/libraries/qt-5/5.8/qtbase/series

···
 tzdir.patch
 dlopen-libXcursor.patch
 xdg-config-dirs.patch
+nix-profiles-library-paths.patch
 libressl.patch
-qpa-plugin-path.patch
+qpa-platform-plugin-path.patch
 dlopen-gl.patch
 compose-search-path.patch
 cmake-paths.patch

pkgs/development/libraries/shibboleth-sp/default.nix

···
     description = "Enables SSO and Federation web applications written with any programming language or framework";
     platforms   = platforms.unix;
     license     = licenses.asl20;
+    maintainers = [ maintainers.jammerful ];
   };
 }

pkgs/development/libraries/xml-tooling-c/default.nix

···
     description = "A low-level library that provides a high level interface to XML processing for OpenSAML 2";
     platforms   = platforms.unix;
     license     = licenses.asl20;
+    maintainers = [ maintainers.jammerful ];
   };
 }

pkgs/development/python-modules/3to2/default.nix

···
+{ lib
+, buildPythonPackage
+, fetchurl
+, pytest
+}:
+
+buildPythonPackage rec {
+  pname = "3to2";
+  version = "1.1.1";
+  name = "${pname}-${version}";
+
+  src = fetchurl {
+    url = "https://files.pythonhosted.org/packages/8f/ab/58a363eca982c40e9ee5a7ca439e8ffc5243dde2ae660ba1ffdd4868026b/${pname}-${version}.zip";
+    sha256 = "fef50b2b881ef743f269946e1090b77567b71bb9a9ce64b7f8e699b562ff685c";
+  };
+
+  checkInputs = [ pytest ];
+
+  checkPhase = ''
+    py.test lib3to2/tests
+  '';
+
+  # Test failing due to upstream issue (https://bitbucket.org/amentajo/lib3to2/issues/50/testsuite-fails-with-new-python-35)
+  doCheck = false;
+
+  meta = {
+    homepage = https://bitbucket.org/amentajo/lib3to2;
+    description = "Refactors valid 3.x syntax into valid 2.x syntax, if a syntactical conversion is possible";
+    license = lib.licenses.asl20;
+    maintainers = with lib.maintainers; [ mt-caret ];
+  };
+}

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

···
+{lib, buildPythonPackage, fetchPypi, coverage, bash, which, writeText}:
+
+buildPythonPackage rec {
+  name = "${pname}-${version}";
+  version = "0.7";
+  pname = "cram";
+
+  buildInputs = [ coverage which ];
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "0bvz6fwdi55rkrz3f50zsy35gvvwhlppki2yml5bj5ffy9d499vx";
+  };
+
+  postPatch = ''
+    substituteInPlace tests/test.t \
+      --replace "/bin/bash" "${bash}/bin/bash"
+  '';
+
+  # This testing is copied from Makefile. Simply using `make test` doesn't work
+  # because it uses the unpatched `scripts/cram` executable which has a bad
+  # shebang. Also, for some reason, coverage fails on one file so let's just
+  # ignore that one.
+  checkPhase = ''
+    # scripts/cram tests
+    #COVERAGE=${coverage}/bin/coverage $out/bin/cram tests
+    #${coverage}/bin/coverage report --fail-under=100
+    COVERAGE=coverage $out/bin/cram tests
+    coverage report --fail-under=100 --omit="*/_encoding.py"
+  '';
+
+  meta = {
+    description = "A simple testing framework for command line applications";
+    homepage = https://bitheap.org/cram/;
+    license = lib.licenses.gpl2Plus;
+    maintainers = with lib.maintainers; [ jluttine ];
+  };
+}

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

···
+{ lib
+, buildPythonPackage
+, pythonOlder
+, fetchPypi
+, hypothesis
+, pytestcache
+, pytestcov
+, pytestflakes
+, pytestpep8
+, pytest
+, glibcLocales
+, mock ? null
+, pathlib ? null
+}:
+
+buildPythonPackage rec {
+  name = "${pname}-${version}";
+  pname = "natsort";
+  version = "5.0.3";
+
+  buildInputs = [
+    hypothesis
+    pytestcache
+    pytestcov
+    pytestflakes
+    pytestpep8
+    pytest
+    glibcLocales
+  ]
+  # pathlib was made part of standard library in 3.5:
+  ++ (lib.optionals (pythonOlder "3.4") [ pathlib ])
+  # based on testing-requirements.txt:
+  ++ (lib.optionals (pythonOlder "3.3") [ mock ]);
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "1h87n0jcsi6mgjx1pws6g1lmcn8jwabwxj8hq334jvziaq0plyym";
+  };
+
+  # do not run checks on nix_run_setup.py
+  patches = [ ./setup.patch ];
+
+  # testing based on project's tox.ini
+  checkPhase = ''
+    pytest --doctest-modules natsort
+    pytest --flakes --pep8 --cov natsort --cov-report term-missing
+  '';
+
+  meta = {
+    description = "Natural sorting for python";
+    homepage = https://github.com/SethMMorton/natsort;
+    license = lib.licenses.mit;
+  };
+}

pkgs/development/python-modules/natsort/setup.patch

···
+diff --git a/setup.cfg b/setup.cfg
+index 604994d..e38c3ec 100644
+--- a/setup.cfg
++++ b/setup.cfg
+@@ -6,6 +6,7 @@ formats = gztar
+ 
+ [tool:pytest]
+ flakes-ignore = 
++	nix_run_setup.py ALL
+ 	natsort/compat/py23.py UndefinedName
+ 	natsort/__init__.py UnusedImport
+ 	natsort/compat/* UnusedImport
+@@ -14,6 +15,7 @@ flakes-ignore =
+ 	test_natsort/test_locale_help.py UnusedImport RedefinedWhileUnused
+ 	test_natsort/compat/* UnusedImport
+ pep8ignore = 
++	nix_run_setup.py ALL
+ 	natsort/ns_enum.py E126 E241 E123 E221
+ 	test_natsort/test_*.py E501 E241 E221
+ 	test_natsort/test_natsort_keygen.py E501 E241 E221 E701

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

···
-{lib, python, buildPythonPackage, isPy27, isPyPy, gfortran, nose, blas}:
+{lib, fetchurl, python, buildPythonPackage, isPy27, isPyPy, gfortran, nose, blas}:
 
-args:
+buildPythonPackage rec {
+  pname = "numpy";
+  version = "1.12.1";
+  name = "${pname}-${version}";
 
-let
-  inherit (args) version;
-in buildPythonPackage (args // rec {
-
-  name = "numpy-${version}";
+  src = fetchurl {
+    url = "mirror://pypi/n/numpy/numpy-${version}.zip";
+    sha256 = "a65266a4ad6ec8936a1bc85ce51f8600634a31a258b722c9274a80ff189d9542";
+  };
 
   disabled = isPyPy;
-  buildInputs = args.buildInputs or [ gfortran nose ];
-  propagatedBuildInputs = args.propagatedBuildInputs or [ passthru.blas ];
+  buildInputs = [ gfortran nose blas ];
 
   patches = lib.optionals (python.hasDistutilsCxxPatch or false) [
     # See cpython 2.7 patches.
···
     echo "Creating site.cfg file..."
     cat << EOF > site.cfg
     [openblas]
-    include_dirs = ${passthru.blas}/include
-    library_dirs = ${passthru.blas}/lib
+    include_dirs = ${blas}/include
+    library_dirs = ${blas}/lib
     EOF
   '';
 
···
     description = "Scientific tools for Python";
     homepage = "http://numpy.scipy.org/";
     maintainers = with lib.maintainers; [ fridh ];
-  } // (args.meta or {});
-})
+  };
+}

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

···
 { buildPythonPackage
+, fetchPypi
 , python
 , stdenv
 , fetchurl
-, nose
+, pytest
 , glibcLocales
 , cython
 , dateutil
···
   inherit (stdenv) isDarwin;
 in buildPythonPackage rec {
   pname = "pandas";
-  version = "0.19.2";
+  version = "0.20.1";
   name = "${pname}-${version}";
 
-  src = fetchurl {
-    url = "mirror://pypi/${builtins.substring 0 1 pname}/${pname}/${name}.tar.gz";
-    sha256 = "6f0f4f598c2b16746803c8bafef7c721c57e4844da752d36240c0acf97658014";
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "42707365577ef69f7c9c168ddcf045df2957595a9ee71bc13c7997eecb96b190";
   };
 
   LC_ALL = "en_US.UTF-8";
-  buildInputs = [ nose glibcLocales ] ++ optional isDarwin libcxx;
+  buildInputs = [ pytest glibcLocales ] ++ optional isDarwin libcxx;
   propagatedBuildInputs = [
     cython
     dateutil
···
   '';
 
   # The flag `-A 'not network'` will disable tests that use internet.
-  # The `-e` flag disables a few problematic tests.
   checkPhase = ''
     runHook preCheck
-    # The flag `-w` provides the initial directory to search for tests.
-    # The flag `-A 'not network'` will disable tests that use internet.
-    nosetests -w $out/${python.sitePackages}/pandas --no-path-adjustment -A 'not slow and not network' \
-      --verbosity=3
-     runHook postCheck
+    py.test $out/${python.sitePackages}/pandas --skip-slow --skip-network
+    runHook postCheck
   '';
 
   meta = {

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

···
+{lib, buildPythonPackage, fetchurl, pillow}:
+
+buildPythonPackage rec {
+  name = "${pname}-${version}";
+  pname = "piexif";
+  version = "1.0.12";
+
+  # pillow needed for unit tests
+  buildInputs = [ pillow ];
+
+  # No .tar.gz source available at PyPI, only .zip source, so need to use
+  # fetchurl because fetchPypi doesn't support .zip.
+  src = fetchurl {
+    url = "mirror://pypi/${builtins.substring 0 1 pname}/${pname}/${name}.zip";
+    sha256 = "15dvdr7b5xxsbsq5k6kq8h0xnzrkqzc08dzlih48a21x27i02bii";
+  };
+
+  meta = {
+    description = "Simplify Exif manipulations with Python";
+    homepage = https://github.com/hMatoba/Piexif;
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ jluttine ];
+  };
+}

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

···
+{lib, buildPythonPackage, fetchPypi, pytest, cram, bash, writeText}:
+
+buildPythonPackage rec {
+  name = "${pname}-${version}";
+  version = "0.1.1";
+  pname = "pytest-cram";
+
+  buildInputs = [ pytest ];
+  propagatedBuildInputs = [ cram ];
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "0ad05999iqzyjay9y5lc0cnd3jv8qxqlzsvxzp76shslmhrv0c4f";
+  };
+
+  postPatch = ''
+    substituteInPlace pytest_cram/tests/test_options.py \
+      --replace "/bin/bash" "${bash}/bin/bash"
+  '';
+
+  # Remove __init__.py from tests folder, otherwise pytest raises an error that
+  # the imported and collected modules are different.
+  checkPhase = ''
+    rm pytest_cram/tests/__init__.py
+    pytest pytest_cram
+  '';
+
+  meta = {
+    description = "Test command-line applications with pytest and cram";
+    homepage = https://github.com/tbekolay/pytest-cram;
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ jluttine ];
+  };
+}

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

···
+{ stdenv, fetchPypi, buildPythonPackage, isPy3k, execnet, pytest, setuptools_scm }:
+
+buildPythonPackage rec {
+  name = "${pname}-${version}";
+  pname = "pytest-xdist";
+  version = "1.16.0";
+
+  src = fetchPypi {
+    inherit pname version;
+    sha256 = "42e5a1e5da9d7cff3e74b07f8692598382f95624f234ff7e00a3b1237e0feba2";
+  };
+
+  buildInputs = [ pytest setuptools_scm ];
+  propagatedBuildInputs = [ execnet ];
+
+  postPatch = ''
+    rm testing/acceptance_test.py testing/test_remote.py testing/test_slavemanage.py
+  '';
+
+  checkPhase = ''
+    py.test testing
+  '';
+
+  # Only test on 3.x
+  # INTERNALERROR> AttributeError: 'NoneType' object has no attribute 'getconsumer'
+  doCheck = isPy3k;
+
+  meta = with stdenv.lib; {
+    description = "py.test xdist plugin for distributed testing and loop-on-failing modes";
+    homepage = https://github.com/pytest-dev/pytest-xdist;
+    license = licenses.mit;
+  };
+}

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

···
-{lib, python, buildPythonPackage, isPyPy, gfortran, nose}:
+{lib, fetchurl, python, buildPythonPackage, isPyPy, gfortran, nose, numpy}:
 
-args:
+buildPythonPackage rec {
+  pname = "scipy";
+  version = "0.19.0";
+  name = "${pname}-${version}";
 
-let
-  inherit (args) version;
-  inherit (args) numpy;
-in buildPythonPackage (args // rec {
+  src = fetchurl {
+    url = "mirror://pypi/s/scipy/scipy-${version}.zip";
+    sha256 = "4190d34bf9a09626cd42100bbb12e3d96b2daf1a8a3244e991263eb693732122";
+  };
 
-  name = "scipy-${version}";
-
-  buildInputs = (args.buildInputs or [ gfortran nose ]);
-  propagatedBuildInputs = (args.propagatedBuildInputs or [ passthru.blas numpy]);
+  buildInputs = [ gfortran nose numpy.blas ];
+  propagatedBuildInputs = [ numpy ];
 
   # Remove tests because of broken wrapper
   prePatch = ''
···
     echo "Creating site.cfg file..."
     cat << EOF > site.cfg
     [openblas]
-    include_dirs = ${passthru.blas}/include
-    library_dirs = ${passthru.blas}/lib
+    include_dirs = ${numpy.blas}/include
+    library_dirs = ${numpy.blas}/lib
     EOF
   '';
 
···
     description = "SciPy (pronounced 'Sigh Pie') is open-source software for mathematics, science, and engineering. ";
     homepage = http://www.scipy.org/;
     maintainers = with lib.maintainers; [ fridh ];
-  } // (args.meta or {});
-})
+  };
+}

pkgs/development/ruby-modules/gem-config/default.nix

···
 , libiconv, postgresql, v8_3_16_14, clang, sqlite, zlib, imagemagick
 , pkgconfig , ncurses, xapian_1_2_22, gpgme, utillinux, fetchpatch, tzdata, icu, libffi
 , cmake, libssh2, openssl, mysql, darwin, git, perl, gecode_3, curl
-, libmsgpack, qt48, libsodium, snappy, libossp_uuid, lxc
+, libmsgpack, qt48, libsodium, snappy, libossp_uuid, lxc, libpcap
 }@args:
 
 let
···
     buildInputs = [ curl ];
   };
 
+  pcaprub = attrs: {
+    buildInputs = [ libpcap ];
+  };
+
   pg = attrs: {
     buildFlags = [
       "--with-pg-config=${postgresql}/bin/pg_config"
···
       substituteInPlace lib/sup/crypto.rb \
         --replace 'which gpg2' \
                   '${which}/bin/which gpg2'
+    '';
+  };
+
+  rb-readline = attrs: {
+    dontBuild = false;
+    postPatch = ''
+      substituteInPlace lib/rbreadline.rb \
+        --replace 'infocmp' '${ncurses.dev}/bin/infocmp'
     '';
   };
 

pkgs/development/tools/continuous-integration/gitlab-runner/v1-fix-shell-path.patch

···
+diff --git a/shells/bash.go b/shells/bash.go
+index c9c8b68..c97dbb5 100644
+--- a/shells/bash.go
++++ b/shells/bash.go
+@@ -208,7 +208,7 @@ func (b *BashShell) GetConfiguration(info common.ShellScriptInfo) (script *commo
+ 	if info.User != "" {
+ 		script.Command = "su"
+ 		if runtime.GOOS == "linux" {
+-			script.Arguments = append(script.Arguments, "-s", "/bin/"+b.Shell)
++			script.Arguments = append(script.Arguments, "-s", "/run/current-system/sw/bin/"+b.Shell)
+ 		}
+ 		script.Arguments = append(script.Arguments, info.User)
+ 		script.Arguments = append(script.Arguments, "-c", shellCommand)

pkgs/development/tools/continuous-integration/gitlab-runner/v1.nix

···
     sha256 = "1sjvlb5981ykc8hr4kp1ibh9jw2wdjjp9zs2nqs9lpsav4nda5fr";
   };
 
+  patches = [ ./v1-fix-shell-path.patch ];
+
   buildInputs = [ go-bindata ];
 
   preBuild = ''

pkgs/os-specific/linux/batman-adv/default.nix

···
     license = stdenv.lib.licenses.gpl2;
     maintainers = with stdenv.lib.maintainers; [ viric fpletz ];
     platforms = with stdenv.lib.platforms; linux;
-    broken = (kernel.features.grsecurity or false);
   };
 }

pkgs/os-specific/linux/cryptsetup/default.nix

···
 assert enablePython -> python2 != null;
 
 stdenv.mkDerivation rec {
-  name = "cryptsetup-1.7.3";
+  name = "cryptsetup-1.7.5";
 
   src = fetchurl {
     url = "mirror://kernel/linux/utils/cryptsetup/v1.7/${name}.tar.xz";
-    sha256 = "00nwd96m9yq4k3cayc04i5y7iakkzana35zxky6hpx2w8zl08axg";
+    sha256 = "1gail831j826lmpdx2gsc83lp3br6wfnwh3vqwxaa1nn1lfwsc1b";
   };
 
   configureFlags = [ "--enable-cryptsetup-reencrypt" "--with-crypto_backend=openssl" ]

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

···
 
 stdenv.mkDerivation rec {
   name = "raspberrypi-firmware-${version}";
-  version = "1.20170303";
+  version = "1.20170427";
 
   src = fetchFromGitHub {
     owner = "raspberrypi";
     repo = "firmware";
     rev = version;
-    sha256 = "1s5dycgix97681vpq7ggpc27n865wgv9npzxvbr2q2bp3ia9mcim";
+    sha256 = "0n79nij0rlwjx3zqs4p3wcyrgrgg9gmsf1a526r91c689r5lpwvl";
   };
 
   dontStrip = true;    # Stripping breaks some of the binaries

pkgs/os-specific/linux/kernel-headers/default.nix

···
 { stdenv, kernel, perl }:
 
-assert (!(kernel.features.grsecurity or false));
-
 let
   baseBuildFlags = [ "INSTALL_HDR_PATH=$(out)" "headers_install" ];
 in stdenv.mkDerivation {

pkgs/os-specific/linux/kernel/linux-4.10.nix

···
 { stdenv, fetchurl, perl, buildLinux, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "4.10.15";
+  version = "4.10.16";
   extraMeta.branch = "4.10";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v4.x/linux-${version}.tar.xz";
-    sha256 = "0i943i7gp9fk5ic3dbm9w8ilgpmphav2m3rlj1i3c0r7y0824hfq";
+    sha256 = "02z0gzycjx0nkxazsfqh9dxhs1xd99z589i4qd8d3d740p2lgifw";
   };
 
   kernelPatches = args.kernelPatches;

pkgs/os-specific/linux/kernel/linux-4.11.nix

···
 { stdenv, fetchurl, perl, buildLinux, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "4.11";
+  version = "4.11.1";
   extraMeta.branch = "4.11";
-  modDirVersion = "4.11.0";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v4.x/linux-${version}.tar.xz";
-    sha256 = "b67ecafd0a42b3383bf4d82f0850cbff92a7e72a215a6d02f42ddbafcf42a7d6";
+    sha256 = "027646ynwf4n8cb3h29a9qfm0cyw12bvaavzn2q44ych2vigjiky";
   };
 
   kernelPatches = args.kernelPatches;

pkgs/os-specific/linux/kernel/linux-4.4.nix

···
 { stdenv, fetchurl, perl, buildLinux, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "4.4.67";
+  version = "4.4.68";
   extraMeta.branch = "4.4";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v4.x/linux-${version}.tar.xz";
-    sha256 = "063vjskz6grjp3bmgcp056r8xzy578fwc2kmzdhb6lw5mih9r85f";
+    sha256 = "1lwh66db78xx1w30v01wn3jmdmh298zx5q4shjz3qswda70r1m1m";
   };
 
   kernelPatches = args.kernelPatches;

pkgs/os-specific/linux/kernel/linux-4.9.nix

···
 { stdenv, fetchurl, perl, buildLinux, ... } @ args:
 
 import ./generic.nix (args // rec {
-  version = "4.9.27";
+  version = "4.9.28";
   extraMeta.branch = "4.9";
 
   src = fetchurl {
     url = "mirror://kernel/linux/kernel/v4.x/linux-${version}.tar.xz";
-    sha256 = "0wvhds3878sh7hphjy30aii7jm5b88d2qph29whc96zccx1rpxlm";
+    sha256 = "0a59lhl3qbsag8lgj635dl15ssfjni6876hz3sry8ls81lpz7l85";
   };
 
   kernelPatches = args.kernelPatches;

pkgs/os-specific/linux/kernel/linux-rpi.nix

···
 { stdenv, fetchFromGitHub, perl, buildLinux, ... } @ args:
 
 let
-  modDirVersion = "4.4.50";
-  tag = "1.20170303";
+  modDirVersion = "4.9.24";
+  tag = "1.20170427";
 in
 stdenv.lib.overrideDerivation (import ./generic.nix (args // rec {
   version = "${modDirVersion}-${tag}";
···
     owner = "raspberrypi";
     repo = "linux";
     rev = "raspberrypi-kernel_${tag}-1";
-    sha256 = "1lvsr8zm8p1ng4b9vq0nkf2gn4gabla8dh6l60vifclqdcq2vwvx";
+    sha256 = "0f7p2jc3a9yvz7k1fig6fardgz2lvp5kawbb3rfsx2p53yjlhmf9";
   };
 
   features.iwlwifi = true;
···
     }
 
     # I am not sure if all of these are correct...
+    copyDTB bcm2708-rpi-0-w.dts bcm2835-rpi-zero.dtb
     copyDTB bcm2708-rpi-b.dtb bcm2835-rpi-a.dtb
     copyDTB bcm2708-rpi-b.dtb bcm2835-rpi-b.dtb
     copyDTB bcm2708-rpi-b.dtb bcm2835-rpi-b-rev2.dtb
···
     copyDTB bcm2708-rpi-cm.dtb bcm2835-rpi-cm.dtb
     copyDTB bcm2709-rpi-2-b.dtb bcm2836-rpi-2-b.dtb
     copyDTB bcm2710-rpi-3-b.dtb bcm2837-rpi-3-b.dtb
+    # bcm2710-rpi-cm3.dts is yet unknown.
   '';
 })

pkgs/os-specific/linux/lttng-modules/default.nix

···
     maintainers = [ maintainers.bjornfor ];
     broken =
       (builtins.compareVersions kernel.version "3.18" == -1) ||
-      (kernel.features.grsecurity or false) ||
       (kernel.features.chromiumos or false);
   };
 

pkgs/os-specific/linux/rtl8723bs/default.nix

···
     homepage = "https://github.com/hadess/rtl8723bs";
     license = stdenv.lib.licenses.gpl2;
     platforms = stdenv.lib.platforms.linux;
-    broken = (! versionAtLeast kernel.version "3.19")
-      || (kernel.features.grsecurity or false);
+    broken = (! versionAtLeast kernel.version "3.19");
     maintainers = with maintainers; [ elitak ];
   };
 }

pkgs/os-specific/linux/rtl8812au/default.nix

···
     homepage = "https://github.com/Grawp/rtl8812au_rtl8821au";
     license = stdenv.lib.licenses.gpl2;
     platforms = [ "x86_64-linux" "i686-linux" ];
-    broken = (kernel.features.grsecurity or false);
   };
 }

pkgs/servers/mattermost/matterircd.nix

···
 
 buildGoPackage rec {
   name = "matterircd-${version}";
-  version = "0.11.3";
+  version = "0.11.4";
 
   src = fetchFromGitHub {
     owner = "42wim";
     repo = "matterircd";
     rev = "v${version}";
-    sha256 = "10fmn6midfzmn6ylhrk00bvykn0zijypiqp5hjqn642kcdkrjc6i";
+    sha256 = "0mnfay6bh9ls2fi3k96hmw4gr7q11lw4rd466lidi4jyjpc7q42x";
   };
 
   goPackagePath = "github.com/42vim/matterircd";

pkgs/servers/monitoring/telegraf/default.nix

···
 
 buildGoPackage rec {
   name = "telegraf-${version}";
-  version = "1.2.1";
+  version = "1.3.0";
 
   goPackagePath = "github.com/influxdata/telegraf";
 
···
     owner = "influxdata";
     repo = "telegraf";
     rev = "${version}";
-    sha256 = "0vfx87a9shhwyqrbdf1jc32jkg0ych8bd0p222v2rcd83l75r0kh";
+    sha256 = "0vcv4ylqzp4fvmpd3n5m0n2kxx39fcp9x62ny7cja4wraq36mdn0";
   };
 
   goDeps = ./. + builtins.toPath "/deps-${version}.nix";

pkgs/servers/monitoring/telegraf/deps-1.2.1.nix

···
-# This file was generated by go2nix.
-[
-  {
-    goPackagePath = "github.com/Shopify/sarama";
-    fetch = {
-      type = "git";
-      url = "https://github.com/Shopify/sarama";
-      rev = "8aadb476e66ca998f2f6bb3c993e9a2daa3666b9";
-      sha256 = "1ndaddqcll9r22jg9x36acanxv5ds3xwahrm4b6nmmg06670gksv";
-    };
-  }
-  {
-    goPackagePath = "github.com/Sirupsen/logrus";
-    fetch = {
-      type = "git";
-      url = "https://github.com/Sirupsen/logrus";
-      rev = "219c8cb75c258c552e999735be6df753ffc7afdc";
-      sha256 = "04v55846v1535dplldyjhr0yqxl6n1mr4kiy2vz3ragv92xpshr6";
-    };
-  }
-  {
-    goPackagePath = "github.com/aerospike/aerospike-client-go";
-    fetch = {
-      type = "git";
-      url = "https://github.com/aerospike/aerospike-client-go";
-      rev = "7f3a312c3b2a60ac083ec6da296091c52c795c63";
-      sha256 = "05ancqplckvni9xp6xd4bv2pgkfa4v23svfcg27m8xinzi4ry219";
-    };
-  }
-  {
-    goPackagePath = "github.com/amir/raidman";
-    fetch = {
-      type = "git";
-      url = "https://github.com/amir/raidman";
-      rev = "53c1b967405155bfc8758557863bf2e14f814687";
-      sha256 = "08a6zz4akkm7lk02w53vfhkxdf0ikv32x41rc4jyi2qaf0wyw6b4";
-    };
-  }
-  {
-    goPackagePath = "github.com/aws/aws-sdk-go";
-    fetch = {
-      type = "git";
-      url = "https://github.com/aws/aws-sdk-go";
-      rev = "13a12060f716145019378a10e2806c174356b857";
-      sha256 = "09yl85kk2y4ayk44af5rbnkq4vy82vbh2z5ac4vpl2vgv7zyh46h";
-    };
-  }
-  {
-    goPackagePath = "github.com/beorn7/perks";
-    fetch = {
-      type = "git";
-      url = "https://github.com/beorn7/perks";
-      rev = "3ac7bf7a47d159a033b107610db8a1b6575507a4";
-      sha256 = "1qc3l4r818xpvrhshh1sisc5lvl9479qspcfcdbivdyh0apah83r";
-    };
-  }
-  {
-    goPackagePath = "github.com/cenkalti/backoff";
-    fetch = {
-      type = "git";
-      url = "https://github.com/cenkalti/backoff";
-      rev = "4dc77674aceaabba2c7e3da25d4c823edfb73f99";
-      sha256 = "0icf4vrgzksr0g8h6y00rd92h1mym6waf3mbqpf890bkw60gnm0w";
-    };
-  }
-  {
-    goPackagePath = "github.com/couchbase/go-couchbase";
-    fetch = {
-      type = "git";
-      url = "https://github.com/couchbase/go-couchbase";
-      rev = "cb664315a324d87d19c879d9cc67fda6be8c2ac1";
-      sha256 = "1dfw1apwrlfwl7bahb6dy5g9z2vs431l4lpaj3k9bnm13p0awivr";
-    };
-  }
-  {
-    goPackagePath = "github.com/couchbase/gomemcached";
-    fetch = {
-      type = "git";
-      url = "https://github.com/couchbase/gomemcached";
-      rev = "a5ea6356f648fec6ab89add00edd09151455b4b2";
-      sha256 = "00x57qqdv9ciyxiw2y6p4s65sfgi4cs6zi39qlqlw90nh133xnwi";
-    };
-  }
-  {
-    goPackagePath = "github.com/couchbase/goutils";
-    fetch = {
-      type = "git";
-      url = "https://github.com/couchbase/goutils";
-      rev = "5823a0cbaaa9008406021dc5daf80125ea30bba6";
-      sha256 = "15v5ps2i2y2hczwxs2ci4c2w4p3pn3bl7vc5wlaqnc7i14f9285c";
-    };
-  }
-  {
-    goPackagePath = "github.com/dancannon/gorethink";
-    fetch = {
-      type = "git";
-      url = "https://github.com/dancannon/gorethink";
-      rev = "e7cac92ea2bc52638791a021f212145acfedb1fc";
-      sha256 = "0f9gwsqf93qzvfpdwgam7vcfzrrkcj2s9ms4p056kcyxv9snwq3g";
-    };
-  }
-  {
-    goPackagePath = "github.com/davecgh/go-spew";
-    fetch = {
-      type = "git";
-      url = "https://github.com/davecgh/go-spew";
-      rev = "5215b55f46b2b919f50a1df0eaa5886afe4e3b3d";
-      sha256 = "15h9kl73rdbzlfmsdxp13jja5gs7sknvqkpq2qizq3qv3nr1x8dk";
-    };
-  }
-  {
-    goPackagePath = "github.com/docker/engine-api";
-    fetch = {
-      type = "git";
-      url = "https://github.com/docker/engine-api";
-      rev = "8924d6900370b4c7e7984be5adc61f50a80d7537";
-      sha256 = "1klimc3d1a2vfgl14a7js20ricpghq5jzvh8l46kf87ycjwc0q4n";
-    };
-  }
-  {
-    goPackagePath = "github.com/docker/go-connections";
-    fetch = {
-      type = "git";
-      url = "https://github.com/docker/go-connections";
-      rev = "f549a9393d05688dff0992ef3efd8bbe6c628aeb";
-      sha256 = "0k1yf4bimmwxc0qiz997nagfmddbm8nwb0c1q16387m8lgw1gbwg";
-    };
-  }
-  {
-    goPackagePath = "github.com/docker/go-units";
-    fetch = {
-      type = "git";
-      url = "https://github.com/docker/go-units";
-      rev = "5d2041e26a699eaca682e2ea41c8f891e1060444";
-      sha256 = "0hn8xdbaykp046inc4d2mwig5ir89ighma8hk18dfkm8rh1vvr8i";
-    };
-  }
-  {
-    goPackagePath = "github.com/eapache/go-resiliency";
-    fetch = {
-      type = "git";
-      url = "https://github.com/eapache/go-resiliency";
-      rev = "b86b1ec0dd4209a588dc1285cdd471e73525c0b3";
-      sha256 = "1kzv95bh3nidm2cr7iv9lk3s2qiw1i17n8gyl2x6xk6qv8b0bc21";
-    };
-  }
-  {
-    goPackagePath = "github.com/eapache/queue";
-    fetch = {
-      type = "git";
-      url = "https://github.com/eapache/queue";
-      rev = "ded5959c0d4e360646dc9e9908cff48666781367";
-      sha256 = "0inclypw0kln8hsn34c5ww34h0qa9fcqwak93lac5dp59rz5430n";
-    };
-  }
-  {
-    goPackagePath = "github.com/eclipse/paho.mqtt.golang";
-    fetch = {
-      type = "git";
-      url = "https://github.com/eclipse/paho.mqtt.golang";
-      rev = "0f7a459f04f13a41b7ed752d47944528d4bf9a86";
-      sha256 = "13l6mrx9z859r4r7kpa9rsbf4ni7dn6xgz8iyv2xnz53pqffanjh";
-    };
-  }
-  {
-    goPackagePath = "github.com/go-sql-driver/mysql";
-    fetch = {
-      type = "git";
-      url = "https://github.com/go-sql-driver/mysql";
-      rev = "1fca743146605a172a266e1654e01e5cd5669bee";
-      sha256 = "02vbq8j4r3skg3fmiv1wvjqh1542dr515w8f3d42b5lpwc1fsn38";
-    };
-  }
-  {
-    goPackagePath = "github.com/gobwas/glob";
-    fetch = {
-      type = "git";
-      url = "https://github.com/gobwas/glob";
-      rev = "49571a1557cd20e6a2410adc6421f85b66c730b5";
-      sha256 = "16j7pdxajqrl20a737p7kgsngr2f7gkkpgqxxmfkrmgckgkc8cvk";
-    };
-  }
-  {
-    goPackagePath = "github.com/golang/protobuf";
-    fetch = {
-      type = "git";
-      url = "https://github.com/golang/protobuf";
-      rev = "552c7b9542c194800fd493123b3798ef0a832032";
-      sha256 = "1zaw1xxnvgsvfcrv5xkn1f7p87vyh9i6mc44csl11fgc2hvqp6xm";
-    };
-  }
-  {
-    goPackagePath = "github.com/golang/snappy";
-    fetch = {
-      type = "git";
-      url = "https://github.com/golang/snappy";
-      rev = "d9eb7a3d35ec988b8585d4a0068e462c27d28380";
-      sha256 = "0wynarlr1y8sm9y9l29pm9dgflxriiialpwn01066snzjxnpmbyn";
-    };
-  }
-  {
-    goPackagePath = "github.com/gorilla/context";
-    fetch = {
-      type = "git";
-      url = "https://github.com/gorilla/context";
-      rev = "1ea25387ff6f684839d82767c1733ff4d4d15d0a";
-      sha256 = "1nh1nzxcsgd215x4xn59wc4cbqfa8zvhvnnx5p8fkrn4bj1cgak4";
-    };
-  }
-  {
-    goPackagePath = "github.com/gorilla/mux";
-    fetch = {
-      type = "git";
-      url = "https://github.com/gorilla/mux";
-      rev = "c9e326e2bdec29039a3761c07bece13133863e1e";
-      sha256 = "1bplp6v14isjdfpf8328k8bvkn35n451axkxlm822d9h5ccg47g6";
-    };
-  }
-  {
-    goPackagePath = "github.com/hailocab/go-hostpool";
-    fetch = {
-      type = "git";
-      url = "https://github.com/hailocab/go-hostpool";
-      rev = "e80d13ce29ede4452c43dea11e79b9bc8a15b478";
-      sha256 = "05ld4wp3illkbgl043yf8jq9y1ld0zzvrcg8jdij129j50xgfxny";
-    };
-  }
-  {
-    goPackagePath = "github.com/hashicorp/consul";
-    fetch = {
-      type = "git";
-      url = "https://github.com/hashicorp/consul";
-      rev = "5aa90455ce78d4d41578bafc86305e6e6b28d7d2";
-      sha256 = "1xas814kkhwnjg5ghhlkgygcgi5p7h6dczmpbrzzh3yygbfdzxgw";
-    };
-  }
-  {
-    goPackagePath = "github.com/hpcloud/tail";
-    fetch = {
-      type = "git";
-      url = "https://github.com/hpcloud/tail";
-      rev = "b2940955ab8b26e19d43a43c4da0475dd81bdb56";
-      sha256 = "1x266pdfvcymsbdrdsns06qq5qfjb62z6h4512ylhakbm64qkn4s";
-    };
-  }
-  {
-    goPackagePath = "github.com/influxdata/config";
-    fetch = {
-      type = "git";
-      url = "https://github.com/influxdata/config";
-      rev = "b79f6829346b8d6e78ba73544b1e1038f1f1c9da";
-      sha256 = "0k4iywy83n3kq2f58a41rjinj03wp1di67aacpf04p25qmf46c4z";
-    };
-  }
-  {
-    goPackagePath = "github.com/influxdata/influxdb";
-    fetch = {
-      type = "git";
-      url = "https://github.com/influxdata/influxdb";
-      rev = "fc57c0f7c635df3873f3d64f0ed2100ddc94d5ae";
-      sha256 = "07cv1gryp4a84a2acgc8k8alr7jw4jwphf12cby8jjy1br35jrbq";
-    };
-  }
-  {
-    goPackagePath = "github.com/influxdata/toml";
-    fetch = {
-      type = "git";
-      url = "https://github.com/influxdata/toml";
-      rev = "af4df43894b16e3fd2b788d01bd27ad0776ef2d0";
-      sha256 = "1faf51s89sk1z41qfsazmddgwll7jq9xna67k3h3vry86c4vs2j4";
-    };
-  }
-  {
-    goPackagePath = "github.com/influxdata/wlog";
-    fetch = {
-      type = "git";
-      url = "https://github.com/influxdata/wlog";
-      rev = "7c63b0a71ef8300adc255344d275e10e5c3a71ec";
-      sha256 = "04kw4kivxvr3kkmghj3427b1xyhzbhnfr971qfn3lv2vvhs8kpfl";
-    };
-  }
-  {
-    goPackagePath = "github.com/kardianos/osext";
-    fetch = {
-      type = "git";
-      url = "https://github.com/kardianos/osext";
-      rev = "29ae4ffbc9a6fe9fb2bc5029050ce6996ea1d3bc";
-      sha256 = "1mawalaz84i16njkz6f9fd5jxhcbxkbsjnav3cmqq2dncv2hyv8a";
-    };
-  }
-  {
-    goPackagePath = "github.com/kardianos/service";
-    fetch = {
-      type = "git";
-      url = "https://github.com/kardianos/service";
-      rev = "5e335590050d6d00f3aa270217d288dda1c94d0a";
-      sha256 = "1g10qisgywfqj135yyiq63pnbjgr201gz929ydlgyzqq6yk3bn3h";
-    };
-  }
-  {
-    goPackagePath = "github.com/kballard/go-shellquote";
-    fetch = {
-      type = "git";
-      url = "https://github.com/kballard/go-shellquote";
-      rev = "d8ec1a69a250a17bb0e419c386eac1f3711dc142";
-      sha256 = "1a57hm0zwyi70am670s0pkglnkk1ilddnmfxz1ba7innpkf5z6s7";
-    };
-  }
-  {
-    goPackagePath = "github.com/klauspost/crc32";
-    fetch = {
-      type = "git";
-      url = "https://github.com/klauspost/crc32";
-      rev = "19b0b332c9e4516a6370a0456e6182c3b5036720";
-      sha256 = "0fcnsf1m0bzplgp28dz8skza6l7rc65s180x85rzbdl9l3zzi43r";
-    };
-  }
-  {
-    goPackagePath = "github.com/lib/pq";
-    fetch = {
-      type = "git";
-      url = "https://github.com/lib/pq";
-      rev = "e182dc4027e2ded4b19396d638610f2653295f36";
-      sha256 = "1636v3snixapjf7rbjq0xn1sbym7hwckqfla0dm5cr4a5q4fw5cj";
-    };
-  }
-  {
-    goPackagePath = "github.com/matttproud/golang_protobuf_extensions";
-    fetch = {
-      type = "git";
-      url = "https://github.com/matttproud/golang_protobuf_extensions";
-      rev = "d0c3fe89de86839aecf2e0579c40ba3bb336a453";
-      sha256 = "0jkjgpi1s8l9bdbf14fh8050757jqy36kn1l1hxxlb2fjn1pcg0r";
-    };
-  }
-  {
-    goPackagePath = "github.com/miekg/dns";
-    fetch = {
-      type = "git";
-      url = "https://github.com/miekg/dns";
-      rev = "cce6c130cdb92c752850880fd285bea1d64439dd";
-      sha256 = "098gadhfjiijlgq497gbccvf26xrmjvln1fws56m0ljcgszq3jdx";
-    };
-  }
-  {
-    goPackagePath = "github.com/mreiferson/go-snappystream";
-    fetch = {
-      type = "git";
-      url = "https://github.com/mreiferson/go-snappystream";
-      rev = "028eae7ab5c4c9e2d1cb4c4ca1e53259bbe7e504";
-      sha256 = "0jdd5whp74nvg35d9hzydsi3shnb1vrnd7shi9qz4wxap7gcrid6";
-    };
-  }
-  {
-    goPackagePath = "github.com/naoina/go-stringutil";
-    fetch = {
-      type = "git";
-      url = "https://github.com/naoina/go-stringutil";
-      rev = "6b638e95a32d0c1131db0e7fe83775cbea4a0d0b";
-      sha256 = "00831p1wn3rimybk1z8l30787kn1akv5jax5wx743nn76qcmkmc6";
-    };
-  }
-  {
-    goPackagePath = "github.com/nats-io/nats";
-    fetch = {
-      type = "git";
-      url = "https://github.com/nats-io/nats";
-      rev = "ea8b4fd12ebb823073c0004b9f09ac8748f4f165";
-      sha256 = "0i5f6n9k0d2vzdy20sqygmss5j45y72irxsi80grjsh7qkxa6vn1";
-    };
-  }
-  {
-    goPackagePath = "github.com/nats-io/nuid";
-    fetch = {
-      type = "git";
-      url = "https://github.com/nats-io/nuid";
-      rev = "a5152d67cf63cbfb5d992a395458722a45194715";
-      sha256 = "0fphar5bz735wwa7549j31nxnm5a9dyw472gs9zafz0cv7g8np40";
-    };
-  }
-  {
-    goPackagePath = "github.com/nsqio/go-nsq";
-    fetch = {
-      type = "git";
-      url = "https://github.com/nsqio/go-nsq";
-      rev = "0b80d6f05e15ca1930e0c5e1d540ed627e299980";
-      sha256 = "1zi9jazjfzilp2g0xy30dlx9nd9g47cjqrnqxallly97mz9n01xr";
-    };
-  }
-  {
-    goPackagePath = "github.com/opencontainers/runc";
-    fetch = {
-      type = "git";
-      url = "https://github.com/opencontainers/runc";
-      rev = "89ab7f2ccc1e45ddf6485eaa802c35dcf321dfc8";
-      sha256 = "1rnaqcsww7plr430r4ksv9si4l91l25li0bwa1b03g3sn2shirk1";
-    };
-  }
-  {
-    goPackagePath = "github.com/prometheus/client_golang";
-    fetch = {
-      type = "git";
-      url = "https://github.com/prometheus/client_golang";
-      rev = "18acf9993a863f4c4b40612e19cdd243e7c86831";
-      sha256 = "1gyjvwnvgyl0fs4hd2vp5hj1dsafhwb2h55w8zgzdpshvhwrpmhv";
-    };
-  }
-  {
-    goPackagePath = "github.com/prometheus/client_model";
-    fetch = {
-      type = "git";
-      url = "https://github.com/prometheus/client_model";
-      rev = "fa8ad6fec33561be4280a8f0514318c79d7f6cb6";
-      sha256 = "11a7v1fjzhhwsl128znjcf5v7v6129xjgkdpym2lial4lac1dhm9";
-    };
-  }
-  {
-    goPackagePath = "github.com/prometheus/common";
-    fetch = {
-      type = "git";
-      url = "https://github.com/prometheus/common";
-      rev = "e8eabff8812b05acf522b45fdcd725a785188e37";
-      sha256 = "08magd2aw7dqaa8bbv85404zvy120ify61msfpy75az5rdl5anxq";
-    };
-  }
-  {
-    goPackagePath = "github.com/prometheus/procfs";
-    fetch = {
-      type = "git";
-      url = "https://github.com/prometheus/procfs";
-      rev = "406e5b7bfd8201a36e2bb5f7bdae0b03380c2ce8";
-      sha256 = "0yla9hz15pg63394ygs9iiwzsqyv29labl8p424hijwsc9z9nka8";
-    };
-  }
-  {
-    goPackagePath = "github.com/samuel/go-zookeeper";
-    fetch = {
-      type = "git";
-      url = "https://github.com/samuel/go-zookeeper";
-      rev = "218e9c81c0dd8b3b18172b2bbfad92cc7d6db55f";
-      sha256 = "1v0m6wn83v4pbqz6hs7z1h5hbjk7k6npkpl7icvcxdcjd7rmyjp2";
-    };
-  }
-  {
-    goPackagePath = "github.com/shirou/gopsutil";
-    fetch = {
-      type = "git";
-      url = "https://github.com/shirou/gopsutil";
-      rev = "1516eb9ddc5e61ba58874047a98f8b44b5e585e8";
-      sha256 = "1pnl1g2l1y5vmnraq97rbm0nirprqvfzxsp6h4xacn1429jdl5bv";
-    };
-  }
-  {
-    goPackagePath = "github.com/soniah/gosnmp";
-    fetch = {
-      type = "git";
-      url = "https://github.com/soniah/gosnmp";
-      rev = "3fe3beb30fa9700988893c56a63b1df8e1b68c26";
-      sha256 = "0a0vlxx1plqj9fi863wd8ajbzl705wgma4qk75v949azgn1yx9ib";
-    };
-  }
-  {
-    goPackagePath = "github.com/streadway/amqp";
-    fetch = {
-      type = "git";
-      url = "https://github.com/streadway/amqp";
-      rev = "b4f3ceab0337f013208d31348b578d83c0064744";
-      sha256 = "1whcg2l6w2q7xrkk8q5y95i90ckq72bpgksii9ibrpyixbx7p5xp";
-    };
-  }
-  {
-    goPackagePath = "github.com/stretchr/testify";
-    fetch = {
-      type = "git";
-      url = "https://github.com/stretchr/testify";
-      rev = "1f4a1643a57e798696635ea4c126e9127adb7d3c";
-      sha256 = "0nam9d68rn8ha8ldif22kkgv6k6ph3y88fp26159wdrs63ca3bzl";
-    };
-  }
-  {
-    goPackagePath = "github.com/vjeantet/grok";
-    fetch = {
-      type = "git";
-      url = "https://github.com/vjeantet/grok";
-      rev = "83bfdfdfd1a8146795b28e547a8e3c8b28a466c2";
-      sha256 = "03zdcg9gy482gbasa7sw4cpw1k1n3dr2q06q80qnkqn268p7hp80";
-    };
-  }
-  {
-    goPackagePath = "github.com/wvanbergen/kafka";
-    fetch = {
-      type = "git";
-      url = "https://github.com/wvanbergen/kafka";
-      rev = "bc265fedb9ff5b5c5d3c0fdcef4a819b3523d3ee";
-      sha256 = "0x86gnkpsr6gsc6mk2312ay8yqrzscvvdra2knhvwgaws6rzvj2l";
-    };
-  }
-  {
-    goPackagePath = "github.com/wvanbergen/kazoo-go";
-    fetch = {
-      type = "git";
-      url = "https://github.com/wvanbergen/kazoo-go";
-      rev = "0f768712ae6f76454f987c3356177e138df258f8";
-      sha256 = "1paaayg03nknbnl3kdl0ybqv4llz7iwry7f29i0bh9srb6c87x16";
-    };
-  }
-  {
-    goPackagePath = "github.com/yuin/gopher-lua";
-    fetch = {
-      type = "git";
-      url = "https://github.com/yuin/gopher-lua";
-      rev = "bf3808abd44b1e55143a2d7f08571aaa80db1808";
-      sha256 = "02m7ly5yzc3snvxlfl9j4ggwd7v0kpvy3pqgqbfr7scdjxdap4nm";
-    };
-  }
-  {
-    goPackagePath = "github.com/zensqlmonitor/go-mssqldb";
-    fetch = {
-      type = "git";
-      url = "https://github.com/zensqlmonitor/go-mssqldb";
-      rev = "ffe5510c6fa5e15e6d983210ab501c815b56b363";
-      sha256 = "079x8ms8lv5p6253ppaxva37k6w04xnd38y8763rr2giswxqzlkl";
-    };
-  }
-  {
-    goPackagePath = "golang.org/x/crypto";
-    fetch = {
-      type = "git";
-      url = "https://go.googlesource.com/crypto";
-      rev = "c197bcf24cde29d3f73c7b4ac6fd41f4384e8af6";
-      sha256 = "1y2bbghi594m8p4pcm9pwrzql06179xj6zvhaghwcc6y0l48rbgp";
-    };
-  }
-  {
-    goPackagePath = "golang.org/x/net";
-    fetch = {
-      type = "git";
-      url = "https://go.googlesource.com/net";
-      rev = "6acef71eb69611914f7a30939ea9f6e194c78172";
-      sha256 = "1fcsv50sbq0lpzrhx3m9jw51wa255fsbqjwsx9iszq4d0gysnnvc";
-    };
-  }
-  {
-    goPackagePath = "golang.org/x/text";
-    fetch = {
-      type = "git";
-      url = "https://go.googlesource.com/text";
-      rev = "a71fd10341b064c10f4a81ceac72bcf70f26ea34";
-      sha256 = "1igxqrgnnb6983fl0yck0xal2hwnkcgbslr7cxyrg7a65vawd0q1";
-    };
-  }
-  {
-    goPackagePath = "gopkg.in/dancannon/gorethink.v1";
-    fetch = {
-      type = "git";
-      url = "https://gopkg.in/dancannon/gorethink.v1";
-      rev = "7d1af5be49cb5ecc7b177bf387d232050299d6ef";
-      sha256 = "0036hcadshka19bcqmq4mm9ssl9qhsx1n96lj1y24mh9g1api8fi";
-    };
-  }
-  {
-    goPackagePath = "gopkg.in/fatih/pool.v2";
-    fetch = {
-      type = "git";
-      url = "https://gopkg.in/fatih/pool.v2";
-      rev = "cba550ebf9bce999a02e963296d4bc7a486cb715";
-      sha256 = "1jlrakgnpvhi2ny87yrsj1gyrcncfzdhypa9i2mlvvzqlj4r0dn0";
-    };
-  }
-  {
-    goPackagePath = "gopkg.in/mgo.v2";
-    fetch = {
-      type = "git";
-      url = "https://gopkg.in/mgo.v2";
-      rev = "d90005c5262a3463800497ea5a89aed5fe22c886";
-      sha256 = "1z81k6mnfk07hkrkw31l16qycyiwa6wzyhysmywgkh58sm5dc9m7";
-    };
-  }
-  {
-    goPackagePath = "gopkg.in/yaml.v2";
-    fetch = {
-      type = "git";
-      url = "https://gopkg.in/yaml.v2";
-      rev = "a83829b6f1293c91addabc89d0571c246397bbf4";
-      sha256 = "1m4dsmk90sbi17571h6pld44zxz7jc4lrnl4f27dpd1l8g5xvjhh";
-    };
-  }
-]

pkgs/servers/monitoring/telegraf/deps-1.3.0.nix

···
+# This file was generated by https://github.com/kamilchm/go2nix v1.2.0
+[
+  {
+    goPackagePath = "collectd.org";
+    fetch = {
+      type = "git";
+      url = "https://github.com/collectd/go-collectd";
+      rev = "2ce144541b8903101fb8f1483cc0497a68798122";
+      sha256 = "0rr9rnc777jk27a7yxhdb7vgkj493158a8k6q44x51s30dkp78x3";
+    };
+  }
+  {
+    goPackagePath = "github.com/Shopify/sarama";
+    fetch = {
+      type = "git";
+      url = "https://github.com/Shopify/sarama";
+      rev = "574d3147eee384229bf96a5d12c207fe7b5234f3";
+      sha256 = "02ckm91bngkrbvkf4j7s5swrjjv3dr9kn9glwyc15apjv2ynkc4j";
+    };
+  }
+  {
+    goPackagePath = "github.com/Sirupsen/logrus";
+    fetch = {
+      type = "git";
+      url = "https://github.com/Sirupsen/logrus";
+      rev = "61e43dc76f7ee59a82bdf3d71033dc12bea4c77d";
+      sha256 = "08kr7zvdgwv8vsakjzq1bla6cc6dlxlg1brlga69y69xw7cz5l9p";
+    };
+  }
+  {
+    goPackagePath = "github.com/aerospike/aerospike-client-go";
+    fetch = {
+      type = "git";
+      url = "https://github.com/aerospike/aerospike-client-go";
+      rev = "95e1ad7791bdbca44707fedbb29be42024900d9c";
+      sha256 = "034pirm1dzdblwadcd829qk2jqkr8hg9gpfph8ax7z0b3h2ah8xf";
+    };
+  }
+  {
+    goPackagePath = "github.com/amir/raidman";
+    fetch = {
+      type = "git";
+      url = "https://github.com/amir/raidman";
+      rev = "c74861fe6a7bb8ede0a010ce4485bdbb4fc4c985";
+      sha256 = "10lmpz5vf2ysw8gnl0z8ravl4vvy48nbh8xpk2zzgifb6yn3x192";
+    };
+  }
+  {
+    goPackagePath = "github.com/aws/aws-sdk-go";
+    fetch = {
+      type = "git";
+      url = "https://github.com/aws/aws-sdk-go";
+      rev = "7524cb911daddd6e5c9195def8e59ae892bef8d9";
+      sha256 = "0dm8zfv3jdrbnhm1yyq6507v5lzi6wwhrpwkdswhf0ihgc9ca90z";
+    };
+  }
+  {
+    goPackagePath = "github.com/beorn7/perks";
+    fetch = {
+      type = "git";
+      url = "https://github.com/beorn7/perks";
+      rev = "4c0e84591b9aa9e6dcfdf3e020114cd81f89d5f9";
+      sha256 = "1hrybsql68xw57brzj805xx2mghydpdiysv3gbhr7f5wlxj2514y";
+    };
+  }
+  {
+    goPackagePath = "github.com/cenkalti/backoff";
+    fetch = {
+      type = "git";
+      url = "https://github.com/cenkalti/backoff";
+      rev = "b02f2bbce11d7ea6b97f282ef1771b0fe2f65ef3";
+      sha256 = "0lhcll9pzcxbbm9sdsijvcvdqc4lrsgbyw0q1xly0pnz556v6pyc";
+    };
+  }
+  {
+    goPackagePath = "github.com/couchbase/go-couchbase";
+    fetch = {
+      type = "git";
+      url = "https://github.com/couchbase/go-couchbase";
+      rev = "bfe555a140d53dc1adf390f1a1d4b0fd4ceadb28";
+      sha256 = "0h59zzxcz3i8nd4ln89fi946ii8kscnqam67h3mxvjwvpnmcax9k";
+    };
+  }
+  {
+    goPackagePath = "github.com/couchbase/gomemcached";
+    fetch = {
+      type = "git";
+      url = "https://github.com/couchbase/gomemcached";
+      rev = "4a25d2f4e1dea9ea7dd76dfd943407abf9b07d29";
+      sha256 = "12h0wsimwmr0f398538g9ngasik4gisnac9vpn0ldy8hqdpa334d";
+    };
+  }
+  {
+    goPackagePath = "github.com/couchbase/goutils";
+    fetch = {
+      type = "git";
+      url = "https://github.com/couchbase/goutils";
+      rev = "5823a0cbaaa9008406021dc5daf80125ea30bba6";
+      sha256 = "15v5ps2i2y2hczwxs2ci4c2w4p3pn3bl7vc5wlaqnc7i14f9285c";
+    };
+  }
+  {
+    goPackagePath = "github.com/davecgh/go-spew";
+    fetch = {
+      type = "git";
+      url = "https://github.com/davecgh/go-spew";
+      rev = "346938d642f2ec3594ed81d874461961cd0faa76";
+      sha256 = "0d4jfmak5p6lb7n2r6yvf5p1zcw0l8j74kn55ghvr7zr7b7axm6c";
+    };
+  }
+  {
+    goPackagePath = "github.com/docker/docker";
+    fetch = {
+      type = "git";
+      url = "https://github.com/docker/docker";
+      rev = "b89aff1afa1f61993ab2ba18fd62d9375a195f5d";
+      sha256 = "1lkj1wmv4nfj3vrrdc072p5iib8p1l0y52mlg55p94b20v18ph2m";
+    };
+  }
+  {
+    goPackagePath = "github.com/eapache/go-resiliency";
+    fetch = {
+      type = "git";
+      url = "https://github.com/eapache/go-resiliency";
+      rev = "b86b1ec0dd4209a588dc1285cdd471e73525c0b3";
+      sha256 = "1kzv95bh3nidm2cr7iv9lk3s2qiw1i17n8gyl2x6xk6qv8b0bc21";
+    };
+  }
+  {
+    goPackagePath = "github.com/eapache/go-xerial-snappy";
+    fetch = {
+      type = "git";
+      url = "https://github.com/eapache/go-xerial-snappy";
+      rev = "bb955e01b9346ac19dc29eb16586c90ded99a98c";
+      sha256 = "1zhxcil8hn88hvxr2d6rmj4cls5zgss1scj0ikwiqq89f8vcgwn4";
+    };
+  }
+  {
+    goPackagePath = "github.com/eapache/queue";
+    fetch = {
+      type = "git";
+      url = "https://github.com/eapache/queue";
+      rev = "44cc805cf13205b55f69e14bcb69867d1ae92f98";
+      sha256 = "07dp54n94gn3gsvdcki56yqh7py7wqqigxbamhxwgbr05n61fqyg";
+    };
+  }
+  {
+    goPackagePath = "github.com/eclipse/paho.mqtt.golang";
+    fetch = {
+      type = "git";
+      url = "https://github.com/eclipse/paho.mqtt.golang";
+      rev = "d4f545eb108a2d19f9b1a735689dbfb719bc21fb";
+      sha256 = "01cnca8y5caramqn6p8aigj6l5p6z0nrs2xqqv90658x584138kh";
+    };
+  }
+  {
+    goPackagePath = "github.com/go-sql-driver/mysql";
+    fetch = {
+      type = "git";
+      url = "https://github.com/go-sql-driver/mysql";
+      rev = "2e00b5cd70399450106cec6431c2e2ce3cae5034";
+      sha256 = "085g48jq9hzmlcxg122n0c4pi41sc1nn2qpx1vrl2jfa8crsppa5";
+    };
+  }
+  {
+    goPackagePath = "github.com/gobwas/glob";
+    fetch = {
+      type = "git";
+      url = "https://github.com/gobwas/glob";
+      rev = "bea32b9cd2d6f55753d94a28e959b13f0244797a";
+      sha256 = "0dx0f293v1a0d8qi7ik5hdl26dapd8xm0hj9a9gc620vhj7khi9q";
+    };
+  }
+  {
+    goPackagePath = "github.com/golang/protobuf";
+    fetch = {
+      type = "git";
+      url = "https://github.com/golang/protobuf";
+      rev = "8ee79997227bf9b34611aee7946ae64735e6fd93";
+      sha256 = "0qm1lpdhf97k2hxgivq2cpjgawhlmmz39y230kgxijhm96xijxb8";
+    };
+  }
+  {
+    goPackagePath = "github.com/golang/snappy";
+    fetch = {
+      type = "git";
+      url = "https://github.com/golang/snappy";
+      rev = "7db9049039a047d955fe8c19b83c8ff5abd765c7";
+      sha256 = "09l3sc9z2fqnj5b040q320gwb4gqig6lnysxcayhwckrdp5bm8hs";
+    };
+  }
+  {
+    goPackagePath = "github.com/gorilla/mux";
+    fetch = {
+      type = "git";
+      url = "https://github.com/gorilla/mux";
+      rev = "392c28fe23e1c45ddba891b0320b3b5df220beea";
+      sha256 = "0dmihkq34ls23by08r8p92qpf77imibjd9m9qvw344j4r2z7bd4d";
+    };
+  }
+  {
+    goPackagePath = "github.com/hailocab/go-hostpool";
+    fetch = {
+      type = "git";
+      url = "https://github.com/hailocab/go-hostpool";
+      rev = "e80d13ce29ede4452c43dea11e79b9bc8a15b478";
+      sha256 = "05ld4wp3illkbgl043yf8jq9y1ld0zzvrcg8jdij129j50xgfxny";
+    };
+  }
+  {
+    goPackagePath = "github.com/hashicorp/consul";
+    fetch = {
+      type = "git";
+      url = "https://github.com/hashicorp/consul";
+      rev = "63d2fc68239b996096a1c55a0d4b400ea4c2583f";
+      sha256 = "0vx7jpi2a9374mlhn37b33780n7g950zh482z2sd4lsf29n4c580";
+    };
+  }
+  {
+    goPackagePath = "github.com/influxdata/tail";
+    fetch = {
+      type = "git";
+      url = "https://github.com/influxdata/tail";
+      rev = "a395bf99fe07c233f41fba0735fa2b13b58588ea";
+      sha256 = "0bmkv932xhjpxwp8n74xy8wf34kiiknwq8agfbnz931apq6iw9b0";
+    };
+  }
+  {
+    goPackagePath = "github.com/influxdata/toml";
+    fetch = {
+      type = "git";
+      url = "https://github.com/influxdata/toml";
+      rev = "5d1d907f22ead1cd47adde17ceec5bda9cacaf8f";
+      sha256 = "1faf51s89sk1z41qfsazmddgwll7jq9xna67k3h3vry86c4vs2j4";
+    };
+  }
+  {
+    goPackagePath = "github.com/influxdata/wlog";
+    fetch = {
+      type = "git";
+      url = "https://github.com/influxdata/wlog";
+      rev = "7c63b0a71ef8300adc255344d275e10e5c3a71ec";
+      sha256 = "04kw4kivxvr3kkmghj3427b1xyhzbhnfr971qfn3lv2vvhs8kpfl";
+    };
+  }
+  {
+    goPackagePath = "github.com/jackc/pgx";
+    fetch = {
+      type = "git";
+      url = "https://github.com/jackc/pgx";
+      rev = "b84338d7d62598f75859b2b146d830b22f1b9ec8";
+      sha256 = "13q763a31yya8ij6m5zbnri7wc88hjwwn1rw4v7dmwbwsrqn885c";
+    };
+  }
+  {
+    goPackagePath = "github.com/kardianos/osext";
+    fetch = {
+      type = "git";
+      url = "https://github.com/kardianos/osext";
+      rev = "c2c54e542fb797ad986b31721e1baedf214ca413";
+      sha256 = "02vmjhkx90601l5fym7c3r4d44b88h3cign86nz4yy6j8qqxvz3h";
+    };
+  }
+  {
+    goPackagePath = "github.com/kardianos/service";
+    fetch = {
+      type = "git";
+      url = "https://github.com/kardianos/service";
+      rev = "6d3a0ee7d3425d9d835debc51a0ca1ffa28f4893";
+      sha256 = "1cgqg6zbwwsn6lz2ms094q4w37x84vd9ixs50wsh3037q4sfhyll";
+    };
+  }
+  {
+    goPackagePath = "github.com/kballard/go-shellquote";
+    fetch = {
+      type = "git";
+      url = "https://github.com/kballard/go-shellquote";
+      rev = "d8ec1a69a250a17bb0e419c386eac1f3711dc142";
+      sha256 = "1a57hm0zwyi70am670s0pkglnkk1ilddnmfxz1ba7innpkf5z6s7";
+    };
+  }
+  {
+    goPackagePath = "github.com/klauspost/crc32";
+    fetch = {
+      type = "git";
+      url = "https://github.com/klauspost/crc32";
+      rev = "cb6bfca970f6908083f26f39a79009d608efd5cd";
+      sha256 = "0q4yr4isgmph1yf1vq527lpmid7vqv56q7vxh3gkp5679fb90q6n";
+    };
+  }
+  {
+    goPackagePath = "github.com/matttproud/golang_protobuf_extensions";
+    fetch = {
+      type = "git";
+      url = "https://github.com/matttproud/golang_protobuf_extensions";
+      rev = "c12348ce28de40eed0136aa2b644d0ee0650e56c";
+      sha256 = "1d0c1isd2lk9pnfq2nk0aih356j30k3h1gi2w0ixsivi5csl7jya";
+    };
+  }
+  {
+    goPackagePath = "github.com/miekg/dns";
+    fetch = {
+      type = "git";
+      url = "https://github.com/miekg/dns";
+      rev = "99f84ae56e75126dd77e5de4fae2ea034a468ca1";
+      sha256 = "1v7rccng7mbzqh5qf8d8gqfppm127v32s8i1n3k50q3flv227byf";
+    };
+  }
+  {
+    goPackagePath = "github.com/naoina/go-stringutil";
+    fetch = {
+      type = "git";
+      url = "https://github.com/naoina/go-stringutil";
+      rev = "6b638e95a32d0c1131db0e7fe83775cbea4a0d0b";
+      sha256 = "00831p1wn3rimybk1z8l30787kn1akv5jax5wx743nn76qcmkmc6";
+    };
+  }
+  {
+    goPackagePath = "github.com/nats-io/go-nats";
+    fetch = {
+      type = "git";
+      url = "https://github.com/nats-io/go-nats";
+      rev = "ea9585611a4ab58a205b9b125ebd74c389a6b898";
+      sha256 = "0i2whh6c8grzi9slrk2clh3dhykxzid4zn395wgysg6gfjrbd5i5";
+    };
+  }
+  {
+    goPackagePath = "github.com/nats-io/nats";
+    fetch = {
+      type = "git";
+      url = "https://github.com/nats-io/nats";
+      rev = "ea9585611a4ab58a205b9b125ebd74c389a6b898";
+      sha256 = "0i2whh6c8grzi9slrk2clh3dhykxzid4zn395wgysg6gfjrbd5i5";
+    };
+  }
+  {
+    goPackagePath = "github.com/nats-io/nuid";
+    fetch = {
+      type = "git";
+      url = "https://github.com/nats-io/nuid";
+      rev = "289cccf02c178dc782430d534e3c1f5b72af807f";
+      sha256 = "1dpk8qzl43gfdaj2nbw52a0xyrmpmq26a9v9dfl27vkijssb20p4";
+    };
+  }
+  {
+    goPackagePath = "github.com/nsqio/go-nsq";
+    fetch = {
+      type = "git";
+      url = "https://github.com/nsqio/go-nsq";
+      rev = "a53d495e81424aaf7a7665a9d32a97715c40e953";
+      sha256 = "04npqz6ajr4r2w5jfvfzppr307qrwr57w4c1ppq9p9ddf7hx3wpz";
+    };
+  }
+  {
+    goPackagePath = "github.com/pierrec/lz4";
+    fetch = {
+      type = "git";
+      url = "https://github.com/pierrec/lz4";
+      rev = "5c9560bfa9ace2bf86080bf40d46b34ae44604df";
+      sha256 = "0j74a3xc48ispj8sb9c2sd1h53q99ws0f2x827b5p86xlpam8xyj";
+    };
+  }
+  {
+    goPackagePath = "github.com/pierrec/xxHash";
+    fetch = {
+      type = "git";
+      url = "https://github.com/pierrec/xxHash";
+      rev = "5a004441f897722c627870a981d02b29924215fa";
+      sha256 = "146ibrgvgh61jhbbv9wks0mabkci3s0m68sg6shmlv1yixkw6gja";
+    };
+  }
+  {
+    goPackagePath = "github.com/prometheus/client_golang";
+    fetch = {
+      type = "git";
+      url = "https://github.com/prometheus/client_golang";
+      rev = "c317fb74746eac4fc65fe3909195f4cf67c5562a";
+      sha256 = "1c3rqwkajkmhk5wh6agc5jnjbbfvpfxbiy8cprpw89khch428khp";
+    };
+  }
+  {
+    goPackagePath = "github.com/prometheus/client_model";
+    fetch = {
+      type = "git";
+      url = "https://github.com/prometheus/client_model";
+      rev = "fa8ad6fec33561be4280a8f0514318c79d7f6cb6";
+      sha256 = "11a7v1fjzhhwsl128znjcf5v7v6129xjgkdpym2lial4lac1dhm9";
+    };
+  }
+  {
+    goPackagePath = "github.com/prometheus/common";
+    fetch = {
+      type = "git";
+      url = "https://github.com/prometheus/common";
+      rev = "dd2f054febf4a6c00f2343686efb775948a8bff4";
+      sha256 = "0rhbgj51r105ax544mfg6wp4rsqpzn3776z1k82b21xwb3b51zr1";
+    };
+  }
+  {
+    goPackagePath = "github.com/prometheus/procfs";
+    fetch = {
+      type = "git";
+      url = "https://github.com/prometheus/procfs";
+      rev = "1878d9fbb537119d24b21ca07effd591627cd160";
+      sha256 = "0jqn5l31szmc0dv5invp5mdhndx3fcsda7zpy49zd7k95c1y20m7";
+    };
+  }
+  {
+    goPackagePath = "github.com/rcrowley/go-metrics";
+    fetch = {
+      type = "git";
+      url = "https://github.com/rcrowley/go-metrics";
+      rev = "1f30fe9094a513ce4c700b9a54458bbb0c96996c";
+      sha256 = "1hvbiaq4b6dqgjz6jkkxglfh9gf71zin6qsg508sh0r0ixfavrzj";
+    };
+  }
+  {
+    goPackagePath = "github.com/samuel/go-zookeeper";
+    fetch = {
+      type = "git";
+      url = "https://github.com/samuel/go-zookeeper";
+      rev = "1d7be4effb13d2d908342d349d71a284a7542693";
+      sha256 = "002s19109spms9ndfwykf3ryy3fnk7b56frxlqmmv37mlqgrd5v9";
+    };
+  }
+  {
+    goPackagePath = "github.com/satori/go.uuid";
+    fetch = {
+      type = "git";
+      url = "https://github.com/satori/go.uuid";
+      rev = "5bf94b69c6b68ee1b541973bb8e1144db23a194b";
+      sha256 = "0l782l4srv36pj8pfgn61996d0vjifld4a569rbjwq5h14pd0c07";
+    };
+  }
+  {
+    goPackagePath = "github.com/shirou/gopsutil";
+    fetch = {
+      type = "git";
+      url = "https://github.com/shirou/gopsutil";
+      rev = "70693b6a3da51a8a686d31f1b346077bbc066062";
+      sha256 = "0mrmwfpq8irqbmcqx64x7n1dw0qpl9kz4vbwm7c8bpfpjqmmni6b";
+    };
+  }
+  {
+    goPackagePath = "github.com/soniah/gosnmp";
+    fetch = {
+      type = "git";
+      url = "https://github.com/soniah/gosnmp";
+      rev = "5ad50dc75ab389f8a1c9f8a67d3a1cd85f67ed15";
+      sha256 = "0dqz0w077xfk9fj5dd8xa6sqgdvjpb8vx997wnqpi3kbii1b9jnb";
+    };
+  }
+  {
+    goPackagePath = "github.com/streadway/amqp";
+    fetch = {
+      type = "git";
+      url = "https://github.com/streadway/amqp";
+      rev = "63795daa9a446c920826655f26ba31c81c860fd6";
+      sha256 = "1v6xwskb4dqyy2q1r7k12f9wky7v6cfb4f1mx94sr3qvx37zg2yj";
+    };
+  }
+  {
+    goPackagePath = "github.com/stretchr/testify";
+    fetch = {
+      type = "git";
+      url = "https://github.com/stretchr/testify";
+      rev = "4d4bfba8f1d1027c4fdbe371823030df51419987";
+      sha256 = "1d3yz1d2s88byjzmn60jbi1m9s552f7ghzbzik97fbph37i8yjhp";
+    };
+  }
+  {
+    goPackagePath = "github.com/vjeantet/grok";
+    fetch = {
+      type = "git";
+      url = "https://github.com/vjeantet/grok";
+      rev = "d73e972b60935c7fec0b4ffbc904ed39ecaf7efe";
+      sha256 = "09p70h5inycwrw3dmn6c7lhx4m11fvw7449wzq1k5w2jcws7amd5";
+    };
+  }
+  {
+    goPackagePath = "github.com/wvanbergen/kafka";
+    fetch = {
+      type = "git";
+      url = "https://github.com/wvanbergen/kafka";
+      rev = "bc265fedb9ff5b5c5d3c0fdcef4a819b3523d3ee";
+      sha256 = "0x86gnkpsr6gsc6mk2312ay8yqrzscvvdra2knhvwgaws6rzvj2l";
+    };
+  }
+  {
+    goPackagePath = "github.com/wvanbergen/kazoo-go";
+    fetch = {
+      type = "git";
+      url = "https://github.com/wvanbergen/kazoo-go";
+      rev = "968957352185472eacb69215fa3dbfcfdbac1096";
+      sha256 = "07q37lmlc3vx620bklp93r368r73kgm2s9x7qcgcxk9701lqq7dc";
+    };
+  }
+  {
+    goPackagePath = "github.com/yuin/gopher-lua";
+    fetch = {
+      type = "git";
+      url = "https://github.com/yuin/gopher-lua";
+      rev = "66c871e454fcf10251c61bf8eff02d0978cae75a";
+      sha256 = "1srcibhsl29cy8qih132iqigl4ss303nfmglrgc583nj9kz9sf8j";
+    };
+  }
+  {
+    goPackagePath = "github.com/zensqlmonitor/go-mssqldb";
+    fetch = {
+      type = "git";
+      url = "https://github.com/zensqlmonitor/go-mssqldb";
+      rev = "ffe5510c6fa5e15e6d983210ab501c815b56b363";
+      sha256 = "079x8ms8lv5p6253ppaxva37k6w04xnd38y8763rr2giswxqzlkl";
+    };
+  }
+  {
+    goPackagePath = "golang.org/x/crypto";
+    fetch = {
+      type = "git";
+      url = "https://go.googlesource.com/crypto";
+      rev = "dc137beb6cce2043eb6b5f223ab8bf51c32459f4";
+      sha256 = "0kia3rd0g0vkb9pf102kbg1agr1xq27bi2shkpxy9l718yvy9jwd";
+    };
+  }
+  {
+    goPackagePath = "golang.org/x/net";
+    fetch = {
+      type = "git";
+      url = "https://go.googlesource.com/net";
+      rev = "f2499483f923065a842d38eb4c7f1927e6fc6e6d";
+      sha256 = "0q1ps8igfczfafk39hkp8gs57s6qxjvf2c48hiq00p873agz0x7s";
+    };
+  }
+  {
+    goPackagePath = "golang.org/x/text";
+    fetch = {
+      type = "git";
+      url = "https://go.googlesource.com/text";
+      rev = "506f9d5c962f284575e88337e7d9296d27e729d3";
+      sha256 = "1ghx5vv4zlkjzlx2gslvcwpvxjggpl6wz5n49nqxiz777psx218s";
+    };
+  }
+  {
+    goPackagePath = "gopkg.in/dancannon/gorethink.v1";
+    fetch = {
+      type = "git";
+      url = "https://gopkg.in/dancannon/gorethink.v1";
+      rev = "edc7a6a68e2d8015f5ffe1b2560eed989f8a45be";
+      sha256 = "0602082mfypdm98i963sdvij8l5ia5cw9r9cy7m6a60cvh1xmaka";
+    };
+  }
+  {
+    goPackagePath = "gopkg.in/fatih/pool.v2";
+    fetch = {
+      type = "git";
+      url = "https://gopkg.in/fatih/pool.v2";
+      rev = "6e328e67893eb46323ad06f0e92cb9536babbabc";
+      sha256 = "1p1sljfpbg2bp4qv7ghvz1wcmmsbcfclsninxa97kr0v7na7jw5p";
+    };
+  }
+  {
+    goPackagePath = "gopkg.in/mgo.v2";
+    fetch = {
+      type = "git";
+      url = "https://gopkg.in/mgo.v2";
+      rev = "3f83fa5005286a7fe593b055f0d7771a7dce4655";
+      sha256 = "19vwb6qlcyh3nh6pkk0bynwmr5cmi6mm4hdz01lwb4ybnkzxryc7";
+    };
+  }
+  {
+    goPackagePath = "gopkg.in/olivere/elastic.v5";
+    fetch = {
+      type = "git";
+      url = "https://gopkg.in/olivere/elastic.v5";
+      rev = "ee3ebceab960cf68ab9a89ee6d78c031ef5b4a4e";
+      sha256 = "0pby1b8s0h964cq6nld0arapkbfqb8vzm1k41cnxjq14ryh8adlh";
+    };
+  }
+  {
+    goPackagePath = "gopkg.in/yaml.v2";
+    fetch = {
+      type = "git";
+      url = "https://gopkg.in/yaml.v2";
+      rev = "4c78c975fe7c825c6d1466c42be594d1d6f3aba6";
+      sha256 = "1ddwvmsfijgl09pbqrcx73fy5kh8y3888dd29lh7i50ds5a088cx";
+    };
+  }
+]

pkgs/servers/openafs-client/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "openafs-${version}-${kernel.version}";
-  version = "1.6.20";
+  version = "1.6.20.2";
 
   src = fetchurl {
     url = "http://www.openafs.org/dl/openafs/${version}/openafs-${version}-src.tar.bz2";
-    sha256 = "0qar94k9x9dkws4clrnlw789q1ha9qjk06356s86hh78qwywc1ki";
+    sha256 = "50234820c3da9752d2ca05fb7e83b7dc5c96a0e96a0b875ebc7ae3c835607614";
   };
 
   nativeBuildInputs = [ autoconf automake flex yacc perl which ];
···
     platforms = platforms.linux;
     maintainers = [ maintainers.z77z ];
     broken =
-      (builtins.compareVersions kernel.version  "3.18" == -1) ||
-      (builtins.compareVersions kernel.version "4.4" != -1) ||
-      (kernel.features.grsecurity or false);
+      (builtins.compareVersions kernel.version  "3.18" == -1);
   };
 }

pkgs/servers/samba/4.x.nix

···
 
 stdenv.mkDerivation rec {
   name = "samba-${version}";
-  version = "4.5.3";
+  version = "4.5.8";
 
   src = fetchurl {
     url = "mirror://samba/pub/samba/stable/${name}.tar.gz";
-    sha256 = "1jif95684swssqwp9v3i2r08cn3r2iddf6ly68db4wmvl5ac8vgh";
+    sha256 = "1w41pxszv5z6gjclg6zymn47mk8n51lnpgcx1k2q18i3i1nnafzn";
   };
 
   outputs = [ "out" "dev" "man" ];

pkgs/servers/web-apps/shaarli/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "shaarli-${version}";
-  version = "0.8.1";
+  version = "0.8.4";
 
   src = fetchurl {
     url = "https://github.com/shaarli/Shaarli/releases/download/v${version}/shaarli-v${version}-full.tar.gz";
-    sha256 = "17p8bmkgmlan6vbvh955idddckr5kyf00gp8apjfcnm4b2awma8x";
+    sha256 = "1p6yljl8v8p74n71az1h68nnsvffw2hkcfk9p2dldspi4k51vnb7";
   };
 
   outputs = [ "out" "doc" ];

pkgs/tools/filesystems/sshfs-fuse/default.nix

···
 { stdenv, fetchFromGitHub, pkgconfig, glib, fuse, autoreconfHook }:
 
 stdenv.mkDerivation rec {
-  version = "2.7";
+  version = "2.9";
   name = "sshfs-fuse-${version}";
   
   src = fetchFromGitHub {
     repo = "sshfs";
     owner = "libfuse";
     rev = "sshfs-${version}";
-    sha256 = "17l9b89zy5qzfcknw3krk74rfrqaa8q1r8jwdsahaqajsy09h4x4";
+    sha256 = "1n0cq72ps4dzsh72fgfprqn8vcfr7ilrkvhzpy5500wjg88diapv";
   };
   
   buildInputs = [ pkgconfig glib fuse autoreconfHook ];

pkgs/tools/misc/ethtool/default.nix

···
 
 stdenv.mkDerivation rec {
   name = "ethtool-${version}";
-  version = "4.6";
+  version = "4.10";
 
   src = fetchurl {
     url = "mirror://kernel/software/network/ethtool/${name}.tar.xz";
-    sha256 = "e90589a9349d008cce8c0510ac4e8878efdc0ddb1b732a9a4cc333b101313415";
+    sha256 = "1fklbjwr41cvd5b7d1qvpl3bqzc4aak732r3m2wjhhgkxhk9f07h";
   };
 
   meta = with stdenv.lib; {

pkgs/tools/networking/zerotierone/default.nix

···
 { stdenv, fetchurl, openssl, lzo, zlib, iproute, which, ronn }:
 
 stdenv.mkDerivation rec {
-  version = "1.2.2";
+  version = "1.2.4";
   name = "zerotierone";
 
   src = fetchurl {
     url = "https://github.com/zerotier/ZeroTierOne/archive/${version}.tar.gz";
-    sha256 = "058sy6yrprd23iyx7fxnwyvnp1xxsd55yapjv5m2n7dcb7l4005h";
+    sha256 = "0n035f2qslw1srxjlm0szrnvb3va3sspbpxqqhng08dp68vmn9wz";
   };
 
   preConfigure = ''
···
     description = "Create flat virtual Ethernet networks of almost unlimited size";
     homepage = https://www.zerotier.com;
     license = licenses.gpl3;
-    maintainers = with maintainers; [ sjmackenzie zimbatm ];
+    maintainers = with maintainers; [ sjmackenzie zimbatm ehmry ];
     platforms = platforms.allBut [ "i686-linux" ];
   };
 }

pkgs/tools/security/metasploit/Gemfile

···
+# frozen_string_literal: true
+source "https://rubygems.org"
+
+gem "metasploit-framework", git: "https://github.com/rapid7/metasploit-framework", ref: "refs/tags/4.14.17"

pkgs/tools/security/metasploit/Gemfile.lock

···
+GIT
+  remote: https://github.com/rapid7/metasploit-framework
+  revision: fd3da8f3350d6cf7f0449bf0ead4d51747525c0a
+  ref: refs/tags/4.14.17
+  specs:
+    metasploit-framework (4.14.17)
+      actionpack (~> 4.2.6)
+      activerecord (~> 4.2.6)
+      activesupport (~> 4.2.6)
+      bcrypt
+      bit-struct
+      filesize
+      jsobfu
+      json
+      metasm
+      metasploit-concern
+      metasploit-credential
+      metasploit-model
+      metasploit-payloads (= 1.2.29)
+      metasploit_data_models
+      metasploit_payloads-mettle (= 0.1.9)
+      msgpack
+      nessus_rest
+      net-ssh
+      network_interface
+      nexpose
+      nokogiri
+      octokit
+      openssl-ccm
+      openvas-omp
+      packetfu
+      patch_finder
+      pcaprub
+      pg
+      railties
+      rb-readline
+      recog
+      redcarpet
+      rex-arch (= 0.1.4)
+      rex-bin_tools
+      rex-core
+      rex-encoder
+      rex-exploitation
+      rex-java
+      rex-mime
+      rex-nop
+      rex-ole
+      rex-powershell
+      rex-random_identifier
+      rex-registry
+      rex-rop_builder
+      rex-socket
+      rex-sslscan
+      rex-struct2
+      rex-text
+      rex-zip
+      robots
+      ruby_smb
+      rubyntlm
+      rubyzip
+      sqlite3
+      sshkey
+      tzinfo
+      tzinfo-data
+      windows_error
+      xmlrpc
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (4.2.8)
+      actionview (= 4.2.8)
+      activesupport (= 4.2.8)
+      rack (~> 1.6)
+      rack-test (~> 0.6.2)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+      rails-html-sanitizer (~> 1.0, >= 1.0.2)
+    actionview (4.2.8)
+      activesupport (= 4.2.8)
+      builder (~> 3.1)
+      erubis (~> 2.7.0)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+      rails-html-sanitizer (~> 1.0, >= 1.0.3)
+    activemodel (4.2.8)
+      activesupport (= 4.2.8)
+      builder (~> 3.1)
+    activerecord (4.2.8)
+      activemodel (= 4.2.8)
+      activesupport (= 4.2.8)
+      arel (~> 6.0)
+    activesupport (4.2.8)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    addressable (2.5.1)
+      public_suffix (~> 2.0, >= 2.0.2)
+    arel (6.0.4)
+    arel-helpers (2.3.0)
+      activerecord (>= 3.1.0, < 6)
+    bcrypt (3.1.11)
+    bindata (2.4.0)
+    bit-struct (0.16)
+    builder (3.2.3)
+    erubis (2.7.0)
+    faraday (0.12.1)
+      multipart-post (>= 1.2, < 3)
+    filesize (0.1.1)
+    i18n (0.8.1)
+    jsobfu (0.4.2)
+      rkelly-remix
+    json (2.1.0)
+    loofah (2.0.3)
+      nokogiri (>= 1.5.9)
+    metasm (1.0.3)
+    metasploit-concern (2.0.4)
+      activemodel (~> 4.2.6)
+      activesupport (~> 4.2.6)
+      railties (~> 4.2.6)
+    metasploit-credential (2.0.9)
+      metasploit-concern
+      metasploit-model
+      metasploit_data_models
+      pg
+      railties
+      rubyntlm
+      rubyzip
+    metasploit-model (2.0.4)
+      activemodel (~> 4.2.6)
+      activesupport (~> 4.2.6)
+      railties (~> 4.2.6)
+    metasploit-payloads (1.2.29)
+    metasploit_data_models (2.0.14)
+      activerecord (~> 4.2.6)
+      activesupport (~> 4.2.6)
+      arel-helpers
+      metasploit-concern
+      metasploit-model
+      pg
+      postgres_ext
+      railties (~> 4.2.6)
+      recog (~> 2.0)
+    metasploit_payloads-mettle (0.1.9)
+    mini_portile2 (2.1.0)
+    minitest (5.10.2)
+    msgpack (1.1.0)
+    multipart-post (2.0.0)
+    nessus_rest (0.1.6)
+    net-ssh (4.1.0)
+    network_interface (0.0.1)
+    nexpose (6.0.0)
+    nokogiri (1.7.2)
+      mini_portile2 (~> 2.1.0)
+    octokit (4.7.0)
+      sawyer (~> 0.8.0, >= 0.5.3)
+    openssl-ccm (1.2.1)
+    openvas-omp (0.0.4)
+    packetfu (1.1.13)
+      pcaprub
+    patch_finder (1.0.2)
+    pcaprub (0.12.4)
+    pg (0.20.0)
+    pg_array_parser (0.0.9)
+    postgres_ext (3.0.0)
+      activerecord (>= 4.0.0)
+      arel (>= 4.0.1)
+      pg_array_parser (~> 0.0.9)
+    public_suffix (2.0.5)
+    rack (1.6.6)
+    rack-test (0.6.3)
+      rack (>= 1.0)
+    rails-deprecated_sanitizer (1.0.3)
+      activesupport (>= 4.2.0.alpha)
+    rails-dom-testing (1.0.8)
+      activesupport (>= 4.2.0.beta, < 5.0)
+      nokogiri (~> 1.6)
+      rails-deprecated_sanitizer (>= 1.0.1)
+    rails-html-sanitizer (1.0.3)
+      loofah (~> 2.0)
+    railties (4.2.8)
+      actionpack (= 4.2.8)
+      activesupport (= 4.2.8)
+      rake (>= 0.8.7)
+      thor (>= 0.18.1, < 2.0)
+    rake (12.0.0)
+    rb-readline (0.5.4)
+    recog (2.1.6)
+      nokogiri
+    redcarpet (3.4.0)
+    rex-arch (0.1.4)
+      rex-text
+    rex-bin_tools (0.1.3)
+      metasm
+      rex-arch
+      rex-core
+      rex-struct2
+      rex-text
+    rex-core (0.1.10)
+    rex-encoder (0.1.4)
+      metasm
+      rex-arch
+      rex-text
+    rex-exploitation (0.1.14)
+      jsobfu
+      metasm
+      rex-arch
+      rex-encoder
+      rex-text
+    rex-java (0.1.5)
+    rex-mime (0.1.5)
+      rex-text
+    rex-nop (0.1.1)
+      rex-arch
+    rex-ole (0.1.6)
+      rex-text
+    rex-powershell (0.1.72)
+      rex-random_identifier
+      rex-text
+    rex-random_identifier (0.1.2)
+      rex-text
+    rex-registry (0.1.3)
+    rex-rop_builder (0.1.3)
+      metasm
+      rex-core
+      rex-text
+    rex-socket (0.1.6)
+      rex-core
+    rex-sslscan (0.1.4)
+      rex-socket
+      rex-text
+    rex-struct2 (0.1.2)
+    rex-text (0.2.15)
+    rex-zip (0.1.3)
+      rex-text
+    rkelly-remix (0.0.7)
+    robots (0.10.1)
+    ruby_smb (0.0.12)
+      bindata
+      rubyntlm
+      windows_error
+    rubyntlm (0.6.2)
+    rubyzip (1.2.1)
+    sawyer (0.8.1)
+      addressable (>= 2.3.5, < 2.6)
+      faraday (~> 0.8, < 1.0)
+    sqlite3 (1.3.13)
+    sshkey (1.9.0)
+    thor (0.19.4)
+    thread_safe (0.3.6)
+    tzinfo (1.2.3)
+      thread_safe (~> 0.1)
+    tzinfo-data (1.2017.2)
+      tzinfo (>= 1.0.0)
+    windows_error (0.1.2)
+    xmlrpc (0.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  metasploit-framework!
+
+BUNDLED WITH
+   1.14.6

pkgs/tools/security/metasploit/default.nix

···
-{ stdenv, fetchurl, makeWrapper, ruby }:
+{ stdenv, fetchFromGitHub, makeWrapper, ruby, bundlerEnv, ncurses }:
+
+# Maintainer notes for updating:
+# 1. increment version number in expression and in Gemfile
+# 2. run $ nix-shell --command "bundler install && bundix"
+#    in metasploit in nixpkgs
 
-stdenv.mkDerivation rec {
+let
+  env = bundlerEnv {
+    inherit ruby;
+    name = "metasploit-bundler-env";
+    gemdir = ./.;
+  };
+in stdenv.mkDerivation rec {
   name = "metasploit-framework-${version}";
-  version = "3.3.1";
+  version = "4.14.17";
 
-  src = fetchurl {
-    url = "http://downloads.metasploit.com/data/releases/archive/framework-${version}.tar.bz2";
-    sha256 = "07clzw1zfnqjhyydsc4mza238isai58p7aygh653qxsqb9a0j7qw";
+  src = fetchFromGitHub {
+    owner = "rapid7";
+    repo = "metasploit-framework";
+    rev = version;
+    sha256 = "0g666lxin9f0v9vhfh3s913ym8fnh32rpfl1rpj8d8n1azch5fn0";
   };
 
-  buildInputs = [makeWrapper];
+  buildInputs = [ makeWrapper ];
+
+  dontPatchelf = true; # stay away from exploit executables
 
   installPhase = ''
-    mkdir -p $out/share/msf
-    mkdir -p $out/bin
+    mkdir -p $out/{bin,share/msf}
 
     cp -r * $out/share/msf
 
     for i in $out/share/msf/msf*; do
-        makeWrapper $i $out/bin/$(basename $i) --prefix RUBYLIB : $out/share/msf/lib
+      bin=$out/bin/$(basename $i)
+      cat > $bin <<EOF
+#!/bin/sh -e
+exec ${env}/bin/bundle exec ${ruby}/bin/ruby $i "\$@"
+EOF
+      chmod +x $bin
     done
   '';
 
-  postInstall = ''
-    patchShebangs $out/share/msf
-  '';
-
-  meta = {
+  meta = with stdenv.lib; {
     description = "Metasploit Framework - a collection of exploits";
     homepage = https://github.com/rapid7/metasploit-framework/wiki;
-    platforms = stdenv.lib.platforms.unix;
+    platforms = platforms.unix;
+    license = licenses.bsd3;
+    maintainers = [ maintainers.makefu ];
   };
 }

pkgs/tools/security/metasploit/gemset.nix

···
+{
+  actionpack = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "09fbazl0ja80na2wadfp3fzmdmdy1lsb4wd2yg7anbj0zk0ap7a9";
+      type = "gem";
+    };
+    version = "4.2.8";
+  };
+  actionview = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1mg4a8143q2wjhjq4mngl69jkv249z5jvg0jkdribdv4zkg586rp";
+      type = "gem";
+    };
+    version = "4.2.8";
+  };
+  activemodel = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "11vhh7zmp92880s5sx8r32v2p0b7xg039mfr92pjynpkz4q901ld";
+      type = "gem";
+    };
+    version = "4.2.8";
+  };
+  activerecord = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1kk4dhn8jfhqfsf1dmb3a183gix6k46xr6cjkxj0rp51w2za1ns0";
+      type = "gem";
+    };
+    version = "4.2.8";
+  };
+  activesupport = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0wibdzd2f5l5rlsw1a1y3j3fhw2imrrbkxggdraa6q9qbdnc66hi";
+      type = "gem";
+    };
+    version = "4.2.8";
+  };
+  addressable = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1i8q32a4gr0zghxylpyy7jfqwxvwrivsxflg9mks6kx92frh75mh";
+      type = "gem";
+    };
+    version = "2.5.1";
+  };
+  arel = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0nfcrdiys6q6ylxiblky9jyssrw2xj96fmxmal7f4f0jj3417vj4";
+      type = "gem";
+    };
+    version = "6.0.4";
+  };
+  arel-helpers = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0k8hqa2505b2s3w6gajh2lvi2mn832yqldiy2z4c55phzkmr08sr";
+      type = "gem";
+    };
+    version = "2.3.0";
+  };
+  bcrypt = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1d254sdhdj6mzak3fb5x3jam8b94pvl1srladvs53j05a89j5z50";
+      type = "gem";
+    };
+    version = "3.1.11";
+  };
+  bindata = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "10sii2chgnkp2jw830sbr2wb20p8p1wcwrl9jhadkw94f505qcyg";
+      type = "gem";
+    };
+    version = "2.4.0";
+  };
+  bit-struct = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1w7x1fh4a6inpb46imhdf4xrq0z4d6zdpg7sdf8n98pif2hx50sx";
+      type = "gem";
+    };
+    version = "0.16";
+  };
+  builder = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0qibi5s67lpdv1wgcj66wcymcr04q6j4mzws6a479n0mlrmh5wr1";
+      type = "gem";
+    };
+    version = "3.2.3";
+  };
+  erubis = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1fj827xqjs91yqsydf0zmfyw9p4l2jz5yikg3mppz6d7fi8kyrb3";
+      type = "gem";
+    };
+    version = "2.7.0";
+  };
+  faraday = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1wkx9844vacsk2229xbc27djf6zw15kqd60ifr78whf9mp9v6l03";
+      type = "gem";
+    };
+    version = "0.12.1";
+  };
+  filesize = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "061qmg82mm9xnmnq3b7gbi24g28xk62w0b0nw86gybd07m1jn989";
+      type = "gem";
+    };
+    version = "0.1.1";
+  };
+  i18n = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1s6971zmjxszdrp59vybns9gzxpdxzdklakc5lp8nl4fx5kpxkbp";
+      type = "gem";
+    };
+    version = "0.8.1";
+  };
+  jsobfu = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1hchns89cfj0gggm2zbr7ghb630imxm2x2d21ffx2jlasn9xbkyk";
+      type = "gem";
+    };
+    version = "0.4.2";
+  };
+  json = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "01v6jjpvh3gnq6sgllpfqahlgxzj50ailwhj9b3cd20hi2dx0vxp";
+      type = "gem";
+    };
+    version = "2.1.0";
+  };
+  loofah = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "109ps521p0sr3kgc460d58b4pr1z4mqggan2jbsf0aajy9s6xis8";
+      type = "gem";
+    };
+    version = "2.0.3";
+  };
+  metasm = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0gss57q4lv6l0jkih77zffrpjjzgkdcsy7b9nvvawyzknis9w4s5";
+      type = "gem";
+    };
+    version = "1.0.3";
+  };
+  metasploit-concern = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0kqby5ycxhr0jfzvjqkdgjbqqjrg8jlmcxw8myrm0875hybyl1mq";
+      type = "gem";
+    };
+    version = "2.0.4";
+  };
+  metasploit-credential = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1y36f1f4nw0imhfbckl213ah7qgfldrkv2fpv2acslb6iqiaa3gk";
+      type = "gem";
+    };
+    version = "2.0.9";
+  };
+  metasploit-framework = {
+    source = {
+      fetchSubmodules = false;
+      rev = "fd3da8f3350d6cf7f0449bf0ead4d51747525c0a";
+      sha256 = "1r04drq34qfbhmhp0mqnm13vrycr7dcq670zk8xqiif5rhbij6qv";
+      type = "git";
+      url = "https://github.com/rapid7/metasploit-framework";
+    };
+    version = "4.14.17";
+  };
+  metasploit-model = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "05pnai1cv00xw87rrz38dz4s3ss45s90290d0knsy1mq6rp8yvmw";
+      type = "gem";
+    };
+    version = "2.0.4";
+  };
+  metasploit-payloads = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0c6wvnxgwdiryz5skzrp2wcfbxp57icaclckjcaxlw63v09wgjii";
+      type = "gem";
+    };
+    version = "1.2.29";
+  };
+  metasploit_data_models = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0hb2wsz3d4xgjf6dlf7nzxlv6q7rcdgn1pj79xs3g8al38zi129g";
+      type = "gem";
+    };
+    version = "2.0.14";
+  };
+  metasploit_payloads-mettle = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "058ijqznh4xqx3d6dph5gwdsmj96z4n46rl1mm85fyxpgpkifqd1";
+      type = "gem";
+    };
+    version = "0.1.9";
+  };
+  mini_portile2 = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1y25adxb1hgg1wb2rn20g3vl07qziq6fz364jc5694611zz863hb";
+      type = "gem";
+    };
+    version = "2.1.0";
+  };
+  minitest = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "11my86fnihvpndyknn3c14hc82nhsgggnhlxh8h3bdjpmfsvl0my";
+      type = "gem";
+    };
+    version = "5.10.2";
+  };
+  msgpack = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0ck7w17d6b4jbb8inh1q57bghi9cjkiaxql1d3glmj1yavbpmlh7";
+      type = "gem";
+    };
+    version = "1.1.0";
+  };
+  multipart-post = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "09k0b3cybqilk1gwrwwain95rdypixb2q9w65gd44gfzsd84xi1x";
+      type = "gem";
+    };
+    version = "2.0.0";
+  };
+  nessus_rest = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1allyrd4rll333zbmsi3hcyg6cw1dhc4bg347ibsw191nswnp8ci";
+      type = "gem";
+    };
+    version = "0.1.6";
+  };
+  net-ssh = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "013p5jb4wy0cq7x7036piw2a3s1i9p752ki1srx2m289mpz4ml3q";
+      type = "gem";
+    };
+    version = "4.1.0";
+  };
+  network_interface = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0ir4c1vbz1y0gxyih024262i7ig1nji1lkylcrn9pjzx3798p97a";
+      type = "gem";
+    };
+    version = "0.0.1";
+  };
+  nexpose = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0jdhhzzs3b3rav6imx8jn9920cjj83yjvz35q169y0ppla2xzqbg";
+      type = "gem";
+    };
+    version = "6.0.0";
+  };
+  nokogiri = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0jd8q3pr5rkrxx1vklvhcqcgl8kmfv5c8ny36ni3z5mirw6cm70c";
+      type = "gem";
+    };
+    version = "1.7.2";
+  };
+  octokit = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0h6cm7bi0y7ysjgwws3paaipqdld6c0m0niazrjahhpz88qqq1g4";
+      type = "gem";
+    };
+    version = "4.7.0";
+  };
+  openssl-ccm = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "18h5lxv0zh4j2f0wnhdmfz63x02vbzbq2k1clz6kzr0q83h8kj9c";
+      type = "gem";
+    };
+    version = "1.2.1";
+  };
+  openvas-omp = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "14xf614vd76qjdjxjv14mmjar6s64fwp4cwb7bv5g1wc29srg28x";
+      type = "gem";
+    };
+    version = "0.0.4";
+  };
+  packetfu = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "16ppq9wfxq4x2hss61l5brs3s6fmi8gb50mnp1nnnzb1asq4g8ll";
+      type = "gem";
+    };
+    version = "1.1.13";
+  };
+  patch_finder = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1md9scls55n1riw26vw1ak0ajq38dfygr36l0h00wqhv51cq745m";
+      type = "gem";
+    };
+    version = "1.0.2";
+  };
+  pcaprub = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0pl4lqy7308185pfv0197n8b4v20fhd0zb3wlpz284rk8ssclkvz";
+      type = "gem";
+    };
+    version = "0.12.4";
+  };
+  pg = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "03xcgwjs6faxis81jxf2plnlalg55dhhafqv3kvjxfr8ic7plpw5";
+      type = "gem";
+    };
+    version = "0.20.0";
+  };
+  pg_array_parser = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1034dhg8h53j48sfm373js54skg4vpndjga6hzn2zylflikrrf3s";
+      type = "gem";
+    };
+    version = "0.0.9";
+  };
+  postgres_ext = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1lbp1qf5s1addhznm7d4bzks9adh7jpilgcsr8k7mbd0a1ailcgc";
+      type = "gem";
+    };
+    version = "3.0.0";
+  };
+  public_suffix = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "040jf98jpp6w140ghkhw2hvc1qx41zvywx5gj7r2ylr1148qnj7q";
+      type = "gem";
+    };
+    version = "2.0.5";
+  };
+  rack = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "073d6rjgqfb4xjhbshyrflqgbdvxqvx4b907j2d4mi5qgbv8y2ax";
+      type = "gem";
+    };
+    version = "1.6.6";
+  };
+  rack-test = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0h6x5jq24makgv2fq5qqgjlrk74dxfy62jif9blk43llw8ib2q7z";
+      type = "gem";
+    };
+    version = "0.6.3";
+  };
+  rails-deprecated_sanitizer = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0qxymchzdxww8bjsxj05kbf86hsmrjx40r41ksj0xsixr2gmhbbj";
+      type = "gem";
+    };
+    version = "1.0.3";
+  };
+  rails-dom-testing = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1ny7mbjxhq20rzg4pivvyvk14irmc7cn20kxfk3vc0z2r2c49p8r";
+      type = "gem";
+    };
+    version = "1.0.8";
+  };
+  rails-html-sanitizer = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "138fd86kv073zqfx0xifm646w6bgw2lr8snk16lknrrfrss8xnm7";
+      type = "gem";
+    };
+    version = "1.0.3";
+  };
+  railties = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0bavl4hj7bnl3ryqi9rvykm410kflplgingkcxasfv1gdilddh4g";
+      type = "gem";
+    };
+    version = "4.2.8";
+  };
+  rake = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "01j8fc9bqjnrsxbppncai05h43315vmz9fwg28qdsgcjw9ck1d7n";
+      type = "gem";
+    };
+    version = "12.0.0";
+  };
+  rb-readline = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "170m6d2298s9kfbd4y3zzj4irsnd15qlbgi6kk93m88lkh9qzy3a";
+      type = "gem";
+    };
+    version = "0.5.4";
+  };
+  recog = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "08ypzrn40jbjbzwdbbjkcqdm74zlsc0yr2iqs0yn479fa5k8ajw4";
+      type = "gem";
+    };
+    version = "2.1.6";
+  };
+  redcarpet = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0h9qz2hik4s9knpmbwrzb3jcp3vc5vygp9ya8lcpl7f1l9khmcd7";
+      type = "gem";
+    };
+    version = "3.4.0";
+  };
+  rex-arch = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1y2mzv6wkqgclxl1x65mdq4d0lcgbbny4r1v24c16gi4jg9nsnc1";
+      type = "gem";
+    };
+    version = "0.1.4";
+  };
+  rex-bin_tools = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0skrbpyal6anh4g1nsaf9ypg5sd2ghxxmghasxw4p1s1i1xbmhwr";
+      type = "gem";
+    };
+    version = "0.1.3";
+  };
+  rex-core = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "09xbslrwbc9d0rp24y1pdgc6650ciwicq4q7skjz74rprr9wj16f";
+      type = "gem";
+    };
+    version = "0.1.10";
+  };
+  rex-encoder = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1zm5jdxgyyp8pkfqwin34izpxdrmglx6vmk20ifnvcsm55c9m70z";
+      type = "gem";
+    };
+    version = "0.1.4";
+  };
+  rex-exploitation = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0gbj28jqaaldpk4qzysgcl6m0wcqx3gcldarqdk55p5z9zasrk19";
+      type = "gem";
+    };
+    version = "0.1.14";
+  };
+  rex-java = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0j58k02p5g9snkpak64sb4aymkrvrh9xpqh8wsnya4w7b86w2y6i";
+      type = "gem";
+    };
+    version = "0.1.5";
+  };
+  rex-mime = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "15a14kz429h7pn81ysa6av3qijxjmxagjff6dyss5v394fxzxf4a";
+      type = "gem";
+    };
+    version = "0.1.5";
+  };
+  rex-nop = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0aigf9qsqsmiraa6zvfy1a7cyvf7zc3iyhzxi6fjv5sb8f64d6ny";
+      type = "gem";
+    };
+    version = "0.1.1";
+  };
+  rex-ole = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1pnzbqfnvbs0vc0z0ryszk3fxhgxrjd6gzwqa937rhlphwp5jpww";
+      type = "gem";
+    };
+    version = "0.1.6";
+  };
+  rex-powershell = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0nl60fdd1rlckk95d3s3y873w84vb0sgwvwxdzv414qxz8icpjnm";
+      type = "gem";
+    };
+    version = "0.1.72";
+  };
+  rex-random_identifier = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0cksrljaw61mdjvbmj9vqqhd8nra7jv466w5nim47n73rj72jc19";
+      type = "gem";
+    };
+    version = "0.1.2";
+  };
+  rex-registry = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0wv812ghnz143vx10ixmv32ypj1xrzr4rh4kgam8d8wwjwxsgw1q";
+      type = "gem";
+    };
+    version = "0.1.3";
+  };
+  rex-rop_builder = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0xjd3d6wnbq4ym0d0m268md8fb16f2hbwrahvxnl14q63fj9i3wy";
+      type = "gem";
+    };
+    version = "0.1.3";
+  };
+  rex-socket = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0r39782f2qpq83wsi72213v344gq4rccch98i376fx8bayh0dygh";
+      type = "gem";
+    };
+    version = "0.1.6";
+  };
+  rex-sslscan = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0r5cy1kng1ggjycn7a8vpval7clhr0yxhd7rgn2hasxl2p3c7i8v";
+      type = "gem";
+    };
+    version = "0.1.4";
+  };
+  rex-struct2 = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1nbdn53264a20cr2m2nq2v4mg0n33dvrd1jj1sixl37qjzw2k452";
+      type = "gem";
+    };
+    version = "0.1.2";
+  };
+  rex-text = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "024miva867h4wv4y1lnxxrw2d7p51va32ismxqf3fsz4s9cqc88m";
+      type = "gem";
+    };
+    version = "0.2.15";
+  };
+  rex-zip = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1mbfryyhcw47i7jb8cs8vilbyqgyiyjkfl1ngl6wdbf7d87dwdw7";
+      type = "gem";
+    };
+    version = "0.1.3";
+  };
+  rkelly-remix = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1g7hjl9nx7f953y7lncmfgp0xgxfxvgfm367q6da9niik6rp1y3j";
+      type = "gem";
+    };
+    version = "0.0.7";
+  };
+  robots = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "141gvihcr2c0dpzl3dqyh8kqc9121prfdql2iamaaw0mf9qs3njs";
+      type = "gem";
+    };
+    version = "0.10.1";
+  };
+  ruby_smb = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1v2acyx6csndb08sidb1pbixn2dlx9s75cpnjv4riwj0qlp8blli";
+      type = "gem";
+    };
+    version = "0.0.12";
+  };
+  rubyntlm = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1p6bxsklkbcqni4bcq6jajc2n57g0w5rzn4r49c3lb04wz5xg0dy";
+      type = "gem";
+    };
+    version = "0.6.2";
+  };
+  rubyzip = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "06js4gznzgh8ac2ldvmjcmg9v1vg9llm357yckkpylaj6z456zqz";
+      type = "gem";
+    };
+    version = "1.2.1";
+  };
+  sawyer = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0sv1463r7bqzvx4drqdmd36m7rrv6sf1v3c6vswpnq3k6vdw2dvd";
+      type = "gem";
+    };
+    version = "0.8.1";
+  };
+  sqlite3 = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "01ifzp8nwzqppda419c9wcvr8n82ysmisrs0hph9pdmv1lpa4f5i";
+      type = "gem";
+    };
+    version = "1.3.13";
+  };
+  sshkey = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0g02lh50jd5z4l9bp7xirnfn3n1dh9lr06dv3xh0kr3yhsny059h";
+      type = "gem";
+    };
+    version = "1.9.0";
+  };
+  thor = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "01n5dv9kql60m6a00zc0r66jvaxx98qhdny3klyj0p3w34pad2ns";
+      type = "gem";
+    };
+    version = "0.19.4";
+  };
+  thread_safe = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0nmhcgq6cgz44srylra07bmaw99f5271l0dpsvl5f75m44l0gmwy";
+      type = "gem";
+    };
+    version = "0.3.6";
+  };
+  tzinfo = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "05r81lk7q7275rdq7xipfm0yxgqyd2ggh73xpc98ypngcclqcscl";
+      type = "gem";
+    };
+    version = "1.2.3";
+  };
+  tzinfo-data = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1n83rmy476d4qmzq74qx0j7lbcpskbvrj1bmy3np4d5pydyw2yky";
+      type = "gem";
+    };
+    version = "1.2017.2";
+  };
+  windows_error = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "0kbcv9j5sc7pvjzf1dkp6h69i6lmj205zyy2arxcfgqg11bsz2kp";
+      type = "gem";
+    };
+    version = "0.1.2";
+  };
+  xmlrpc = {
+    source = {
+      remotes = ["https://rubygems.org"];
+      sha256 = "1s744iwblw262gj357pky3d9fcx9hisvla7rnw29ysn5zsb6i683";
+      type = "gem";
+    };
+    version = "0.3.0";
+  };
+}

pkgs/tools/security/metasploit/shell.nix

···
+# Env to update Gemfile.lock / gemset.nix
+with import <nixpkgs> {};
+stdenv.mkDerivation {
+  name = "env";
+  buildInputs = [
+    sqlite
+    libpcap
+    postgresql
+    libxml2
+    libxslt
+    pkgconfig
+    bundix
+  ];
+}

pkgs/tools/security/tor/default.nix

···
 }:
 
 stdenv.mkDerivation rec {
-  name = "tor-0.3.0.6";
+  name = "tor-0.3.0.7";
 
   src = fetchurl {
     url = "https://dist.torproject.org/${name}.tar.gz";
-    sha256 = "057vq8wagppmrlg85dgbsrk1v67yqpbi9n87s8gn0mdm7kli5rd3";
+    sha256 = "00kxa83bn0axh7479fynp6r8znq5wy26kvb8ghixgjpkir2c8h4n";
   };
 
   outputs = [ "out" "geoip" ];

pkgs/top-level/all-packages.nix

···
       exe=$out/libexec/${drv.pname}-${drv.version}/${drv.pname}
       install -D $out/bin/${drv.pname} $exe
       rm -rf $out/{bin,lib,share}
-      makeWrapper $exe $out/bin/${drv.pname} --prefix PATH ":" "${nix-prefetch-scripts}/bin"
+      makeWrapper $exe $out/bin/${drv.pname} \
+        --prefix PATH ":" "${nix}/bin" \
+        --prefix PATH ":" "${nix-prefetch-scripts}/bin"
       mkdir -p $out/share/bash-completion/completions
       $exe --bash-completion-script $exe >$out/share/bash-completion/completions/${drv.pname}
     '';
···
 
   mscgen = callPackage ../tools/graphics/mscgen { };
 
-  msf = callPackage ../tools/security/metasploit { };
+  metasploit = callPackage ../tools/security/metasploit { };
+  msf = metasploit;
 
   ms-sys = callPackage ../tools/misc/ms-sys { };
 
···
   linux_rpi = callPackage ../os-specific/linux/kernel/linux-rpi.nix {
     kernelPatches = with kernelPatches; [
       bridge_stp_helper
-      DCCP_double_free_vulnerability_CVE-2017-6074
     ];
   };
 
···
   fira = callPackage ../data/fonts/fira { };
 
   fira-code = callPackage ../data/fonts/fira-code { };
+  fira-code-symbols = callPackage ../data/fonts/fira-code/symbols.nix { };
 
   fira-mono = callPackage ../data/fonts/fira-mono { };
 
···
   go-ethereum = self.altcoins.go-ethereum;
   ethabi = self.altcoins.ethabi;
   ethrun = self.altcoins.ethrun;
+  seth = self.altcoins.seth;
 
   stellar-core = self.altcoins.stellar-core;
 
···
   mpc_cli = callPackage ../applications/audio/mpc { };
 
   clerk = callPackage ../applications/audio/clerk { };
+
+  nbstripout = callPackage ../applications/version-management/nbstripout { };
 
   ncmpc = callPackage ../applications/audio/ncmpc { };
 

pkgs/top-level/python-packages.nix

···
     };
   };
 
+  "3to2" = callPackage ../development/python-modules/3to2 { };
+
   aenum = callPackage ../development/python-modules/aenum { };
 
   agate = callPackage ../development/python-modules/agate { };
···
     doCheck = false; # lazy packager
   };
 
+  cram = callPackage ../development/python-modules/cram { };
+
   csscompressor = callPackage ../development/python-modules/csscompressor.nix {};
 
   csvkit =  callPackage ../development/python-modules/csvkit { };
···
         ${if stdenv.cc.isClang or false then ''--exclude="(cpdef_extern_func|libcpp_algo)"'' else ""}
     '';
 
+    # Disable tests temporarily
+    # https://github.com/cython/cython/issues/1676
+    doCheck = false;
+
     meta = {
       description = "An optimising static compiler for both the Python programming language and the extended Cython programming language";
       platforms = platforms.all;
···
     };
   };
 
+  pytest-cram = callPackage ../development/python-modules/pytest-cram { };
+
   pytest-datafiles = callPackage ../development/python-modules/pytest-datafiles { };
 
   pytest-django = callPackage ../development/python-modules/pytest-django { };
···
     };
   };
 
-  pytest_xdist = buildPythonPackage rec {
-    name = "pytest-xdist-1.14";
-
-    src = pkgs.fetchurl {
-      url = "mirror://pypi/p/pytest-xdist/${name}.zip";
-      sha256 = "08rn2l39ds60xshs4js787l84pfckksqklfq2wq9x8ig2aci2pja";
-    };
-
-    buildInputs = with self; [ pytest setuptools_scm ];
-    propagatedBuildInputs = with self; [ execnet ];
-
-    meta = {
-      description = "py.test xdist plugin for distributed testing and loop-on-failing modes";
-      homepage = https://github.com/pytest-dev/pytest-xdist;
-      license = licenses.mit;
-    };
-  };
+  pytest_xdist = callPackage ../development/python-modules/pytest-xdist { };
 
   pytest-localserver = buildPythonPackage rec {
     name = "pytest-localserver-${version}";
···
     };
   };
 
-  natsort = buildPythonPackage rec {
-    name = "natsort-5.0.1";
-
-    src = pkgs.fetchurl {
-      url = "mirror://pypi/n/natsort/${name}.tar.gz";
-      sha256 = "4ad6b4d1153451e345967989bd3ca30abf33f615b116eeadfcc51a456e6974a9";
-    };
-
-    buildInputs = with self;
-      [
-        hypothesis
-        pytestcache
-        pytestcov
-        pytestflakes
-        pytestpep8
-        pytest
-        mock
-      ]
-      # pathlib was made part of standard library in 3.5:
-      ++ (optionals (pythonOlder "3.4") [ pathlib ]);
-
-    meta = {
-      description = "Natural sorting for python";
-      homepage = https://github.com/SethMMorton/natsort;
-      license = licenses.mit;
-      broken = true;
-    };
-  };
+  natsort = callPackage ../development/python-modules/natsort { };
 
   logster = buildPythonPackage {
     name = "logster-7475c53822";
···
     };
   };
 
-
-  buildNumpyPackage = callPackage ../development/python-modules/numpy.nix {
-    gfortran = pkgs.gfortran;
+  numpy = callPackage ../development/python-modules/numpy {
     blas = pkgs.openblasCompat;
-  };
-
-  numpy = self.numpy_1_11;
-
-  numpy_1_10 = self.buildNumpyPackage rec {
-    version = "1.10.4";
-    src = pkgs.fetchurl {
-      url = "mirror://pypi/n/numpy/numpy-${version}.tar.gz";
-      sha256 = "7356e98fbcc529e8d540666f5a919912752e569150e9a4f8d869c686f14c720b";
-    };
-  };
-
-  numpy_1_11 = self.buildNumpyPackage rec {
-    version = "1.11.3";
-    src = pkgs.fetchurl {
-      url = "mirror://pypi/n/numpy/numpy-${version}.zip";
-      sha256 = "2e0fc5248246a64628656fe14fcab0a959741a2820e003bd15538226501b82f7";
-    };
   };
 
   numpydoc = buildPythonPackage rec {
···
     };
   };
 
+  piexif = callPackage ../development/python-modules/piexif { };
+
   pip = buildPythonPackage rec {
     pname = "pip";
     version = "9.0.1";
···
 
     src = fetchPypi {
       inherit pname version;
-      sha256 = "4929d022713129401160fd47550d5158931e4ea6a7136b5d8dfe3b13ac16f2f0";
+      sha256 = "1rvf5jw9hknqz02rp1vg8abgb1lpa0bc65l7ylmlillqx7bswq3r";
     };
 
     # No tests in archive
···
     };
   };
 
-  buildScipyPackage = callPackage ../development/python-modules/scipy.nix {
-    gfortran = pkgs.gfortran;
-  };
-
-  scipy = self.scipy_0_18;
-
-  scipy_0_17 = self.buildScipyPackage rec {
-    version = "0.17.1";
-    src = pkgs.fetchurl {
-      url = "mirror://pypi/s/scipy/scipy-${version}.tar.gz";
-      sha256 = "1b1qpfz2j2rvmlplsjbnznnxnqr9ckbmis506110ii1w07wd4k4w";
-    };
-    numpy = self.numpy;
-  };
-
-  scipy_0_18 = self.buildScipyPackage rec {
-    version = "0.18.1";
-    src = pkgs.fetchurl {
-      url = "mirror://pypi/s/scipy/scipy-${version}.tar.gz";
-      sha256 = "8ab6e9c808bf2fb3e8576cd8cf07226d9cdc18b012c06d9708429a821ac6634e";
-    };
-    numpy = self.numpy;
-  };
+  scipy = callPackage ../development/python-modules/scipy { };
 
   scikitimage = buildPythonPackage rec {
     name = "scikit-image-${version}";