nix: don't pass pkgs into injected vcsserver.

default.nix

@@ -1,292 +1,293 b''
 # Nix environment for the community edition
 #
 # This shall be as lean as possible, just producing the enterprise-ce
 # derivation. For advanced tweaks to pimp up the development environment we use
 # "shell.nix" so that it does not have to clutter this file.
 #
 # Configuration, set values in "~/.nixpkgs/config.nix".
 # example
 #  {
 #    # Thoughts on how to configure the dev environment
 #    rc = {
 #      codeInternalUrl = "https://usr:[e-mail]";
 #      sources = {
 #        rhodecode-vcsserver = "/home/user/work/rhodecode-vcsserver";
 #        rhodecode-enterprise-ce = "/home/user/work/rhodecode-enterprise-ce";
 #        rhodecode-enterprise-ee = "/home/user/work/rhodecode-enterprise-ee";
 #      };
 #    };
 #  }
 
 args@
 { pythonPackages ? "python27Packages"
 , pythonExternalOverrides ? self: super: {}
 , doCheck ? false
 , ...
 }:
 let pkgs_ = (import <nixpkgs> {}); in
 
 let
   # Use nixpkgs from args or import them. We use this indirect approach
   # through args to be able to use the name `pkgs` for our customized packages.
   # Otherwise we will end up with an infinite recursion.
   pkgs = args.pkgs or (import <nixpkgs> {
     overlays = [
       (import ./pkgs/overlays.nix)
     ];
-    inherit (pkgs_)
+    inherit
+      (pkgs_)
       system;
   });
 
   # Works with the new python-packages, still can fallback to the old
   # variant.
   basePythonPackagesUnfix = basePythonPackages.__unfix__ or (
     self: basePythonPackages.override (a: { inherit self; }));
 
   # Evaluates to the last segment of a file system path.
   basename = path: with pkgs.lib; last (splitString "/" path);
 
   # source code filter used as arugment to builtins.filterSource.
   src-filter = path: type: with pkgs.lib;
     let
       ext = last (splitString "." path);
     in
       !builtins.elem (basename path) [
         ".git" ".hg" "__pycache__" ".eggs" ".idea" ".dev"
         "bower_components" "node_modules"
         "build" "data" "result" "tmp"] &&
       !builtins.elem ext ["egg-info" "pyc"] &&
       # TODO: johbo: This check is wrong, since "path" contains an absolute path,
       # it would still be good to restore it since we want to ignore "result-*".
       !hasPrefix "result" path;
 
   sources =
     let
       inherit
         (pkgs.lib)
         all
         isString
         attrValues;
       sourcesConfig = pkgs.config.rc.sources or {};
     in
       # Ensure that sources are configured as strings. Using a path
       # would result in a copy into the nix store.
       assert all isString (attrValues sourcesConfig);
       sourcesConfig;
 
   version = builtins.readFile "${rhodecode-enterprise-ce-src}/rhodecode/VERSION";
   rhodecode-enterprise-ce-src = builtins.filterSource src-filter ./.;
 
   buildBowerComponents = pkgs.buildBowerComponents;
   nodeEnv = import ./pkgs/node-default.nix {
     inherit
       pkgs;
   };
   nodeDependencies = nodeEnv.shell.nodeDependencies;
 
   bowerComponents = buildBowerComponents {
     name = "enterprise-ce-${version}";
     generated = ./pkgs/bower-packages.nix;
     src = rhodecode-enterprise-ce-src;
   };
 
   rhodecode-testdata-src = sources.rhodecode-testdata or (
     pkgs.fetchhg {
       url = "https://code.rhodecode.com/upstream/rc_testdata";
       rev = "v0.10.0";
       sha256 = "0zn9swwvx4vgw4qn8q3ri26vvzgrxn15x6xnjrysi1bwmz01qjl0";
   });
 
   rhodecode-testdata = import "${rhodecode-testdata-src}/default.nix" {
   inherit
     doCheck
     pkgs
     pythonPackages;
   };
 
   pythonLocalOverrides = self: super: {
     rhodecode-enterprise-ce =
       let
         linkNodeAndBowerPackages = ''
           export RHODECODE_CE_PATH=${rhodecode-enterprise-ce-src}
 
           echo "[BEGIN]: Link node packages"
           rm -fr node_modules
           mkdir node_modules
           # johbo: Linking individual packages allows us to run "npm install"
           # inside of a shell to try things out. Re-entering the shell will
           # restore a clean environment.
           ln -s ${nodeDependencies}/lib/node_modules/* node_modules/
           echo "[DONE]: Link node packages"
 
           echo "[BEGIN]: Link bower packages"
           rm -fr bower_components
           mkdir bower_components
           ln -s ${bowerComponents}/bower_components/* bower_components/
           echo "[DONE]: Link bower packages"
         '';
 
         releaseName = "RhodeCodeEnterpriseCE-${version}";
       in super.rhodecode-enterprise-ce.override (attrs: {
       inherit
         doCheck
         version;
 
       name = "rhodecode-enterprise-ce-${version}";
       releaseName = releaseName;
       src = rhodecode-enterprise-ce-src;
       dontStrip = true; # prevent strip, we don't need it.
 
       # expose following attributed outside
       passthru = {
         inherit
           rhodecode-testdata
           bowerComponents
           linkNodeAndBowerPackages
           myPythonPackagesUnfix
           pythonLocalOverrides
           pythonCommunityOverrides;
 
         pythonPackages = self;
       };
 
       buildInputs =
         attrs.buildInputs or [] ++ [
           rhodecode-testdata
           pkgs.nodePackages.bower
           pkgs.nodePackages.grunt-cli
         ];
 
       #NOTE: option to inject additional propagatedBuildInputs
       propagatedBuildInputs =
         attrs.propagatedBuildInputs or [] ++ [
 
         ];
 
       LC_ALL = "en_US.UTF-8";
       LOCALE_ARCHIVE =
         if pkgs.stdenv.isLinux
         then "${pkgs.glibcLocales}/lib/locale/locale-archive"
         else "";
 
       # Add bin directory to path so that tests can find 'rhodecode'.
       preCheck = ''
         export PATH="$out/bin:$PATH"
       '';
 
       # custom check phase for testing
       checkPhase = ''
         runHook preCheck
         PYTHONHASHSEED=random py.test -vv -p no:sugar -r xw --cov-config=.coveragerc --cov=rhodecode --cov-report=term-missing rhodecode
         runHook postCheck
       '';
 
       postCheck = ''
         echo "Cleanup of rhodecode/tests"
         rm -rf $out/lib/${self.python.libPrefix}/site-packages/rhodecode/tests
       '';
 
       preBuild = ''
         echo "Building frontend assets"
         ${linkNodeAndBowerPackages}
         grunt
         rm -fr node_modules
       '';
 
       postInstall = ''
         # check required files
         if [ ! -f rhodecode/public/js/scripts.js ]; then
           echo "Missing scripts.js"
           exit 1
         fi
         if [ ! -f rhodecode/public/css/style.css ]; then
           echo "Missing style.css"
           exit 1
         fi
 
         echo "Writing enterprise-ce meta information for rccontrol to nix-support/rccontrol"
         mkdir -p $out/nix-support/rccontrol
         cp -v rhodecode/VERSION $out/nix-support/rccontrol/version
         echo "[DONE]: enterprise-ce meta information for rccontrol written"
 
         mkdir -p $out/etc
         cp configs/production.ini $out/etc
         echo "[DONE]: saved enterprise-ce production.ini into $out/etc"
 
         cp -r rhodecode/config/rcextensions $out/etc/rcextensions.tmpl
         echo "[DONE]: saved enterprise-ce rcextensions into $out/etc/rcextensions.tmpl"
 
         # python based programs need to be wrapped
         mkdir -p $out/bin
 
         # required binaries from dependencies
         ln -s ${self.supervisor}/bin/supervisorctl $out/bin/
         ln -s ${self.supervisor}/bin/supervisord $out/bin/
         ln -s ${self.pastescript}/bin/paster $out/bin/
         ln -s ${self.channelstream}/bin/channelstream $out/bin/
         ln -s ${self.celery}/bin/celery $out/bin/
         ln -s ${self.gunicorn}/bin/gunicorn $out/bin/
         ln -s ${self.pyramid}/bin/prequest $out/bin/
         ln -s ${self.pyramid}/bin/pserve $out/bin/
 
         echo "[DONE]: created symlinks into $out/bin"
         DEPS="$out/bin/supervisorctl \
               $out/bin/supervisord \
               $out/bin/paster \
               $out/bin/channelstream \
               $out/bin/celery \
               $out/bin/gunicorn \
               $out/bin/prequest \
               $out/bin/pserve"
 
         # wrap only dependency scripts, they require to have full PYTHONPATH set
         # to be able to import all packages
         for file in $DEPS;
         do
           wrapProgram $file \
             --prefix PATH : $PATH \
             --prefix PYTHONPATH : $PYTHONPATH \
             --set PYTHONHASHSEED random
         done
 
         echo "[DONE]: enterprise-ce binary wrapping"
 
         # rhodecode-tools don't need wrapping
         ln -s ${self.rhodecode-tools}/bin/rhodecode-* $out/bin/
 
       '';
     });
 
   };
 
   basePythonPackages = with builtins;
     if isAttrs pythonPackages then
       pythonPackages
     else
       getAttr pythonPackages pkgs;
 
   pythonGeneratedPackages = import ./pkgs/python-packages.nix {
     inherit
       pkgs;
     inherit
       (pkgs)
       fetchurl
       fetchgit
       fetchhg;
   };
 
   pythonCommunityOverrides = import ./pkgs/python-packages-overrides.nix {
     inherit pkgs basePythonPackages;
   };
 
   # Apply all overrides and fix the final package set
   myPythonPackagesUnfix = with pkgs.lib;
     (extends pythonExternalOverrides
     (extends pythonLocalOverrides
     (extends pythonCommunityOverrides
     (extends pythonGeneratedPackages
              basePythonPackagesUnfix))));
 
   myPythonPackages = (pkgs.lib.fix myPythonPackagesUnfix);
 
 in myPythonPackages.rhodecode-enterprise-ce

shell.nix

@@ -1,118 +1,117 b''
 # This file contains the adjustments which are desired for a development
 # environment.
 
 { pkgs ? (import <nixpkgs> {})
 , pythonPackages ? "python27Packages"
 , doCheck ? false
 , sourcesOverrides ? {}
 , doDevelopInstall ? true
 }:
 
 let
   # Get sources from config and update them with overrides.
   sources = (pkgs.config.rc.sources or {}) // sourcesOverrides;
 
   enterprise-ce = import ./default.nix {
     inherit
       pythonPackages
       doCheck;
   };
 
   ce-pythonPackages = enterprise-ce.pythonPackages;
 
   # This method looks up a path from `pkgs.config.rc.sources` and returns a
   # shell script which does a `python setup.py develop` installation of it. If
   # no path is found it will return an empty string.
   optionalDevelopInstall = attributeName:
     let
       path = pkgs.lib.attrByPath [attributeName] null sources;
       doIt = doDevelopInstall && path != null;
 
     in
       # do develop installation with empty hosts to skip any package duplicates to
       # be replaced. This only pushes the package to be locally available
       pkgs.lib.optionalString doIt (''
         echo "[BEGIN] Develop install of '${attributeName}' from '${path}'"
         pushd ${path}
         python setup.py develop --prefix $tmp_path --allow-hosts ""
         popd
         echo "[DONE] Develop install of '${attributeName}' from '${path}'"
         echo ""
       '');
 
   # This method looks up a path from `pkgs.config.rc.sources` and imports the
   # default.nix file if it exists. It returns the list of build inputs. If no
   # path is found it will return an empty list.
   optionalDevelopInstallBuildInputs = attributeName:
     let
       path = pkgs.lib.attrByPath [attributeName] null sources;
       doIt = doDevelopInstall && path != null && pkgs.lib.pathExists "${nixFile}";
       nixFile = "${path}/default.nix";
 
       derivate = import "${nixFile}" {
         inherit
           doCheck
-          pkgs
           pythonPackages;
       };
     in
       pkgs.lib.lists.optionals doIt (
         derivate.propagatedBuildInputs
       );
 
   developInstalls = [ "rhodecode-vcsserver" ];
 
 in enterprise-ce.override (attrs: {
   # Avoid that we dump any sources into the store when entering the shell and
   # make development a little bit more convenient.
   src = null;
 
   # Add dependencies which are useful for the development environment.
   buildInputs =
     attrs.buildInputs ++
     (with ce-pythonPackages; [
       bumpversion
       invoke
       ipdb
     ]);
 
   # place to inject some required libs from develop installs
   propagatedBuildInputs =
     attrs.propagatedBuildInputs ++
     pkgs.lib.lists.concatMap optionalDevelopInstallBuildInputs developInstalls;
 
 
   # Make sure we execute both hooks
   shellHook = ''
     runHook preShellHook
     runHook postShellHook
   '';
 
   preShellHook = ''
     echo "Entering CE-Shell"
 
     # Custom prompt to distinguish from other dev envs.
     export PS1="\n\[\033[1;32m\][CE-shell:\w]$\[\033[0m\] "
 
     echo "Building frontend assets"
     ${enterprise-ce.linkNodeAndBowerPackages}
 
     # Setup a temporary directory.
     tmp_path=$(mktemp -d)
     export PATH="$tmp_path/bin:$PATH"
     export PYTHONPATH="$tmp_path/${ce-pythonPackages.python.sitePackages}:$PYTHONPATH"
     mkdir -p $tmp_path/${ce-pythonPackages.python.sitePackages}
 
     # Develop installation
     echo "[BEGIN]: develop install of rhodecode-enterprise-ce"
     python setup.py develop --prefix $tmp_path --allow-hosts ""
   '';
 
   postShellHook = ''
     echo "** Additional develop installs **"
     '' +
     pkgs.lib.strings.concatMapStrings optionalDevelopInstall developInstalls
     + ''
   '';
 
 })