release: Merge default into stable for release preparation

configs/gunicorn_config.py

@@ -0,0 +1,152 b''
+"""
+gunicorn config extension and hooks. Sets additional configuration that is
+available post the .ini config.
+
+- workers = ${cpu_number}
+- threads = 1
+- proc_name = ${gunicorn_proc_name}
+- worker_class = sync
+- worker_connections = 10
+- max_requests = 1000
+- max_requests_jitter = 30
+- timeout = 21600
+
+"""
+
+import multiprocessing
+import sys
+import time
+import datetime
+import threading
+import traceback
+from gunicorn.glogging import Logger
+
+
+# GLOBAL
+errorlog = '-'
+accesslog = '-'
+loglevel = 'debug'
+
+# SECURITY
+
+# The maximum size of HTTP request line in bytes.
+limit_request_line = 4094
+
+# Limit the number of HTTP headers fields in a request.
+limit_request_fields = 1024
+
+# Limit the allowed size of an HTTP request header field.
+# Value is a positive number or 0.
+# Setting it to 0 will allow unlimited header field sizes.
+limit_request_field_size = 0
+
+
+# Timeout for graceful workers restart.
+# After receiving a restart signal, workers have this much time to finish
+# serving requests. Workers still alive after the timeout (starting from the
+# receipt of the restart signal) are force killed.
+graceful_timeout = 30
+
+
+# The number of seconds to wait for requests on a Keep-Alive connection.
+# Generally set in the 1-5 seconds range.
+keepalive = 2
+
+
+# SERVER MECHANICS
+# None == system temp dir
+# worker_tmp_dir is recommended to be set to some tmpfs
+worker_tmp_dir = None
+tmp_upload_dir = None
+
+# Custom log format
+access_log_format = (
+    '%(t)s [%(p)-8s] GNCRN %(h)-15s rqt:%(L)s %(s)s %(b)-6s "%(m)s:%(U)s %(q)s" usr:%(u)s "%(f)s" "%(a)s"')
+
+# self adjust workers based on CPU count
+# workers = multiprocessing.cpu_count() * 2 + 1
+
+
+def post_fork(server, worker):
+    server.log.info("[<%-10s>] WORKER spawned", worker.pid)
+
+
+def pre_fork(server, worker):
+    pass
+
+
+def pre_exec(server):
+    server.log.info("Forked child, re-executing.")
+
+
+def on_starting(server):
+    server.log.info("Server is starting.")
+
+
+def when_ready(server):
+    server.log.info("Server is ready. Spawning workers")
+
+
+def on_reload(server):
+    pass
+
+
+def worker_int(worker):
+    worker.log.info("[<%-10s>] worker received INT or QUIT signal", worker.pid)
+
+    # get traceback info, on worker crash
+    id2name = dict([(th.ident, th.name) for th in threading.enumerate()])
+    code = []
+    for thread_id, stack in sys._current_frames().items():
+        code.append(
+            "\n# Thread: %s(%d)" % (id2name.get(thread_id, ""), thread_id))
+        for fname, lineno, name, line in traceback.extract_stack(stack):
+            code.append('File: "%s", line %d, in %s' % (fname, lineno, name))
+            if line:
+                code.append("  %s" % (line.strip()))
+    worker.log.debug("\n".join(code))
+
+
+def worker_abort(worker):
+    worker.log.info("[<%-10s>] worker received SIGABRT signal", worker.pid)
+
+
+def worker_exit(server, worker):
+    worker.log.info("[<%-10s>] worker exit", worker.pid)
+
+
+def child_exit(server, worker):
+    worker.log.info("[<%-10s>] worker child exit", worker.pid)
+
+
+def pre_request(worker, req):
+    worker.start_time = time.time()
+    worker.log.debug(
+        "GNCRN PRE  WORKER [cnt:%s]: %s %s", worker.nr, req.method, req.path)
+
+
+def post_request(worker, req, environ, resp):
+    total_time = time.time() - worker.start_time
+    worker.log.debug(
+        "GNCRN POST WORKER [cnt:%s]: %s %s resp: %s, Load Time: %.3fs",
+        worker.nr, req.method, req.path, resp.status_code, total_time)
+
+
+class RhodeCodeLogger(Logger):
+    """
+    Custom Logger that allows some customization that gunicorn doesn't allow
+    """
+
+    datefmt = r"%Y-%m-%d %H:%M:%S"
+
+    def __init__(self, cfg):
+        Logger.__init__(self, cfg)
+
+    def now(self):
+        """ return date in RhodeCode Log format """
+        now = time.time()
+        msecs = int((now - long(now)) * 1000)
+        return time.strftime(self.datefmt, time.localtime(now)) + '.{0:03d}'.format(msecs)
+
+
+logger_class = RhodeCodeLogger

pkgs/README.rst

@@ -0,0 +1,28 b''
+
+==============================
+ Generate the Nix expressions
+==============================
+
+Details can be found in the repository of `RhodeCode Enterprise CE`_ inside of
+the file `docs/contributing/dependencies.rst`.
+
+Start the environment as follows:
+
+.. code:: shell
+
+   nix-shell pkgs/shell-generate.nix
+
+
+Python dependencies
+===================
+
+.. code:: shell
+
+   pip2nix generate --licenses
+   # or faster
+   nix-shell pkgs/shell-generate.nix --command "pip2nix generate --licenses"
+
+
+.. Links
+
+.. _RhodeCode Enterprise CE: https://code.rhodecode.com/rhodecode-enterprise-ce

pkgs/nix-common/pip2nix.nix

@@ -0,0 +1,17 b''
+{ pkgs
+, pythonPackages
+}:
+
+rec {
+  pip2nix-src = pkgs.fetchzip {
+    url = https://github.com/johbo/pip2nix/archive/51e6fdae34d0e8ded9efeef7a8601730249687a6.tar.gz;
+    sha256 = "02a4jjgi7lsvf8mhrxsd56s9a3yg20081rl9bgc2m84w60v2gbz2";
+  };
+
+  pip2nix = import pip2nix-src {
+    inherit
+      pkgs
+      pythonPackages;
+  };
+
+}

pkgs/overlays.nix

@@ -0,0 +1,45 b''
+self: super: {
+  # bump GIT version
+  git = super.lib.overrideDerivation super.git (oldAttrs: {
+    name = "git-2.17.1";
+    src = self.fetchurl {
+      url = "https://www.kernel.org/pub/software/scm/git/git-2.17.1.tar.xz";
+      sha256 = "0pm6bdnrrm165k3krnazxcxadifk2gqi30awlbcf9fism1x6w4vr";
+    };
+
+    patches = [
+      ./git_patches/docbook2texi.patch
+      ./git_patches/symlinks-in-bin.patch
+      ./git_patches/git-sh-i18n.patch
+      ./git_patches/ssh-path.patch
+    ];
+
+  });
+
+  # Override subversion derivation to
+  #  - activate python bindings
+  subversion =
+  let
+    subversionWithPython = super.subversion.override {
+      httpSupport = true;
+      pythonBindings = true;
+      python = self.python27Packages.python;
+    };
+  in
+    super.lib.overrideDerivation subversionWithPython (oldAttrs: {
+      name = "subversion-1.10.2";
+      src = self.fetchurl {
+        url = "https://archive.apache.org/dist/subversion/subversion-1.10.2.tar.gz";
+        sha256 = "0xv5z2bg0lw7057g913yc13f60nfj257wvmsq22pr33m4syf26sg";
+      };
+
+      ## use internal lz4/utf8proc because it is stable and shipped with SVN
+      configureFlags = oldAttrs.configureFlags ++ [
+        " --with-lz4=internal"
+        " --with-utf8proc=internal"
+      ];
+
+
+  });
+
+}

pkgs/shell-generate.nix

@@ -0,0 +1,41 b''
+{ pkgs ? (import <nixpkgs> {})
+, pythonPackages ? "python27Packages"
+}:
+
+with pkgs.lib;
+
+let _pythonPackages = pythonPackages; in
+let
+  pythonPackages = getAttr _pythonPackages pkgs;
+
+  pip2nix = import ./nix-common/pip2nix.nix {
+    inherit
+      pkgs
+      pythonPackages;
+  };
+
+in
+
+pkgs.stdenv.mkDerivation {
+  name = "pip2nix-generated";
+  buildInputs = [
+    pip2nix.pip2nix
+    pythonPackages.pip-tools
+    pkgs.apr
+    pkgs.aprutil
+  ];
+
+  shellHook = ''
+    runHook preShellHook
+    echo "Setting SVN_* variables"
+    export SVN_LIBRARY_PATH=${pkgs.subversion}/lib
+    export SVN_HEADER_PATH=${pkgs.subversion.dev}/include
+    runHook postShellHook
+  '';
+
+  preShellHook = ''
+    echo "Starting Generate Shell"
+    # Custom prompt to distinguish from other dev envs.
+    export PS1="\n\[\033[1;32m\][Generate-shell:\w]$\[\033[0m\] "
+  '';
+}

vcsserver/lib/__init__.py

@@ -0,0 +1,16 b''
+# RhodeCode VCSServer provides access to different vcs backends via network.
+# Copyright (C) 2014-2018 RhodeCode GmbH
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA

vcsserver/lib/exc_tracking.py

@@ -0,0 +1,146 b''
+# -*- coding: utf-8 -*-
+
+# RhodeCode VCSServer provides access to different vcs backends via network.
+# Copyright (C) 2014-2018 RhodeCode GmbH
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+
+
+import os
+import time
+import datetime
+import msgpack
+import logging
+import traceback
+import tempfile
+
+
+log = logging.getLogger(__name__)
+
+# NOTE: Any changes should be synced with exc_tracking at rhodecode.lib.exc_tracking
+global_prefix = 'vcsserver'
+
+
+def exc_serialize(exc_id, tb, exc_type):
+
+    data = {
+        'version': 'v1',
+        'exc_id': exc_id,
+        'exc_utc_date': datetime.datetime.utcnow().isoformat(),
+        'exc_timestamp': repr(time.time()),
+        'exc_message': tb,
+        'exc_type': exc_type,
+    }
+    return msgpack.packb(data), data
+
+
+def exc_unserialize(tb):
+    return msgpack.unpackb(tb)
+
+
+def get_exc_store():
+    """
+    Get and create exception store if it's not existing
+    """
+    exc_store_dir = 'rc_exception_store_v1'
+    # fallback
+    _exc_store_path = os.path.join(tempfile.gettempdir(), exc_store_dir)
+
+    exc_store_dir = ''  # TODO: need a persistent cross instance store here
+    if exc_store_dir:
+        _exc_store_path = os.path.join(exc_store_dir, exc_store_dir)
+
+    _exc_store_path = os.path.abspath(_exc_store_path)
+    if not os.path.isdir(_exc_store_path):
+        os.makedirs(_exc_store_path)
+        log.debug('Initializing exceptions store at %s', _exc_store_path)
+    return _exc_store_path
+
+
+def _store_exception(exc_id, exc_info, prefix):
+    exc_type, exc_value, exc_traceback = exc_info
+    tb = ''.join(traceback.format_exception(
+        exc_type, exc_value, exc_traceback, None))
+
+    exc_type_name = exc_type.__name__
+    exc_store_path = get_exc_store()
+    exc_data, org_data = exc_serialize(exc_id, tb, exc_type_name)
+    exc_pref_id = '{}_{}_{}'.format(exc_id, prefix, org_data['exc_timestamp'])
+    if not os.path.isdir(exc_store_path):
+        os.makedirs(exc_store_path)
+    stored_exc_path = os.path.join(exc_store_path, exc_pref_id)
+    with open(stored_exc_path, 'wb') as f:
+        f.write(exc_data)
+    log.debug('Stored generated exception %s as: %s', exc_id, stored_exc_path)
+
+
+def store_exception(exc_id, exc_info, prefix=global_prefix):
+    try:
+        _store_exception(exc_id=exc_id, exc_info=exc_info, prefix=prefix)
+    except Exception:
+        log.exception('Failed to store exception `%s` information', exc_id)
+        # there's no way this can fail, it will crash server badly if it does.
+        pass
+
+
+def _find_exc_file(exc_id, prefix=global_prefix):
+    exc_store_path = get_exc_store()
+    if prefix:
+        exc_id = '{}_{}'.format(exc_id, prefix)
+    else:
+        # search without a prefix
+        exc_id = '{}'.format(exc_id)
+
+    # we need to search the store for such start pattern as above
+    for fname in os.listdir(exc_store_path):
+        if fname.startswith(exc_id):
+            exc_id = os.path.join(exc_store_path, fname)
+            break
+        continue
+    else:
+        exc_id = None
+
+    return exc_id
+
+
+def _read_exception(exc_id, prefix):
+    exc_id_file_path = _find_exc_file(exc_id=exc_id, prefix=prefix)
+    if exc_id_file_path:
+        with open(exc_id_file_path, 'rb') as f:
+            return exc_unserialize(f.read())
+    else:
+        log.debug('Exception File `%s` not found', exc_id_file_path)
+    return None
+
+
+def read_exception(exc_id, prefix=global_prefix):
+    try:
+        return _read_exception(exc_id=exc_id, prefix=prefix)
+    except Exception:
+        log.exception('Failed to read exception `%s` information', exc_id)
+        # there's no way this can fail, it will crash server badly if it does.
+    return None
+
+
+def delete_exception(exc_id, prefix=global_prefix):
+    try:
+        exc_id_file_path = _find_exc_file(exc_id, prefix=prefix)
+        if exc_id_file_path:
+            os.remove(exc_id_file_path)
+
+    except Exception:
+        log.exception('Failed to remove exception `%s` information', exc_id)
+        # there's no way this can fail, it will crash server badly if it does.
+        pass

vcsserver/lib/memory_lru_dict.py

@@ -0,0 +1,65 b''
+# -*- coding: utf-8 -*-
+
+# RhodeCode VCSServer provides access to different vcs backends via network.
+# Copyright (C) 2014-2018 RhodeCode GmbH
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+
+
+import logging
+
+from repoze.lru import LRUCache
+
+from vcsserver.utils import safe_str
+
+log = logging.getLogger(__name__)
+
+
+class LRUDict(LRUCache):
+    """
+    Wrapper to provide partial dict access
+    """
+
+    def __setitem__(self, key, value):
+        return self.put(key, value)
+
+    def __getitem__(self, key):
+        return self.get(key)
+
+    def __contains__(self, key):
+        return bool(self.get(key))
+
+    def __delitem__(self, key):
+        del self.data[key]
+
+    def keys(self):
+        return self.data.keys()
+
+
+class LRUDictDebug(LRUDict):
+    """
+    Wrapper to provide some debug options
+    """
+    def _report_keys(self):
+        elems_cnt = '%s/%s' % (len(self.keys()), self.size)
+        # trick for pformat print it more nicely
+        fmt = '\n'
+        for cnt, elem in enumerate(self.keys()):
+            fmt += '%s - %s\n' % (cnt+1, safe_str(elem))
+        log.debug('current LRU keys (%s):%s' % (elems_cnt, fmt))
+
+    def __getitem__(self, key):
+        self._report_keys()
+        return self.get(key)

vcsserver/lib/rc_cache/__init__.py

@@ -0,0 +1,60 b''
+# RhodeCode VCSServer provides access to different vcs backends via network.
+# Copyright (C) 2014-2018 RhodeCode GmbH
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+
+import logging
+from dogpile.cache import register_backend
+
+register_backend(
+    "dogpile.cache.rc.memory_lru", "vcsserver.lib.rc_cache.backends",
+    "LRUMemoryBackend")
+
+log = logging.getLogger(__name__)
+
+from . import region_meta
+from .util import key_generator, get_default_cache_settings, make_region
+
+
+def configure_dogpile_cache(settings):
+    cache_dir = settings.get('cache_dir')
+    if cache_dir:
+        region_meta.dogpile_config_defaults['cache_dir'] = cache_dir
+
+    rc_cache_data = get_default_cache_settings(settings, prefixes=['rc_cache.'])
+
+    # inspect available namespaces
+    avail_regions = set()
+    for key in rc_cache_data.keys():
+        namespace_name = key.split('.', 1)[0]
+        avail_regions.add(namespace_name)
+    log.debug('dogpile: found following cache regions: %s', avail_regions)
+
+    # register them into namespace
+    for region_name in avail_regions:
+        new_region = make_region(
+            name=region_name,
+            function_key_generator=key_generator
+        )
+
+        new_region.configure_from_config(settings, 'rc_cache.{}.'.format(region_name))
+
+        log.debug('dogpile: registering a new region %s[%s]',
+                  region_name, new_region.__dict__)
+        region_meta.dogpile_cache_regions[region_name] = new_region
+
+
+def includeme(config):
+    configure_dogpile_cache(config.registry.settings)

vcsserver/lib/rc_cache/backends.py

@@ -0,0 +1,51 b''
+# RhodeCode VCSServer provides access to different vcs backends via network.
+# Copyright (C) 2014-2018 RhodeCode GmbH
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+
+import logging
+
+from dogpile.cache.backends import memory as memory_backend
+from vcsserver.lib.memory_lru_dict import LRUDict, LRUDictDebug
+
+
+_default_max_size = 1024
+
+log = logging.getLogger(__name__)
+
+
+class LRUMemoryBackend(memory_backend.MemoryBackend):
+    pickle_values = False
+
+    def __init__(self, arguments):
+        max_size = arguments.pop('max_size', _default_max_size)
+
+        LRUDictClass = LRUDict
+        if arguments.pop('log_key_count', None):
+            LRUDictClass = LRUDictDebug
+
+        arguments['cache_dict'] = LRUDictClass(max_size)
+        super(LRUMemoryBackend, self).__init__(arguments)
+
+    def delete(self, key):
+        try:
+            del self._cache[key]
+        except KeyError:
+            # we don't care if key isn't there at deletion
+            pass
+
+    def delete_multi(self, keys):
+        for key in keys:
+            self.delete(key)

vcsserver/lib/rc_cache/region_meta.py

@@ -0,0 +1,26 b''
+# RhodeCode VCSServer provides access to different vcs backends via network.
+# Copyright (C) 2014-2018 RhodeCode GmbH
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+
+import os
+import tempfile
+
+dogpile_config_defaults = {
+    'cache_dir': os.path.join(tempfile.gettempdir(), 'rc_cache')
+}
+
+# GLOBAL TO STORE ALL REGISTERED REGIONS
+dogpile_cache_regions = {}

vcsserver/lib/rc_cache/util.py

@@ -0,0 +1,136 b''
+# RhodeCode VCSServer provides access to different vcs backends via network.
+# Copyright (C) 2014-2018 RhodeCode GmbH
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+
+import os
+import logging
+import functools
+
+from vcsserver.utils import safe_str, sha1
+from dogpile.cache import CacheRegion
+from dogpile.cache.util import compat
+
+log = logging.getLogger(__name__)
+
+
+class RhodeCodeCacheRegion(CacheRegion):
+
+    def conditional_cache_on_arguments(
+            self, namespace=None,
+            expiration_time=None,
+            should_cache_fn=None,
+            to_str=compat.string_type,
+            function_key_generator=None,
+            condition=True):
+        """
+        Custom conditional decorator, that will not touch any dogpile internals if
+        condition isn't meet. This works a bit different than should_cache_fn
+        And it's faster in cases we don't ever want to compute cached values
+        """
+        expiration_time_is_callable = compat.callable(expiration_time)
+
+        if function_key_generator is None:
+            function_key_generator = self.function_key_generator
+
+        def decorator(fn):
+            if to_str is compat.string_type:
+                # backwards compatible
+                key_generator = function_key_generator(namespace, fn)
+            else:
+                key_generator = function_key_generator(namespace, fn, to_str=to_str)
+
+            @functools.wraps(fn)
+            def decorate(*arg, **kw):
+                key = key_generator(*arg, **kw)
+
+                @functools.wraps(fn)
+                def creator():
+                    return fn(*arg, **kw)
+
+                if not condition:
+                    return creator()
+
+                timeout = expiration_time() if expiration_time_is_callable \
+                    else expiration_time
+
+                return self.get_or_create(key, creator, timeout, should_cache_fn)
+
+            def invalidate(*arg, **kw):
+                key = key_generator(*arg, **kw)
+                self.delete(key)
+
+            def set_(value, *arg, **kw):
+                key = key_generator(*arg, **kw)
+                self.set(key, value)
+
+            def get(*arg, **kw):
+                key = key_generator(*arg, **kw)
+                return self.get(key)
+
+            def refresh(*arg, **kw):
+                key = key_generator(*arg, **kw)
+                value = fn(*arg, **kw)
+                self.set(key, value)
+                return value
+
+            decorate.set = set_
+            decorate.invalidate = invalidate
+            decorate.refresh = refresh
+            decorate.get = get
+            decorate.original = fn
+            decorate.key_generator = key_generator
+
+            return decorate
+
+        return decorator
+
+
+def make_region(*arg, **kw):
+    return RhodeCodeCacheRegion(*arg, **kw)
+
+
+def get_default_cache_settings(settings, prefixes=None):
+    prefixes = prefixes or []
+    cache_settings = {}
+    for key in settings.keys():
+        for prefix in prefixes:
+            if key.startswith(prefix):
+                name = key.split(prefix)[1].strip()
+                val = settings[key]
+                if isinstance(val, basestring):
+                    val = val.strip()
+                cache_settings[name] = val
+    return cache_settings
+
+
+def compute_key_from_params(*args):
+    """
+    Helper to compute key from given params to be used in cache manager
+    """
+    return sha1("_".join(map(safe_str, args)))
+
+
+def key_generator(namespace, fn):
+    fname = fn.__name__
+
+    def generate_key(*args):
+        namespace_pref = namespace or 'default'
+        arg_key = compute_key_from_params(*args)
+        final_key = "{}:{}_{}".format(namespace_pref, fname, arg_key)
+
+        return final_key
+
+    return generate_key

.bumpversion.cfg

@@ -1,6 +1,6 b''
 [bumpversion]
-current_version = 4.12.4
+current_version = 4.13.0
 message = release: Bump version {current_version} to {new_version}
 
 [bumpversion:file:vcsserver/VERSION]
 

.release.cfg

@@ -1,16 +1,14 b''
 [DEFAULT]
 done = false
 
 [task:bump_version]
 done = true
 
 [task:fixes_on_stable]
-done = true
 
 [task:pip2nix_generated]
-done = true
 
 [release]
-state = prepared
-version = 4.12.4
+state = in_progress
+version = 4.13.0
 

Makefile

@@ -1,18 +1,18 b''
 
 .PHONY: clean test test-clean test-only
 
 
 clean:
 	make test-clean
 	find . -type f \( -iname '*.c' -o -iname '*.pyc' -o -iname '*.so' \) -exec rm '{}' ';'
 
 test:
 	make test-clean
 	make test-only
 
 test-clean:
 	rm -rf coverage.xml htmlcov junit.xml pylint.log result
 	find . -type d -name "__pycache__" -prune -exec rm -rf '{}' ';'
 
 test-only:
-	PYTHONHASHSEED=random py.test -vv -r xw --cov=vcsserver --cov-report=term-missing --cov-report=html vcsserver
+	PYTHONHASHSEED=random py.test -vv -r xw -p no:sugar --cov=vcsserver --cov-report=term-missing --cov-report=html vcsserver

configs/development.ini

@@ -1,1 +1,79 b''
-development_http.ini
  No newline at end of file
+################################################################################
+# RhodeCode VCSServer with HTTP Backend - configuration                        #
+#                                                                              #
+################################################################################
+
+
+[server:main]
+## COMMON ##
+host = 0.0.0.0
+port = 9900
+
+use = egg:waitress#main
+
+
+[app:main]
+use = egg:rhodecode-vcsserver
+
+pyramid.default_locale_name = en
+pyramid.includes =
+
+## default locale used by VCS systems
+locale = en_US.UTF-8
+
+
+## path to binaries for vcsserver, it should be set by the installer
+## at installation time, e.g /home/user/vcsserver-1/profile/bin
+core.binary_dir = ""
+
+## cache region for storing repo_objects cache
+rc_cache.repo_object.backend = dogpile.cache.rc.memory_lru
+## cache auto-expires after N seconds
+rc_cache.repo_object.expiration_time = 300
+## max size of LRU, old values will be discarded if the size of cache reaches max_size
+rc_cache.repo_object.max_size = 100
+
+
+################################
+### LOGGING CONFIGURATION   ####
+################################
+[loggers]
+keys = root, vcsserver
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+#############
+## LOGGERS ##
+#############
+[logger_root]
+level = NOTSET
+handlers = console
+
+[logger_vcsserver]
+level = DEBUG
+handlers =
+qualname = vcsserver
+propagate = 1
+
+
+##############
+## HANDLERS ##
+##############
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = DEBUG
+formatter = generic
+
+################
+## FORMATTERS ##
+################
+
+[formatter_generic]
+format = %(asctime)s.%(msecs)03d [%(process)d] %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %Y-%m-%d %H:%M:%S

configs/production.ini

@@ -1,1 +1,100 b''
-production_http.ini
  No newline at end of file
+################################################################################
+# RhodeCode VCSServer with HTTP Backend - configuration                        #
+#                                                                              #
+################################################################################
+
+
+[server:main]
+## COMMON ##
+host = 127.0.0.1
+port = 9900
+
+
+##########################
+## GUNICORN WSGI SERVER ##
+##########################
+## run with gunicorn --log-config vcsserver.ini --paste vcsserver.ini
+use = egg:gunicorn#main
+## Sets the number of process workers. Recommended
+## value is (2 * NUMBER_OF_CPUS + 1), eg 2CPU = 5 workers
+workers = 2
+## process name
+proc_name = rhodecode_vcsserver
+## type of worker class, currently `sync` is the only option allowed.
+worker_class = sync
+## The maximum number of simultaneous clients. Valid only for Gevent
+#worker_connections = 10
+## max number of requests that worker will handle before being gracefully
+## restarted, could prevent memory leaks
+max_requests = 1000
+max_requests_jitter = 30
+## amount of time a worker can spend with handling a request before it
+## gets killed and restarted. Set to 6hrs
+timeout = 21600
+
+
+[app:main]
+use = egg:rhodecode-vcsserver
+
+pyramid.default_locale_name = en
+pyramid.includes =
+
+## default locale used by VCS systems
+locale = en_US.UTF-8
+
+
+## path to binaries for vcsserver, it should be set by the installer
+## at installation time, e.g /home/user/vcsserver-1/profile/bin
+core.binary_dir = ""
+
+## cache region for storing repo_objects cache
+rc_cache.repo_object.backend = dogpile.cache.rc.memory_lru
+## cache auto-expires after N seconds
+rc_cache.repo_object.expiration_time = 300
+## max size of LRU, old values will be discarded if the size of cache reaches max_size
+rc_cache.repo_object.max_size = 100
+
+
+################################
+### LOGGING CONFIGURATION   ####
+################################
+[loggers]
+keys = root, vcsserver
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+#############
+## LOGGERS ##
+#############
+[logger_root]
+level = NOTSET
+handlers = console
+
+[logger_vcsserver]
+level = DEBUG
+handlers =
+qualname = vcsserver
+propagate = 1
+
+
+##############
+## HANDLERS ##
+##############
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = DEBUG
+formatter = generic
+
+################
+## FORMATTERS ##
+################
+
+[formatter_generic]
+format = %(asctime)s.%(msecs)03d [%(process)d] %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %Y-%m-%d %H:%M:%S

default.nix

@@ -1,166 +1,178 b''
 # Nix environment for the community edition
 #
 # This shall be as lean as possible, just producing the rhodecode-vcsserver
 # derivation. For advanced tweaks to pimp up the development environment we use
 # "shell.nix" so that it does not have to clutter this file.
 
-{ pkgs ? (import <nixpkgs> {})
-, pythonPackages ? "python27Packages"
+args@
+{ pythonPackages ? "python27Packages"
 , pythonExternalOverrides ? self: super: {}
-, doCheck ? true
+, doCheck ? false
+, ...
 }:
 
-let pkgs_ = pkgs; in
+let pkgs_ = (import <nixpkgs> {}); in
 
 let
-  pkgs = pkgs_.overridePackages (self: super: {
-    # bump GIT version
-    git = pkgs.lib.overrideDerivation pkgs_.git (oldAttrs: {
-      name = "git-2.16.4";
-      src = pkgs.fetchurl {
-        url = "https://www.kernel.org/pub/software/scm/git/git-2.16.4.tar.xz";
-        sha256 = "0cnmidjvbdf81mybcvxvl0c2r2x2nvq2jj2dl59dmrc7qklv0sbf";
-      };
-
-      patches = [
-        ./pkgs/git_patches/docbook2texi.patch
-        ./pkgs/git_patches/symlinks-in-bin.patch
-        ./pkgs/git_patches/git-sh-i18n.patch
-        ./pkgs/git_patches/ssh-path.patch
-      ];
-
-    });
 
-    # Override subversion derivation to
-    #  - activate python bindings
-    subversion = let
-      subversionWithPython = super.subversion.override {
-        httpSupport = true;
-        pythonBindings = true;
-        python = self.python27Packages.python;
-      };
-
-    in
+  # TODO: Currently we ignore the passed in pkgs, instead we should use it
+  # somehow as a base and apply overlays to it.
+  pkgs = import <nixpkgs> {
+    overlays = [
+      (import ./pkgs/overlays.nix)
+    ];
+    inherit (pkgs_)
+      system;
+  };
 
-    pkgs.lib.overrideDerivation subversionWithPython (oldAttrs: {
-      name = "subversion-1.9.7";
-      src = pkgs.fetchurl {
-        url = "https://www.apache.org/dist/subversion/subversion-1.9.7.tar.gz";
-        sha256 = "0g3cs2h008z8ymgkhbk54jp87bjh7y049rn42igj881yi2f20an7";
-      };
-
-    });
-
-  });
+  # Works with the new python-packages, still can fallback to the old
+  # variant.
+  basePythonPackagesUnfix = basePythonPackages.__unfix__ or (
+    self: basePythonPackages.override (a: { inherit self; }));
 
-  inherit (pkgs.lib) fix extends;
-  basePythonPackages = with builtins; if isAttrs pythonPackages
-    then pythonPackages
-    else getAttr pythonPackages pkgs;
+  # Evaluates to the last segment of a file system path.
+  basename = path: with pkgs.lib; last (splitString "/" path);
 
-  elem = builtins.elem;
-  basename = path: with pkgs.lib; last (splitString "/" path);
-  startsWith = prefix: full: let
-    actualPrefix = builtins.substring 0 (builtins.stringLength prefix) full;
-  in actualPrefix == prefix;
-
+  # source code filter used as arugment to builtins.filterSource.
   src-filter = path: type: with pkgs.lib;
     let
       ext = last (splitString "." path);
     in
-      !elem (basename path) [".hg" ".git" "__pycache__" ".eggs"
-        "node_modules" "build" "data" "tmp"] &&
-      !elem ext ["egg-info" "pyc"] &&
-      !startsWith "result" path;
+      !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-vcsserver-src}/vcsserver/VERSION";
   rhodecode-vcsserver-src = builtins.filterSource src-filter ./.;
 
-  pythonGeneratedPackages = self: basePythonPackages.override (a: {
-    inherit self;
-  }) // (scopedImport {
-    self = self;
-    super = basePythonPackages;
-    inherit pkgs;
-    inherit (pkgs) fetchurl fetchgit;
-  } ./pkgs/python-packages.nix);
-
-  pythonOverrides = import ./pkgs/python-packages-overrides.nix {
-    inherit basePythonPackages pkgs;
-  };
-
-  version = builtins.readFile ./vcsserver/VERSION;
-
   pythonLocalOverrides = self: super: {
-    rhodecode-vcsserver = super.rhodecode-vcsserver.override (attrs: {
-      inherit doCheck version;
+    rhodecode-vcsserver =
+      let
+        releaseName = "RhodeCodeVCSServer-${version}";
+      in super.rhodecode-vcsserver.override (attrs: {
+      inherit
+        doCheck
+        version;
 
       name = "rhodecode-vcsserver-${version}";
-      releaseName = "RhodeCodeVCSServer-${version}";
+      releaseName = releaseName;
       src = rhodecode-vcsserver-src;
       dontStrip = true; # prevent strip, we don't need it.
 
-      propagatedBuildInputs = attrs.propagatedBuildInputs ++ ([
-        pkgs.git
-        pkgs.subversion
-      ]);
-
-      # TODO: johbo: Make a nicer way to expose the parts. Maybe
-      # pkgs/default.nix?
+      # expose following attributed outside
       passthru = {
         pythonPackages = self;
       };
 
-      # Add VCSServer bin directory to path so that tests can find 'vcsserver'.
+      propagatedBuildInputs =
+        attrs.propagatedBuildInputs or [] ++ [
+        pkgs.git
+        pkgs.subversion
+      ];
+
+      # set some default locale env variables
+      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 'vcsserver'.
       preCheck = ''
         export PATH="$out/bin:$PATH"
       '';
 
-      # put custom attrs here
+      # custom check phase for testing
       checkPhase = ''
         runHook preCheck
-        PYTHONHASHSEED=random py.test -p no:sugar -vv --cov-config=.coveragerc --cov=vcsserver --cov-report=term-missing vcsserver
+        PYTHONHASHSEED=random py.test -vv -p no:sugar -r xw --cov-config=.coveragerc --cov=vcsserver --cov-report=term-missing vcsserver
         runHook postCheck
       '';
 
+      postCheck = ''
+        echo "Cleanup of vcsserver/tests"
+        rm -rf $out/lib/${self.python.libPrefix}/site-packages/vcsserver/tests
+      '';
+
       postInstall = ''
-        echo "Writing meta information for rccontrol to nix-support/rccontrol"
+        echo "Writing vcsserver meta information for rccontrol to nix-support/rccontrol"
         mkdir -p $out/nix-support/rccontrol
         cp -v vcsserver/VERSION $out/nix-support/rccontrol/version
-        echo "DONE: Meta information for rccontrol written"
+        echo "DONE: vcsserver meta information for rccontrol written"
+
+        mkdir -p $out/etc
+        cp configs/production.ini $out/etc
+        echo "DONE: saved vcsserver production.ini into $out/etc"
 
         # python based programs need to be wrapped
+        mkdir -p $out/bin
+        ln -s ${self.python}/bin/python $out/bin
         ln -s ${self.pyramid}/bin/* $out/bin/
         ln -s ${self.gunicorn}/bin/gunicorn $out/bin/
 
         # Symlink version control utilities
-        #
         # We ensure that always the correct version is available as a symlink.
         # So that users calling them via the profile path will always use the
         # correct version.
-        ln -s ${self.python}/bin/python $out/bin
+
         ln -s ${pkgs.git}/bin/git $out/bin
         ln -s ${self.mercurial}/bin/hg $out/bin
         ln -s ${pkgs.subversion}/bin/svn* $out/bin
+        echo "DONE: created symlinks into $out/bin"
 
         for file in $out/bin/*;
         do
           wrapProgram $file \
-            --set PATH $PATH \
-            --set PYTHONPATH $PYTHONPATH \
+            --prefix PATH : $PATH \
+            --prefix PYTHONPATH : $PYTHONPATH \
             --set PYTHONHASHSEED random
         done
+        echo "DONE: vcsserver binary wrapping"
 
       '';
 
     });
   };
 
+  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;
+  };
+
+  pythonVCSServerOverrides = import ./pkgs/python-packages-overrides.nix {
+    inherit pkgs basePythonPackages;
+  };
+
+
   # Apply all overrides and fix the final package set
-  myPythonPackages =
-    (fix
+  myPythonPackagesUnfix = with pkgs.lib;
     (extends pythonExternalOverrides
     (extends pythonLocalOverrides
-    (extends pythonOverrides
-             pythonGeneratedPackages))));
+    (extends pythonVCSServerOverrides
+    (extends pythonGeneratedPackages
+             basePythonPackagesUnfix))));
+
+  myPythonPackages = (pkgs.lib.fix myPythonPackagesUnfix);
 
 in myPythonPackages.rhodecode-vcsserver

pkgs/python-packages-overrides.nix

@@ -1,60 +1,53 b''
 # Overrides for the generated python-packages.nix
 #
 # This function is intended to be used as an extension to the generated file
 # python-packages.nix. The main objective is to add needed dependencies of C
 # libraries and tweak the build instructions where needed.
 
-{ pkgs, basePythonPackages }:
+{ pkgs
+, basePythonPackages
+}:
 
 let
   sed = "sed -i";
+
 in
 
 self: super: {
 
-  Beaker = super.Beaker.override (attrs: {
-    patches = [
-      ./patch-beaker-lock-func-debug.diff
+  "gevent" = super."gevent".override (attrs: {
+    propagatedBuildInputs = attrs.propagatedBuildInputs ++ [
+      # NOTE: (marcink) odd requirements from gevent aren't set properly,
+      # thus we need to inject psutil manually
+      self."psutil"
     ];
   });
 
-  subvertpy = super.subvertpy.override (attrs: {
-    # TODO: johbo: Remove the "or" once we drop 16.03 support
-    SVN_PREFIX = "${pkgs.subversion.dev or pkgs.subversion}";
+  "hgsubversion" = super."hgsubversion".override (attrs: {
     propagatedBuildInputs = attrs.propagatedBuildInputs ++ [
+      pkgs.sqlite
+      #basePythonPackages.sqlite3
+      self.mercurial
+    ];
+  });
+
+  "subvertpy" = super."subvertpy".override (attrs: {
+    SVN_PREFIX = "${pkgs.subversion.dev}";
+    propagatedBuildInputs = [
+      pkgs.apr.dev
       pkgs.aprutil
       pkgs.subversion
     ];
-    preBuild = pkgs.lib.optionalString pkgs.stdenv.isDarwin ''
-      ${sed} -e "s/'gcc'/'clang'/" setup.py
-    '';
   });
 
-  hgsubversion = super.hgsubversion.override (attrs: {
-    propagatedBuildInputs = attrs.propagatedBuildInputs ++ [
-      pkgs.sqlite
-      basePythonPackages.sqlite3
+  "mercurial" = super."mercurial".override (attrs: {
+    propagatedBuildInputs = [
+      # self.python.modules.curses
     ];
   });
 
-  mercurial = super.mercurial.override (attrs: {
-    propagatedBuildInputs = attrs.propagatedBuildInputs ++ [
-      self.python.modules.curses
-    ] ++ pkgs.lib.optional pkgs.stdenv.isDarwin
-      pkgs.darwin.apple_sdk.frameworks.ApplicationServices;
-  });
-
-  pyramid = super.pyramid.override (attrs: {
-    postFixup = ''
-      wrapPythonPrograms
-      # TODO: johbo: "wrapPython" adds this magic line which
-      # confuses pserve.
-      ${sed} '/import sys; sys.argv/d' $out/bin/.pserve-wrapped
-    '';
-  });
-
-  # Avoid that setuptools is replaced, this leads to trouble
-  # with buildPythonPackage.
-  setuptools = basePythonPackages.setuptools;
+  # Avoid that base packages screw up the build process
+  inherit (basePythonPackages)
+    setuptools;
 
 }

pkgs/python-packages.nix

@@ -1,877 +1,947 b''
-# Generated by pip2nix 0.4.0
+# Generated by pip2nix 0.8.0.dev1
 # See https://github.com/johbo/pip2nix
 
-{
-  Beaker = super.buildPythonPackage {
-    name = "Beaker-1.9.1";
-    buildInputs = with self; [];
-    doCheck = false;
-    propagatedBuildInputs = with self; [funcsigs];
-    src = fetchurl {
-      url = "https://pypi.python.org/packages/ca/14/a626188d0d0c7b55dd7cf1902046c2743bd392a7078bb53073e13280eb1e/Beaker-1.9.1.tar.gz";
-      md5 = "46fda0a164e2b0d24ccbda51a2310301";
-    };
-    meta = {
-      license = [ pkgs.lib.licenses.bsdOriginal ];
-    };
-  };
-  Jinja2 = super.buildPythonPackage {
-    name = "Jinja2-2.9.6";
-    buildInputs = with self; [];
+{ pkgs, fetchurl, fetchgit, fetchhg }:
+
+self: super: {
+  "atomicwrites" = super.buildPythonPackage {
+    name = "atomicwrites-1.1.5";
     doCheck = false;
-    propagatedBuildInputs = with self; [MarkupSafe];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/90/61/f820ff0076a2599dd39406dcb858ecb239438c02ce706c8e91131ab9c7f1/Jinja2-2.9.6.tar.gz";
-      md5 = "6411537324b4dba0956aaa8109f3c77b";
-    };
-    meta = {
-      license = [ pkgs.lib.licenses.bsdOriginal ];
-    };
-  };
-  Mako = super.buildPythonPackage {
-    name = "Mako-1.0.7";
-    buildInputs = with self; [];
-    doCheck = false;
-    propagatedBuildInputs = with self; [MarkupSafe];
-    src = fetchurl {
-      url = "https://pypi.python.org/packages/eb/f3/67579bb486517c0d49547f9697e36582cd19dafb5df9e687ed8e22de57fa/Mako-1.0.7.tar.gz";
-      md5 = "5836cc997b1b773ef389bf6629c30e65";
+      url = "https://files.pythonhosted.org/packages/a1/e1/2d9bc76838e6e6667fde5814aa25d7feb93d6fa471bf6816daac2596e8b2/atomicwrites-1.1.5.tar.gz";
+      sha256 = "11bm90fwm2avvf4f3ib8g925w7jr4m11vcsinn1bi6ns4bm32214";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
-  MarkupSafe = super.buildPythonPackage {
-    name = "MarkupSafe-1.0";
-    buildInputs = with self; [];
+  "attrs" = super.buildPythonPackage {
+    name = "attrs-18.1.0";
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/4d/de/32d741db316d8fdb7680822dd37001ef7a448255de9699ab4bfcbdf4172b/MarkupSafe-1.0.tar.gz";
-      md5 = "2fcedc9284d50e577b5192e8e3578355";
-    };
-    meta = {
-      license = [ pkgs.lib.licenses.bsdOriginal ];
-    };
-  };
-  PasteDeploy = super.buildPythonPackage {
-    name = "PasteDeploy-1.5.2";
-    buildInputs = with self; [];
-    doCheck = false;
-    propagatedBuildInputs = with self; [];
-    src = fetchurl {
-      url = "https://pypi.python.org/packages/0f/90/8e20cdae206c543ea10793cbf4136eb9a8b3f417e04e40a29d72d9922cbd/PasteDeploy-1.5.2.tar.gz";
-      md5 = "352b7205c78c8de4987578d19431af3b";
+      url = "https://files.pythonhosted.org/packages/e4/ac/a04671e118b57bee87dabca1e0f2d3bda816b7a551036012d0ca24190e71/attrs-18.1.0.tar.gz";
+      sha256 = "0yzqz8wv3w1srav5683a55v49i0szkm47dyrnkd56fqs8j8ypl70";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
-  WebOb = super.buildPythonPackage {
-    name = "WebOb-1.7.4";
-    buildInputs = with self; [];
+  "backports.shutil-get-terminal-size" = super.buildPythonPackage {
+    name = "backports.shutil-get-terminal-size-1.0.0";
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/75/34/731e23f52371852dfe7490a61644826ba7fe70fd52a377aaca0f4956ba7f/WebOb-1.7.4.tar.gz";
-      md5 = "397e46892d7f199b1a07eb20a2d3d9bd";
+      url = "https://files.pythonhosted.org/packages/ec/9c/368086faa9c016efce5da3e0e13ba392c9db79e3ab740b763fe28620b18b/backports.shutil_get_terminal_size-1.0.0.tar.gz";
+      sha256 = "107cmn7g3jnbkp826zlj8rrj19fam301qvaqf0f3905f5217lgki";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
-  WebTest = super.buildPythonPackage {
-    name = "WebTest-2.0.29";
-    buildInputs = with self; [];
+  "beautifulsoup4" = super.buildPythonPackage {
+    name = "beautifulsoup4-4.6.3";
     doCheck = false;
-    propagatedBuildInputs = with self; [six WebOb waitress beautifulsoup4];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/94/de/8f94738be649997da99c47b104aa3c3984ecec51a1d8153ed09638253d56/WebTest-2.0.29.tar.gz";
-      md5 = "30b4cf0d340b9a5335fac4389e6f84fc";
+      url = "https://files.pythonhosted.org/packages/88/df/86bffad6309f74f3ff85ea69344a078fc30003270c8df6894fca7a3c72ff/beautifulsoup4-4.6.3.tar.gz";
+      sha256 = "041dhalzjciw6qyzzq7a2k4h1yvyk76xigp35hv5ibnn448ydy4h";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
-  backports.shutil-get-terminal-size = super.buildPythonPackage {
-    name = "backports.shutil-get-terminal-size-1.0.0";
-    buildInputs = with self; [];
-    doCheck = false;
-    propagatedBuildInputs = with self; [];
-    src = fetchurl {
-      url = "https://pypi.python.org/packages/ec/9c/368086faa9c016efce5da3e0e13ba392c9db79e3ab740b763fe28620b18b/backports.shutil_get_terminal_size-1.0.0.tar.gz";
-      md5 = "03267762480bd86b50580dc19dff3c66";
-    };
-    meta = {
-      license = [ pkgs.lib.licenses.mit ];
-    };
-  };
-  beautifulsoup4 = super.buildPythonPackage {
-    name = "beautifulsoup4-4.6.0";
-    buildInputs = with self; [];
+  "configobj" = super.buildPythonPackage {
+    name = "configobj-5.0.6";
     doCheck = false;
-    propagatedBuildInputs = with self; [];
+    propagatedBuildInputs = [
+      self."six"
+    ];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/fa/8d/1d14391fdaed5abada4e0f63543fef49b8331a34ca60c88bd521bcf7f782/beautifulsoup4-4.6.0.tar.gz";
-      md5 = "c17714d0f91a23b708a592cb3c697728";
-    };
-    meta = {
-      license = [ pkgs.lib.licenses.mit ];
-    };
-  };
-  configobj = super.buildPythonPackage {
-    name = "configobj-5.0.6";
-    buildInputs = with self; [];
-    doCheck = false;
-    propagatedBuildInputs = with self; [six];
-    src = fetchurl {
-      url = "https://pypi.python.org/packages/64/61/079eb60459c44929e684fa7d9e2fdca403f67d64dd9dbac27296be2e0fab/configobj-5.0.6.tar.gz";
-      md5 = "e472a3a1c2a67bb0ec9b5d54c13a47d6";
+      url = "https://code.rhodecode.com/upstream/configobj/archive/a11ff0a0bd4fbda9e3a91267e720f88329efb4a6.tar.gz?md5=9916c524ea11a6c418217af6b28d4b3c";
+      sha256 = "1hhcxirwvg58grlfr177b3awhbq8hlx1l3lh69ifl1ki7lfd1s1x";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
-  cov-core = super.buildPythonPackage {
+  "cov-core" = super.buildPythonPackage {
     name = "cov-core-1.15.0";
-    buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [coverage];
+    propagatedBuildInputs = [
+      self."coverage"
+    ];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/4b/87/13e75a47b4ba1be06f29f6d807ca99638bedc6b57fa491cd3de891ca2923/cov-core-1.15.0.tar.gz";
-      md5 = "f519d4cb4c4e52856afb14af52919fe6";
+      url = "https://files.pythonhosted.org/packages/4b/87/13e75a47b4ba1be06f29f6d807ca99638bedc6b57fa491cd3de891ca2923/cov-core-1.15.0.tar.gz";
+      sha256 = "0k3np9ymh06yv1ib96sb6wfsxjkqhmik8qfsn119vnhga9ywc52a";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
-  coverage = super.buildPythonPackage {
+  "coverage" = super.buildPythonPackage {
     name = "coverage-3.7.1";
-    buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/09/4f/89b06c7fdc09687bca507dc411c342556ef9c5a3b26756137a4878ff19bf/coverage-3.7.1.tar.gz";
-      md5 = "c47b36ceb17eaff3ecfab3bcd347d0df";
+      url = "https://files.pythonhosted.org/packages/09/4f/89b06c7fdc09687bca507dc411c342556ef9c5a3b26756137a4878ff19bf/coverage-3.7.1.tar.gz";
+      sha256 = "0knlbq79g2ww6xzsyknj9rirrgrgc983dpa2d9nkdf31mb2a3bni";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
-  decorator = super.buildPythonPackage {
+  "decorator" = super.buildPythonPackage {
     name = "decorator-4.1.2";
-    buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/bb/e0/f6e41e9091e130bf16d4437dabbac3993908e4d6485ecbc985ef1352db94/decorator-4.1.2.tar.gz";
-      md5 = "a0f7f4fe00ae2dde93494d90c192cf8c";
+      url = "https://files.pythonhosted.org/packages/bb/e0/f6e41e9091e130bf16d4437dabbac3993908e4d6485ecbc985ef1352db94/decorator-4.1.2.tar.gz";
+      sha256 = "1d8npb11kxyi36mrvjdpcjij76l5zfyrz2f820brf0l0rcw4vdkw";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal { fullName = "new BSD License"; } ];
     };
   };
-  dulwich = super.buildPythonPackage {
-    name = "dulwich-0.13.0";
-    buildInputs = with self; [];
+  "dogpile.cache" = super.buildPythonPackage {
+    name = "dogpile.cache-0.6.6";
+    doCheck = false;
+    src = fetchurl {
+      url = "https://files.pythonhosted.org/packages/48/ca/604154d835c3668efb8a31bd979b0ea4bf39c2934a40ffecc0662296cb51/dogpile.cache-0.6.6.tar.gz";
+      sha256 = "1h8n1lxd4l2qvahfkiinljkqz7pww7w3sgag0j8j9ixbl2h4wk84";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.bsdOriginal ];
+    };
+  };
+  "dogpile.core" = super.buildPythonPackage {
+    name = "dogpile.core-0.4.1";
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/84/95/732d280eee829dacc954e8109f97b47abcadcca472c2ab013e1635eb4792/dulwich-0.13.0.tar.gz";
-      md5 = "6dede0626657c2bd08f48ca1221eea91";
+      url = "https://files.pythonhosted.org/packages/0e/77/e72abc04c22aedf874301861e5c1e761231c288b5de369c18be8f4b5c9bb/dogpile.core-0.4.1.tar.gz";
+      sha256 = "0xpdvg4kr1isfkrh1rfsh7za4q5a5s6l2kf9wpvndbwf3aqjyrdy";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.bsdOriginal ];
+    };
+  };
+  "dulwich" = super.buildPythonPackage {
+    name = "dulwich-0.13.0";
+    doCheck = false;
+    src = fetchurl {
+      url = "https://files.pythonhosted.org/packages/84/95/732d280eee829dacc954e8109f97b47abcadcca472c2ab013e1635eb4792/dulwich-0.13.0.tar.gz";
+      sha256 = "0f1jwvrh549c4rgavkn3wizrch904s73s4fmrxykxy9cw8s57lwf";
     };
     meta = {
       license = [ pkgs.lib.licenses.gpl2Plus ];
     };
   };
-  enum34 = super.buildPythonPackage {
+  "enum34" = super.buildPythonPackage {
     name = "enum34-1.1.6";
-    buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/bf/3e/31d502c25302814a7c2f1d3959d2a3b3f78e509002ba91aea64993936876/enum34-1.1.6.tar.gz";
-      md5 = "5f13a0841a61f7fc295c514490d120d0";
+      url = "https://files.pythonhosted.org/packages/bf/3e/31d502c25302814a7c2f1d3959d2a3b3f78e509002ba91aea64993936876/enum34-1.1.6.tar.gz";
+      sha256 = "1cgm5ng2gcfrkrm3hc22brl6chdmv67b9zvva9sfs7gn7dwc9n4a";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
-  funcsigs = super.buildPythonPackage {
+  "funcsigs" = super.buildPythonPackage {
     name = "funcsigs-1.0.2";
-    buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/94/4a/db842e7a0545de1cdb0439bb80e6e42dfe82aaeaadd4072f2263a4fbed23/funcsigs-1.0.2.tar.gz";
-      md5 = "7e583285b1fb8a76305d6d68f4ccc14e";
+      url = "https://files.pythonhosted.org/packages/94/4a/db842e7a0545de1cdb0439bb80e6e42dfe82aaeaadd4072f2263a4fbed23/funcsigs-1.0.2.tar.gz";
+      sha256 = "0l4g5818ffyfmfs1a924811azhjj8ax9xd1cffr1mzd3ycn0zfx7";
     };
     meta = {
       license = [ { fullName = "ASL"; } pkgs.lib.licenses.asl20 ];
     };
   };
-  gevent = super.buildPythonPackage {
-    name = "gevent-1.2.2";
-    buildInputs = with self; [];
+  "gevent" = super.buildPythonPackage {
+    name = "gevent-1.3.5";
     doCheck = false;
-    propagatedBuildInputs = with self; [greenlet];
+    propagatedBuildInputs = [
+      self."greenlet"
+    ];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/1b/92/b111f76e54d2be11375b47b213b56687214f258fd9dae703546d30b837be/gevent-1.2.2.tar.gz";
-      md5 = "7f0baf355384fe5ff2ecf66853422554";
+      url = "https://files.pythonhosted.org/packages/e6/0a/fc345c6e6161f84484870dbcaa58e427c10bd9bdcd08a69bed3d6b398bf1/gevent-1.3.5.tar.gz";
+      sha256 = "1w3gydxirgd2f60c5yv579w4903ds9s4g3587ik4jby97hgqc5bz";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
-  gprof2dot = super.buildPythonPackage {
+  "gprof2dot" = super.buildPythonPackage {
     name = "gprof2dot-2017.9.19";
-    buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/9d/36/f977122502979f3dfb50704979c9ed70e6b620787942b089bf1af15f5aba/gprof2dot-2017.9.19.tar.gz";
-      md5 = "cda2d552bb0d0b9f16e6824a9aabd225";
+      url = "https://files.pythonhosted.org/packages/9d/36/f977122502979f3dfb50704979c9ed70e6b620787942b089bf1af15f5aba/gprof2dot-2017.9.19.tar.gz";
+      sha256 = "17ih23ld2nzgc3xwgbay911l6lh96jp1zshmskm17n1gg2i7mg6f";
     };
     meta = {
       license = [ { fullName = "GNU Lesser General Public License v3 or later (LGPLv3+)"; } { fullName = "LGPL"; } ];
     };
   };
-  greenlet = super.buildPythonPackage {
+  "greenlet" = super.buildPythonPackage {
     name = "greenlet-0.4.13";
-    buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/13/de/ba92335e9e76040ca7274224942282a80d54f85e342a5e33c5277c7f87eb/greenlet-0.4.13.tar.gz";
-      md5 = "6e0b9dd5385f81d478451ec8ed1d62b3";
+      url = "https://files.pythonhosted.org/packages/13/de/ba92335e9e76040ca7274224942282a80d54f85e342a5e33c5277c7f87eb/greenlet-0.4.13.tar.gz";
+      sha256 = "1r412gfx25jrdiv444prmz5a8igrfabwnwqyr6b52ypq7ga87vqg";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.mit ];
+    };
+  };
+  "gunicorn" = super.buildPythonPackage {
+    name = "gunicorn-19.9.0";
+    doCheck = false;
+    src = fetchurl {
+      url = "https://files.pythonhosted.org/packages/47/52/68ba8e5e8ba251e54006a49441f7ccabca83b6bef5aedacb4890596c7911/gunicorn-19.9.0.tar.gz";
+      sha256 = "1wzlf4xmn6qjirh5w81l6i6kqjnab1n1qqkh7zsj1yb6gh4n49ps";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
-  gunicorn = super.buildPythonPackage {
-    name = "gunicorn-19.7.1";
-    buildInputs = with self; [];
+  "hg-evolve" = super.buildPythonPackage {
+    name = "hg-evolve-8.0.1";
+    doCheck = false;
+    src = fetchurl {
+      url = "https://files.pythonhosted.org/packages/06/1a/c5c12d8f117426f05285a820ee5a23121882f5381104e86276b72598934f/hg-evolve-8.0.1.tar.gz";
+      sha256 = "1brafifb42k71gl7qssb5m3ijnm7y30lfvm90z8xxcr2fgz19p29";
+    };
+    meta = {
+      license = [ { fullName = "GPLv2+"; } ];
+    };
+  };
+  "hgsubversion" = super.buildPythonPackage {
+    name = "hgsubversion-1.9.2";
     doCheck = false;
-    propagatedBuildInputs = with self; [];
+    propagatedBuildInputs = [
+      self."mercurial"
+      self."subvertpy"
+    ];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/30/3a/10bb213cede0cc4d13ac2263316c872a64bf4c819000c8ccd801f1d5f822/gunicorn-19.7.1.tar.gz";
-      md5 = "174d3c3cd670a5be0404d84c484e590c";
+      url = "https://files.pythonhosted.org/packages/05/80/3a3cef10dd65e86528ef8d7ac57a41ebc782d0f3c6cfa4fed021aa9fbee0/hgsubversion-1.9.2.tar.gz";
+      sha256 = "16490narhq14vskml3dam8g5y3w3hdqj3g8bgm2b0c0i85l1xvcz";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.gpl1 ];
+    };
+  };
+  "hupper" = super.buildPythonPackage {
+    name = "hupper-1.3";
+    doCheck = false;
+    src = fetchurl {
+      url = "https://files.pythonhosted.org/packages/51/0c/96335b1f2f32245fb871eea5bb9773196505ddb71fad15190056a282df9e/hupper-1.3.tar.gz";
+      sha256 = "1pkyrm9c2crc32ps00k1ahnc5clj3pjwiarc7j0x8aykwih7ff10";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
-  hg-evolve = super.buildPythonPackage {
-    name = "hg-evolve-7.0.1";
-    buildInputs = with self; [];
+  "ipdb" = super.buildPythonPackage {
+    name = "ipdb-0.11";
     doCheck = false;
-    propagatedBuildInputs = with self; [];
+    propagatedBuildInputs = [
+      self."setuptools"
+      self."ipython"
+    ];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/92/5c/4c216be1a08f326a12076b645f4892a2b0865810db1f4a0c9648f1f4c113/hg-evolve-7.0.1.tar.gz";
-      md5 = "2dfa926846ea873a8406bababb06b277";
+      url = "https://files.pythonhosted.org/packages/80/fe/4564de08f174f3846364b3add8426d14cebee228f741c27e702b2877e85b/ipdb-0.11.tar.gz";
+      sha256 = "02m0l8wrhhd3z7dg3czn5ys1g5pxib516hpshdzp7rxzsxgcd0bh";
     };
     meta = {
-      license = [ { fullName = "GPLv2+"; } ];
+      license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
-  hgsubversion = super.buildPythonPackage {
-    name = "hgsubversion-1.9";
-    buildInputs = with self; [];
+  "ipython" = super.buildPythonPackage {
+    name = "ipython-5.1.0";
     doCheck = false;
-    propagatedBuildInputs = with self; [mercurial subvertpy];
+    propagatedBuildInputs = [
+      self."setuptools"
+      self."decorator"
+      self."pickleshare"
+      self."simplegeneric"
+      self."traitlets"
+      self."prompt-toolkit"
+      self."pygments"
+      self."pexpect"
+      self."backports.shutil-get-terminal-size"
+      self."pathlib2"
+      self."pexpect"
+    ];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/db/26/7293a6c6b85e2a74ab452e9ba7f00b04ff0e440e6cd4f84131ac5d5e6b22/hgsubversion-1.9.tar.gz";
-      md5 = "0c6f93ef12cc2e7fe67286f16bcc7211";
+      url = "https://files.pythonhosted.org/packages/89/63/a9292f7cd9d0090a0f995e1167f3f17d5889dcbc9a175261719c513b9848/ipython-5.1.0.tar.gz";
+      sha256 = "0qdrf6aj9kvjczd5chj1my8y2iq09am9l8bb2a1334a52d76kx3y";
     };
     meta = {
-      license = [ pkgs.lib.licenses.gpl1 ];
+      license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
-  hupper = super.buildPythonPackage {
-    name = "hupper-1.0";
-    buildInputs = with self; [];
+  "ipython-genutils" = super.buildPythonPackage {
+    name = "ipython-genutils-0.2.0";
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/2e/07/df892c564dc09bb3cf6f6deb976c26adf9117db75ba218cb4353dbc9d826/hupper-1.0.tar.gz";
-      md5 = "26e77da7d5ac5858f59af050d1a6eb5a";
+      url = "https://files.pythonhosted.org/packages/e8/69/fbeffffc05236398ebfcfb512b6d2511c622871dca1746361006da310399/ipython_genutils-0.2.0.tar.gz";
+      sha256 = "1a4bc9y8hnvq6cp08qs4mckgm6i6ajpndp4g496rvvzcfmp12bpb";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.bsdOriginal ];
+    };
+  };
+  "mako" = super.buildPythonPackage {
+    name = "mako-1.0.7";
+    doCheck = false;
+    propagatedBuildInputs = [
+      self."markupsafe"
+    ];
+    src = fetchurl {
+      url = "https://files.pythonhosted.org/packages/eb/f3/67579bb486517c0d49547f9697e36582cd19dafb5df9e687ed8e22de57fa/Mako-1.0.7.tar.gz";
+      sha256 = "1bi5gnr8r8dva06qpyx4kgjc6spm2k1y908183nbbaylggjzs0jf";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
-  infrae.cache = super.buildPythonPackage {
-    name = "infrae.cache-1.0.1";
-    buildInputs = with self; [];
+  "markupsafe" = super.buildPythonPackage {
+    name = "markupsafe-1.0";
     doCheck = false;
-    propagatedBuildInputs = with self; [Beaker repoze.lru];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/bb/f0/e7d5e984cf6592fd2807dc7bc44a93f9d18e04e6a61f87fdfb2622422d74/infrae.cache-1.0.1.tar.gz";
-      md5 = "b09076a766747e6ed2a755cc62088e32";
-    };
-    meta = {
-      license = [ pkgs.lib.licenses.zpt21 ];
-    };
-  };
-  ipdb = super.buildPythonPackage {
-    name = "ipdb-0.10.3";
-    buildInputs = with self; [];
-    doCheck = false;
-    propagatedBuildInputs = with self; [setuptools ipython];
-    src = fetchurl {
-      url = "https://pypi.python.org/packages/ad/cc/0e7298e1fbf2efd52667c9354a12aa69fb6f796ce230cca03525051718ef/ipdb-0.10.3.tar.gz";
-      md5 = "def1f6ac075d54bdee07e6501263d4fa";
+      url = "https://files.pythonhosted.org/packages/4d/de/32d741db316d8fdb7680822dd37001ef7a448255de9699ab4bfcbdf4172b/MarkupSafe-1.0.tar.gz";
+      sha256 = "0rdn1s8x9ni7ss8rfiacj7x1085lx8mh2zdwqslnw8xc3l4nkgm6";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
-  ipython = super.buildPythonPackage {
-    name = "ipython-5.1.0";
-    buildInputs = with self; [];
+  "mercurial" = super.buildPythonPackage {
+    name = "mercurial-4.6.2";
     doCheck = false;
-    propagatedBuildInputs = with self; [setuptools decorator pickleshare simplegeneric traitlets prompt-toolkit pygments pexpect backports.shutil-get-terminal-size pathlib2 pexpect];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/89/63/a9292f7cd9d0090a0f995e1167f3f17d5889dcbc9a175261719c513b9848/ipython-5.1.0.tar.gz";
-      md5 = "47c8122420f65b58784cb4b9b4af35e3";
+      url = "https://files.pythonhosted.org/packages/d9/fb/c7ecf2b7fd349878dbf45b8390b8db735cef73d49dd9ce8a364b4ca3a846/mercurial-4.6.2.tar.gz";
+      sha256 = "1bv6wgcdx8glihjjfg22khhc52mclsn4kwfqvzbzlg0b42h4xl0w";
     };
     meta = {
-      license = [ pkgs.lib.licenses.bsdOriginal ];
+      license = [ pkgs.lib.licenses.gpl1 pkgs.lib.licenses.gpl2Plus ];
     };
   };
-  ipython-genutils = super.buildPythonPackage {
-    name = "ipython-genutils-0.2.0";
-    buildInputs = with self; [];
+  "mock" = super.buildPythonPackage {
+    name = "mock-1.0.1";
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/e8/69/fbeffffc05236398ebfcfb512b6d2511c622871dca1746361006da310399/ipython_genutils-0.2.0.tar.gz";
-      md5 = "5a4f9781f78466da0ea1a648f3e1f79f";
+      url = "https://files.pythonhosted.org/packages/a2/52/7edcd94f0afb721a2d559a5b9aae8af4f8f2c79bc63fdbe8a8a6c9b23bbe/mock-1.0.1.tar.gz";
+      sha256 = "0kzlsbki6q0awf89rc287f3aj8x431lrajf160a70z0ikhnxsfdq";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
-  mercurial = super.buildPythonPackage {
-    name = "mercurial-4.4.2";
-    buildInputs = with self; [];
+  "more-itertools" = super.buildPythonPackage {
+    name = "more-itertools-4.3.0";
     doCheck = false;
-    propagatedBuildInputs = with self; [];
+    propagatedBuildInputs = [
+      self."six"
+    ];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/d0/83/92a5fa662ba277128db305e39e7ea5a638f2f1cbbc6dc5fbf4c14aefae22/mercurial-4.4.2.tar.gz";
-      md5 = "95769125cf7e9dbc341a983253acefcd";
+      url = "https://files.pythonhosted.org/packages/88/ff/6d485d7362f39880810278bdc906c13300db05485d9c65971dec1142da6a/more-itertools-4.3.0.tar.gz";
+      sha256 = "17h3na0rdh8xq30w4b9pizgkdxmm51896bxw600x84jflg9vaxn4";
     };
     meta = {
-      license = [ pkgs.lib.licenses.gpl1 pkgs.lib.licenses.gpl2Plus ];
+      license = [ pkgs.lib.licenses.mit ];
     };
   };
-  mock = super.buildPythonPackage {
-    name = "mock-1.0.1";
-    buildInputs = with self; [];
+  "msgpack-python" = super.buildPythonPackage {
+    name = "msgpack-python-0.5.6";
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/a2/52/7edcd94f0afb721a2d559a5b9aae8af4f8f2c79bc63fdbe8a8a6c9b23bbe/mock-1.0.1.tar.gz";
-      md5 = "c3971991738caa55ec7c356bbc154ee2";
-    };
-    meta = {
-      license = [ pkgs.lib.licenses.bsdOriginal ];
-    };
-  };
-  msgpack-python = super.buildPythonPackage {
-    name = "msgpack-python-0.4.8";
-    buildInputs = with self; [];
-    doCheck = false;
-    propagatedBuildInputs = with self; [];
-    src = fetchurl {
-      url = "https://pypi.python.org/packages/21/27/8a1d82041c7a2a51fcc73675875a5f9ea06c2663e02fcfeb708be1d081a0/msgpack-python-0.4.8.tar.gz";
-      md5 = "dcd854fb41ee7584ebbf35e049e6be98";
+      url = "https://files.pythonhosted.org/packages/8a/20/6eca772d1a5830336f84aca1d8198e5a3f4715cd1c7fc36d3cc7f7185091/msgpack-python-0.5.6.tar.gz";
+      sha256 = "16wh8qgybmfh4pjp8vfv78mdlkxfmcasg78lzlnm6nslsfkci31p";
     };
     meta = {
       license = [ pkgs.lib.licenses.asl20 ];
     };
   };
-  pathlib2 = super.buildPythonPackage {
-    name = "pathlib2-2.3.0";
-    buildInputs = with self; [];
+  "pastedeploy" = super.buildPythonPackage {
+    name = "pastedeploy-1.5.2";
     doCheck = false;
-    propagatedBuildInputs = with self; [six scandir];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/a1/14/df0deb867c2733f7d857523c10942b3d6612a1b222502fdffa9439943dfb/pathlib2-2.3.0.tar.gz";
-      md5 = "89c90409d11fd5947966b6a30a47d18c";
+      url = "https://files.pythonhosted.org/packages/0f/90/8e20cdae206c543ea10793cbf4136eb9a8b3f417e04e40a29d72d9922cbd/PasteDeploy-1.5.2.tar.gz";
+      sha256 = "1jz3m4hq8v6hyhfjz9425nd3nvn52cvbfipdcd72krjmla4qz1fm";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.mit ];
+    };
+  };
+  "pathlib2" = super.buildPythonPackage {
+    name = "pathlib2-2.3.0";
+    doCheck = false;
+    propagatedBuildInputs = [
+      self."six"
+      self."scandir"
+    ];
+    src = fetchurl {
+      url = "https://files.pythonhosted.org/packages/a1/14/df0deb867c2733f7d857523c10942b3d6612a1b222502fdffa9439943dfb/pathlib2-2.3.0.tar.gz";
+      sha256 = "1cx5gs2v9j2vnzmcrbq5l8fq2mwrr1h6pyf1sjdji2w1bavm09fk";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
-  pexpect = super.buildPythonPackage {
-    name = "pexpect-4.4.0";
-    buildInputs = with self; [];
+  "pexpect" = super.buildPythonPackage {
+    name = "pexpect-4.6.0";
     doCheck = false;
-    propagatedBuildInputs = with self; [ptyprocess];
+    propagatedBuildInputs = [
+      self."ptyprocess"
+    ];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/fa/c3/60c0cbf96f242d0b47a82e9ca634dcd6dcb043832cf05e17540812e1c707/pexpect-4.4.0.tar.gz";
-      md5 = "e9b07f0765df8245ac72201d757baaef";
+      url = "https://files.pythonhosted.org/packages/89/43/07d07654ee3e25235d8cea4164cdee0ec39d1fda8e9203156ebe403ffda4/pexpect-4.6.0.tar.gz";
+      sha256 = "1fla85g47iaxxpjhp9vkxdnv4pgc7rplfy6ja491smrrk0jqi3ia";
     };
     meta = {
       license = [ pkgs.lib.licenses.isc { fullName = "ISC License (ISCL)"; } ];
     };
   };
-  pickleshare = super.buildPythonPackage {
+  "pickleshare" = super.buildPythonPackage {
     name = "pickleshare-0.7.4";
-    buildInputs = with self; [];
+    doCheck = false;
+    propagatedBuildInputs = [
+      self."pathlib2"
+    ];
+    src = fetchurl {
+      url = "https://files.pythonhosted.org/packages/69/fe/dd137d84daa0fd13a709e448138e310d9ea93070620c9db5454e234af525/pickleshare-0.7.4.tar.gz";
+      sha256 = "0yvk14dzxk7g6qpr7iw23vzqbsr0dh4ij4xynkhnzpfz4xr2bac4";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.mit ];
+    };
+  };
+  "plaster" = super.buildPythonPackage {
+    name = "plaster-1.0";
     doCheck = false;
-    propagatedBuildInputs = with self; [pathlib2];
+    propagatedBuildInputs = [
+      self."setuptools"
+    ];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/69/fe/dd137d84daa0fd13a709e448138e310d9ea93070620c9db5454e234af525/pickleshare-0.7.4.tar.gz";
-      md5 = "6a9e5dd8dfc023031f6b7b3f824cab12";
+      url = "https://files.pythonhosted.org/packages/37/e1/56d04382d718d32751017d32f351214384e529b794084eee20bb52405563/plaster-1.0.tar.gz";
+      sha256 = "1hy8k0nv2mxq94y5aysk6hjk9ryb4bsd13g83m60hcyzxz3wflc3";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.mit ];
+    };
+  };
+  "plaster-pastedeploy" = super.buildPythonPackage {
+    name = "plaster-pastedeploy-0.6";
+    doCheck = false;
+    propagatedBuildInputs = [
+      self."pastedeploy"
+      self."plaster"
+    ];
+    src = fetchurl {
+      url = "https://files.pythonhosted.org/packages/3f/e7/6a6833158d2038ec40085433308a1e164fd1dac595513f6dd556d5669bb8/plaster_pastedeploy-0.6.tar.gz";
+      sha256 = "1bkggk18f4z2bmsmxyxabvf62znvjwbivzh880419r3ap0616cf2";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.mit ];
+    };
+  };
+  "pluggy" = super.buildPythonPackage {
+    name = "pluggy-0.6.0";
+    doCheck = false;
+    src = fetchurl {
+      url = "https://files.pythonhosted.org/packages/11/bf/cbeb8cdfaffa9f2ea154a30ae31a9d04a1209312e2919138b4171a1f8199/pluggy-0.6.0.tar.gz";
+      sha256 = "1zqckndfn85l1cd8pndw212zg1bq9fkg1nnj32kp2mppppsyg2kz";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
-  plaster = super.buildPythonPackage {
-    name = "plaster-1.0";
-    buildInputs = with self; [];
+  "prompt-toolkit" = super.buildPythonPackage {
+    name = "prompt-toolkit-1.0.15";
     doCheck = false;
-    propagatedBuildInputs = with self; [setuptools];
+    propagatedBuildInputs = [
+      self."six"
+      self."wcwidth"
+    ];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/37/e1/56d04382d718d32751017d32f351214384e529b794084eee20bb52405563/plaster-1.0.tar.gz";
-      md5 = "80e6beb4760c16fea31754babcc0576e";
+      url = "https://files.pythonhosted.org/packages/8a/ad/cf6b128866e78ad6d7f1dc5b7f99885fb813393d9860778b2984582e81b5/prompt_toolkit-1.0.15.tar.gz";
+      sha256 = "05v9h5nydljwpj5nm8n804ms0glajwfy1zagrzqrg91wk3qqi1c5";
     };
     meta = {
-      license = [ pkgs.lib.licenses.mit ];
+      license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
-  plaster-pastedeploy = super.buildPythonPackage {
-    name = "plaster-pastedeploy-0.4.2";
-    buildInputs = with self; [];
+  "psutil" = super.buildPythonPackage {
+    name = "psutil-5.4.6";
     doCheck = false;
-    propagatedBuildInputs = with self; [PasteDeploy plaster];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/2c/62/0daf9c0be958e785023e583e51baac15863699e956bfb3d448898d80edd8/plaster_pastedeploy-0.4.2.tar.gz";
-      md5 = "58fd7852002909378e818c9d5b71e90a";
-    };
-    meta = {
-      license = [ pkgs.lib.licenses.mit ];
-    };
-  };
-  prompt-toolkit = super.buildPythonPackage {
-    name = "prompt-toolkit-1.0.15";
-    buildInputs = with self; [];
-    doCheck = false;
-    propagatedBuildInputs = with self; [six wcwidth];
-    src = fetchurl {
-      url = "https://pypi.python.org/packages/8a/ad/cf6b128866e78ad6d7f1dc5b7f99885fb813393d9860778b2984582e81b5/prompt_toolkit-1.0.15.tar.gz";
-      md5 = "8fe70295006dbc8afedd43e5eba99032";
+      url = "https://files.pythonhosted.org/packages/51/9e/0f8f5423ce28c9109807024f7bdde776ed0b1161de20b408875de7e030c3/psutil-5.4.6.tar.gz";
+      sha256 = "1xmw4qi6hnrhw81xqzkvmsm9im7j2vkk4v26ycjwq2jczqsmlvk8";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
-  ptyprocess = super.buildPythonPackage {
-    name = "ptyprocess-0.5.2";
-    buildInputs = with self; [];
+  "ptyprocess" = super.buildPythonPackage {
+    name = "ptyprocess-0.6.0";
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/51/83/5d07dc35534640b06f9d9f1a1d2bc2513fb9cc7595a1b0e28ae5477056ce/ptyprocess-0.5.2.tar.gz";
-      md5 = "d3b8febae1b8c53b054bd818d0bb8665";
+      url = "https://files.pythonhosted.org/packages/7d/2d/e4b8733cf79b7309d84c9081a4ab558c89d8c89da5961bf4ddb050ca1ce0/ptyprocess-0.6.0.tar.gz";
+      sha256 = "1h4lcd3w5nrxnsk436ar7fwkiy5rfn5wj2xwy9l0r4mdqnf2jgwj";
     };
     meta = {
       license = [  ];
     };
   };
-  py = super.buildPythonPackage {
-    name = "py-1.5.2";
-    buildInputs = with self; [];
+  "py" = super.buildPythonPackage {
+    name = "py-1.5.3";
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/90/e3/e075127d39d35f09a500ebb4a90afd10f9ef0a1d28a6d09abeec0e444fdd/py-1.5.2.tar.gz";
-      md5 = "279ca69c632069e1b71e11b14641ca28";
+      url = "https://files.pythonhosted.org/packages/f7/84/b4c6e84672c4ceb94f727f3da8344037b62cee960d80e999b1cd9b832d83/py-1.5.3.tar.gz";
+      sha256 = "10gq2lckvgwlk9w6yzijhzkarx44hsaknd0ypa08wlnpjnsgmj99";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
-  pygments = super.buildPythonPackage {
+  "pygments" = super.buildPythonPackage {
     name = "pygments-2.2.0";
-    buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/71/2a/2e4e77803a8bd6408a2903340ac498cb0a2181811af7c9ec92cb70b0308a/Pygments-2.2.0.tar.gz";
-      md5 = "13037baca42f16917cbd5ad2fab50844";
+      url = "https://files.pythonhosted.org/packages/71/2a/2e4e77803a8bd6408a2903340ac498cb0a2181811af7c9ec92cb70b0308a/Pygments-2.2.0.tar.gz";
+      sha256 = "1k78qdvir1yb1c634nkv6rbga8wv4289xarghmsbbvzhvr311bnv";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
-  pyramid = super.buildPythonPackage {
-    name = "pyramid-1.9.1";
-    buildInputs = with self; [];
+  "pyramid" = super.buildPythonPackage {
+    name = "pyramid-1.9.2";
     doCheck = false;
-    propagatedBuildInputs = with self; [setuptools WebOb repoze.lru zope.interface zope.deprecation venusian translationstring PasteDeploy plaster plaster-pastedeploy hupper];
+    propagatedBuildInputs = [
+      self."setuptools"
+      self."webob"
+      self."repoze.lru"
+      self."zope.interface"
+      self."zope.deprecation"
+      self."venusian"
+      self."translationstring"
+      self."pastedeploy"
+      self."plaster"
+      self."plaster-pastedeploy"
+      self."hupper"
+    ];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/9a/57/73447be9e7d0512d601e3f0a1fb9d7d1efb941911f49efdfe036d2826507/pyramid-1.9.1.tar.gz";
-      md5 = "0163e19c58c2d12976a3b6fdb57e052d";
+      url = "https://files.pythonhosted.org/packages/a0/c1/b321d07cfc4870541989ad131c86a1d593bfe802af0eca9718a0dadfb97a/pyramid-1.9.2.tar.gz";
+      sha256 = "09drsl0346nchgxp2j7sa5hlk7mkhfld9wvbd0wicacrp26a92fg";
     };
     meta = {
       license = [ { fullName = "Repoze Public License"; } { fullName = "BSD-derived (http://www.repoze.org/LICENSE.txt)"; } ];
     };
   };
-  pyramid-jinja2 = super.buildPythonPackage {
-    name = "pyramid-jinja2-2.7";
-    buildInputs = with self; [];
+  "pyramid-mako" = super.buildPythonPackage {
+    name = "pyramid-mako-1.0.2";
     doCheck = false;
-    propagatedBuildInputs = with self; [pyramid zope.deprecation Jinja2 MarkupSafe];
+    propagatedBuildInputs = [
+      self."pyramid"
+      self."mako"
+    ];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/d8/80/d60a7233823de22ce77bd864a8a83736a1fe8b49884b08303a2e68b2c853/pyramid_jinja2-2.7.tar.gz";
-      md5 = "c2f8b2cd7b73a6f1d9a311fcfaf4fb92";
+      url = "https://files.pythonhosted.org/packages/f1/92/7e69bcf09676d286a71cb3bbb887b16595b96f9ba7adbdc239ffdd4b1eb9/pyramid_mako-1.0.2.tar.gz";
+      sha256 = "18gk2vliq8z4acblsl6yzgbvnr9rlxjlcqir47km7kvlk1xri83d";
     };
     meta = {
       license = [ { fullName = "Repoze Public License"; } { fullName = "BSD-derived (http://www.repoze.org/LICENSE.txt)"; } ];
     };
   };
-  pyramid-mako = super.buildPythonPackage {
-    name = "pyramid-mako-1.0.2";
-    buildInputs = with self; [];
-    doCheck = false;
-    propagatedBuildInputs = with self; [pyramid Mako];
-    src = fetchurl {
-      url = "https://pypi.python.org/packages/f1/92/7e69bcf09676d286a71cb3bbb887b16595b96f9ba7adbdc239ffdd4b1eb9/pyramid_mako-1.0.2.tar.gz";
-      md5 = "ee25343a97eb76bd90abdc2a774eb48a";
-    };
-    meta = {
-      license = [ { fullName = "Repoze Public License"; } { fullName = "BSD-derived (http://www.repoze.org/LICENSE.txt)"; } ];
-    };
-  };
-  pytest = super.buildPythonPackage {
-    name = "pytest-3.2.5";
-    buildInputs = with self; [];
+  "pytest" = super.buildPythonPackage {
+    name = "pytest-3.6.0";
     doCheck = false;
-    propagatedBuildInputs = with self; [py setuptools];
+    propagatedBuildInputs = [
+      self."py"
+      self."six"
+      self."setuptools"
+      self."attrs"
+      self."more-itertools"
+      self."atomicwrites"
+      self."pluggy"
+      self."funcsigs"
+    ];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/1f/f8/8cd74c16952163ce0db0bd95fdd8810cbf093c08be00e6e665ebf0dc3138/pytest-3.2.5.tar.gz";
-      md5 = "6dbe9bb093883f75394a689a1426ac6f";
-    };
-    meta = {
-      license = [ pkgs.lib.licenses.mit ];
-    };
-  };
-  pytest-catchlog = super.buildPythonPackage {
-    name = "pytest-catchlog-1.2.2";
-    buildInputs = with self; [];
-    doCheck = false;
-    propagatedBuildInputs = with self; [py pytest];
-    src = fetchurl {
-      url = "https://pypi.python.org/packages/f2/2b/2faccdb1a978fab9dd0bf31cca9f6847fbe9184a0bdcc3011ac41dd44191/pytest-catchlog-1.2.2.zip";
-      md5 = "09d890c54c7456c818102b7ff8c182c8";
+      url = "https://files.pythonhosted.org/packages/67/6a/5bcdc22f8dbada1d2910d6e1a3a03f6b14306c78f81122890735b28be4bf/pytest-3.6.0.tar.gz";
+      sha256 = "0bdfazvjjbxssqzyvkb3m2x2in7xv56ipr899l00s87k7815sm9r";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
-  pytest-cov = super.buildPythonPackage {
+  "pytest-cov" = super.buildPythonPackage {
     name = "pytest-cov-2.5.1";
-    buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [pytest coverage];
+    propagatedBuildInputs = [
+      self."pytest"
+      self."coverage"
+    ];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/24/b4/7290d65b2f3633db51393bdf8ae66309b37620bc3ec116c5e357e3e37238/pytest-cov-2.5.1.tar.gz";
-      md5 = "5acf38d4909e19819eb5c1754fbfc0ac";
+      url = "https://files.pythonhosted.org/packages/24/b4/7290d65b2f3633db51393bdf8ae66309b37620bc3ec116c5e357e3e37238/pytest-cov-2.5.1.tar.gz";
+      sha256 = "0bbfpwdh9k3636bxc88vz9fa7vf4akchgn513ql1vd0xy4n7bah3";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal pkgs.lib.licenses.mit ];
     };
   };
-  pytest-profiling = super.buildPythonPackage {
-    name = "pytest-profiling-1.2.11";
-    buildInputs = with self; [];
+  "pytest-profiling" = super.buildPythonPackage {
+    name = "pytest-profiling-1.3.0";
     doCheck = false;
-    propagatedBuildInputs = with self; [six pytest gprof2dot];
+    propagatedBuildInputs = [
+      self."six"
+      self."pytest"
+      self."gprof2dot"
+    ];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/c0/4a/b4aa786e93c07a86f1f87c581a36bf355a9e06a9da7e00dbd05047626bd2/pytest-profiling-1.2.11.tar.gz";
-      md5 = "9ef6b60248731be5d44477980408e8f7";
+      url = "https://files.pythonhosted.org/packages/f5/34/4626126e041a51ef50a80d0619519b18d20aef249aac25b0d0fdd47e57ee/pytest-profiling-1.3.0.tar.gz";
+      sha256 = "08r5afx5z22yvpmsnl91l4amsy1yxn8qsmm61mhp06mz8zjs51kb";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
-  pytest-runner = super.buildPythonPackage {
-    name = "pytest-runner-3.0";
-    buildInputs = with self; [];
+  "pytest-runner" = super.buildPythonPackage {
+    name = "pytest-runner-4.2";
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/65/b4/ae89338cd2d81e2cc54bd6db2e962bfe948f612303610d68ab24539ac2d1/pytest-runner-3.0.tar.gz";
-      md5 = "8f8363a52bbabc4cedd5e239beb2ba11";
+      url = "https://files.pythonhosted.org/packages/9e/b7/fe6e8f87f9a756fd06722216f1b6698ccba4d269eac6329d9f0c441d0f93/pytest-runner-4.2.tar.gz";
+      sha256 = "1gkpyphawxz38ni1gdq1fmwyqcg02m7ypzqvv46z06crwdxi2gyj";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
-  pytest-sugar = super.buildPythonPackage {
-    name = "pytest-sugar-0.9.0";
-    buildInputs = with self; [];
+  "pytest-sugar" = super.buildPythonPackage {
+    name = "pytest-sugar-0.9.1";
     doCheck = false;
-    propagatedBuildInputs = with self; [pytest termcolor];
+    propagatedBuildInputs = [
+      self."pytest"
+      self."termcolor"
+    ];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/49/d8/c5ff6cca3ce2ebd8b73eec89779bf6b4a7737456a70e8ea4d44c1ff90f71/pytest-sugar-0.9.0.tar.gz";
-      md5 = "89fbff17277fa6a95a560a04b68cb9f9";
+      url = "https://files.pythonhosted.org/packages/3e/6a/a3f909083079d03bde11d06ab23088886bbe25f2c97fbe4bb865e2bf05bc/pytest-sugar-0.9.1.tar.gz";
+      sha256 = "0b4av40dv30727m54v211r0nzwjp2ajkjgxix6j484qjmwpw935b";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
-  pytest-timeout = super.buildPythonPackage {
-    name = "pytest-timeout-1.2.0";
-    buildInputs = with self; [];
+  "pytest-timeout" = super.buildPythonPackage {
+    name = "pytest-timeout-1.2.1";
     doCheck = false;
-    propagatedBuildInputs = with self; [pytest];
+    propagatedBuildInputs = [
+      self."pytest"
+    ];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/cc/b7/b2a61365ea6b6d2e8881360ae7ed8dad0327ad2df89f2f0be4a02304deb2/pytest-timeout-1.2.0.tar.gz";
-      md5 = "83607d91aa163562c7ee835da57d061d";
+      url = "https://files.pythonhosted.org/packages/be/e9/a9106b8bc87521c6813060f50f7d1fdc15665bc1bbbe71c0ffc1c571aaa2/pytest-timeout-1.2.1.tar.gz";
+      sha256 = "1kdp6qbh5v1168l99rba5yfzvy05gmzkmkhldgp36p9xcdjd5dv8";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit { fullName = "DFSG approved"; } ];
     };
   };
-  repoze.lru = super.buildPythonPackage {
+  "repoze.lru" = super.buildPythonPackage {
     name = "repoze.lru-0.7";
-    buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/12/bc/595a77c4b5e204847fdf19268314ef59c85193a9dc9f83630fc459c0fee5/repoze.lru-0.7.tar.gz";
-      md5 = "c08cc030387e0b1fc53c5c7d964b35e2";
+      url = "https://files.pythonhosted.org/packages/12/bc/595a77c4b5e204847fdf19268314ef59c85193a9dc9f83630fc459c0fee5/repoze.lru-0.7.tar.gz";
+      sha256 = "0xzz1aw2smy8hdszrq8yhnklx6w1r1mf55061kalw3iq35gafa84";
     };
     meta = {
       license = [ { fullName = "Repoze Public License"; } { fullName = "BSD-derived (http://www.repoze.org/LICENSE.txt)"; } ];
     };
   };
-  rhodecode-vcsserver = super.buildPythonPackage {
-    name = "rhodecode-vcsserver-4.12.4";
-    buildInputs = with self; [pytest py pytest-cov pytest-sugar pytest-runner pytest-catchlog pytest-profiling gprof2dot pytest-timeout mock WebTest cov-core coverage configobj];
+  "rhodecode-vcsserver" = super.buildPythonPackage {
+    name = "rhodecode-vcsserver-4.13.0";
+    buildInputs = [
+      self."pytest"
+      self."py"
+      self."pytest-cov"
+      self."pytest-sugar"
+      self."pytest-runner"
+      self."pytest-profiling"
+      self."gprof2dot"
+      self."pytest-timeout"
+      self."mock"
+      self."webtest"
+      self."cov-core"
+      self."coverage"
+      self."configobj"
+    ];
     doCheck = true;
-    propagatedBuildInputs = with self; [Beaker configobj decorator dulwich hgsubversion hg-evolve infrae.cache mercurial msgpack-python pyramid pyramid-jinja2 pyramid-mako repoze.lru simplejson subprocess32 subvertpy six translationstring WebOb wheel zope.deprecation zope.interface ipdb ipython gevent greenlet gunicorn waitress pytest py pytest-cov pytest-sugar pytest-runner pytest-catchlog pytest-profiling gprof2dot pytest-timeout mock WebTest cov-core coverage];
+    propagatedBuildInputs = [
+      self."configobj"
+      self."dogpile.cache"
+      self."dogpile.core"
+      self."decorator"
+      self."dulwich"
+      self."hgsubversion"
+      self."hg-evolve"
+      self."mako"
+      self."markupsafe"
+      self."mercurial"
+      self."msgpack-python"
+      self."pastedeploy"
+      self."psutil"
+      self."pyramid"
+      self."pyramid-mako"
+      self."pygments"
+      self."pathlib2"
+      self."repoze.lru"
+      self."simplejson"
+      self."subprocess32"
+      self."setproctitle"
+      self."subvertpy"
+      self."six"
+      self."translationstring"
+      self."webob"
+      self."zope.deprecation"
+      self."zope.interface"
+      self."gevent"
+      self."greenlet"
+      self."gunicorn"
+      self."waitress"
+      self."ipdb"
+      self."ipython"
+      self."pytest"
+      self."py"
+      self."pytest-cov"
+      self."pytest-sugar"
+      self."pytest-runner"
+      self."pytest-profiling"
+      self."gprof2dot"
+      self."pytest-timeout"
+      self."mock"
+      self."webtest"
+      self."cov-core"
+      self."coverage"
+    ];
     src = ./.;
     meta = {
       license = [ { fullName = "GPL V3"; } { fullName = "GNU General Public License v3 or later (GPLv3+)"; } ];
     };
   };
-  scandir = super.buildPythonPackage {
-    name = "scandir-1.7";
-    buildInputs = with self; [];
+  "scandir" = super.buildPythonPackage {
+    name = "scandir-1.9.0";
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/13/bb/e541b74230bbf7a20a3949a2ee6631be299378a784f5445aa5d0047c192b/scandir-1.7.tar.gz";
-      md5 = "037e5f24d1a0e78b17faca72dea9555f";
+      url = "https://files.pythonhosted.org/packages/16/2a/557af1181e6b4e30254d5a6163b18f5053791ca66e251e77ab08887e8fe3/scandir-1.9.0.tar.gz";
+      sha256 = "0r3hvf1a9jm1rkqgx40gxkmccknkaiqjavs8lccgq9s8khh5x5s4";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal { fullName = "New BSD License"; } ];
     };
   };
-  setuptools = super.buildPythonPackage {
-    name = "setuptools-30.1.0";
-    buildInputs = with self; [];
+  "setproctitle" = super.buildPythonPackage {
+    name = "setproctitle-1.1.10";
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/1e/43/002c8616db9a3e7be23c2556e39b90a32bb40ba0dc652de1999d5334d372/setuptools-30.1.0.tar.gz";
-      md5 = "cac497f42e5096ac8df29e38d3f81c3e";
+      url = "https://files.pythonhosted.org/packages/5a/0d/dc0d2234aacba6cf1a729964383e3452c52096dc695581248b548786f2b3/setproctitle-1.1.10.tar.gz";
+      sha256 = "163kplw9dcrw0lffq1bvli5yws3rngpnvrxrzdw89pbphjjvg0v2";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.bsdOriginal ];
+    };
+  };
+  "setuptools" = super.buildPythonPackage {
+    name = "setuptools-40.1.0";
+    doCheck = false;
+    src = fetchurl {
+      url = "https://files.pythonhosted.org/packages/5a/df/b2e3d9693bb0dcbeac516a73dd7a9eb82b126ae52e4a74605a9b01beddd5/setuptools-40.1.0.zip";
+      sha256 = "0w1blx5ajga5y15dci0mddk49cf2xpq0mp7rp7jrqr2diqk00ib6";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
-  simplegeneric = super.buildPythonPackage {
+  "simplegeneric" = super.buildPythonPackage {
     name = "simplegeneric-0.8.1";
-    buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/3d/57/4d9c9e3ae9a255cd4e1106bb57e24056d3d0709fc01b2e3e345898e49d5b/simplegeneric-0.8.1.zip";
-      md5 = "f9c1fab00fd981be588fc32759f474e3";
+      url = "https://files.pythonhosted.org/packages/3d/57/4d9c9e3ae9a255cd4e1106bb57e24056d3d0709fc01b2e3e345898e49d5b/simplegeneric-0.8.1.zip";
+      sha256 = "0wwi1c6md4vkbcsfsf8dklf3vr4mcdj4mpxkanwgb6jb1432x5yw";
     };
     meta = {
-      license = [ pkgs.lib.licenses.zpt21 ];
+      license = [ pkgs.lib.licenses.zpl21 ];
     };
   };
-  simplejson = super.buildPythonPackage {
+  "simplejson" = super.buildPythonPackage {
     name = "simplejson-3.11.1";
-    buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/08/48/c97b668d6da7d7bebe7ea1817a6f76394b0ec959cb04214ca833c34359df/simplejson-3.11.1.tar.gz";
-      md5 = "6e2f1bd5fb0a926facf5d89d217a7183";
+      url = "https://files.pythonhosted.org/packages/08/48/c97b668d6da7d7bebe7ea1817a6f76394b0ec959cb04214ca833c34359df/simplejson-3.11.1.tar.gz";
+      sha256 = "1rr58dppsq73p0qcd9bsw066cdd3v63sqv7j6sqni8frvm4jv8h1";
     };
     meta = {
       license = [ { fullName = "Academic Free License (AFL)"; } pkgs.lib.licenses.mit ];
     };
   };
-  six = super.buildPythonPackage {
+  "six" = super.buildPythonPackage {
     name = "six-1.11.0";
-    buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/16/d8/bc6316cf98419719bd59c91742194c111b6f2e85abac88e496adefaf7afe/six-1.11.0.tar.gz";
-      md5 = "d12789f9baf7e9fb2524c0c64f1773f8";
+      url = "https://files.pythonhosted.org/packages/16/d8/bc6316cf98419719bd59c91742194c111b6f2e85abac88e496adefaf7afe/six-1.11.0.tar.gz";
+      sha256 = "1scqzwc51c875z23phj48gircqjgnn3af8zy2izjwmnlxrxsgs3h";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
-  subprocess32 = super.buildPythonPackage {
-    name = "subprocess32-3.2.7";
-    buildInputs = with self; [];
+  "subprocess32" = super.buildPythonPackage {
+    name = "subprocess32-3.5.1";
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/b8/2f/49e53b0d0e94611a2dc624a1ad24d41b6d94d0f1b0a078443407ea2214c2/subprocess32-3.2.7.tar.gz";
-      md5 = "824c801e479d3e916879aae3e9c15e16";
+      url = "https://files.pythonhosted.org/packages/de/fb/fd3e91507021e2aecdb081d1b920082628d6b8869ead845e3e87b3d2e2ca/subprocess32-3.5.1.tar.gz";
+      sha256 = "0wgi3bfnssid1g6h0v803z3k1wjal6il16nr3r9c587cfzwfkv0q";
     };
     meta = {
       license = [ pkgs.lib.licenses.psfl ];
     };
   };
-  subvertpy = super.buildPythonPackage {
+  "subvertpy" = super.buildPythonPackage {
     name = "subvertpy-0.10.1";
-    buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/9d/76/99fa82affce75f5ac0f7dbe513796c3f37311ace0c68e1b063683b4f9b99/subvertpy-0.10.1.tar.gz";
-      md5 = "a70e03579902d480f5e9f8c570f6536b";
+      url = "https://files.pythonhosted.org/packages/9d/76/99fa82affce75f5ac0f7dbe513796c3f37311ace0c68e1b063683b4f9b99/subvertpy-0.10.1.tar.gz";
+      sha256 = "061ncy9wjz3zyv527avcrdyk0xygyssyy7p1644nhzhwp8zpybij";
     };
     meta = {
       license = [ pkgs.lib.licenses.lgpl21Plus pkgs.lib.licenses.gpl2Plus ];
     };
   };
-  termcolor = super.buildPythonPackage {
+  "termcolor" = super.buildPythonPackage {
     name = "termcolor-1.1.0";
-    buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/8a/48/a76be51647d0eb9f10e2a4511bf3ffb8cc1e6b14e9e4fab46173aa79f981/termcolor-1.1.0.tar.gz";
-      md5 = "043e89644f8909d462fbbfa511c768df";
+      url = "https://files.pythonhosted.org/packages/8a/48/a76be51647d0eb9f10e2a4511bf3ffb8cc1e6b14e9e4fab46173aa79f981/termcolor-1.1.0.tar.gz";
+      sha256 = "0fv1vq14rpqwgazxg4981904lfyp84mnammw7y046491cv76jv8x";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
-  traitlets = super.buildPythonPackage {
+  "traitlets" = super.buildPythonPackage {
     name = "traitlets-4.3.2";
-    buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [ipython-genutils six decorator enum34];
+    propagatedBuildInputs = [
+      self."ipython-genutils"
+      self."six"
+      self."decorator"
+      self."enum34"
+    ];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/a5/98/7f5ef2fe9e9e071813aaf9cb91d1a732e0a68b6c44a32b38cb8e14c3f069/traitlets-4.3.2.tar.gz";
-      md5 = "3068663f2f38fd939a9eb3a500ccc154";
+      url = "https://files.pythonhosted.org/packages/a5/98/7f5ef2fe9e9e071813aaf9cb91d1a732e0a68b6c44a32b38cb8e14c3f069/traitlets-4.3.2.tar.gz";
+      sha256 = "0dbq7sx26xqz5ixs711k5nc88p8a0nqyz6162pwks5dpcz9d4jww";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
-  translationstring = super.buildPythonPackage {
+  "translationstring" = super.buildPythonPackage {
     name = "translationstring-1.3";
-    buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/5e/eb/bee578cc150b44c653b63f5ebe258b5d0d812ddac12497e5f80fcad5d0b4/translationstring-1.3.tar.gz";
-      md5 = "a4b62e0f3c189c783a1685b3027f7c90";
+      url = "https://files.pythonhosted.org/packages/5e/eb/bee578cc150b44c653b63f5ebe258b5d0d812ddac12497e5f80fcad5d0b4/translationstring-1.3.tar.gz";
+      sha256 = "0bdpcnd9pv0131dl08h4zbcwmgc45lyvq3pa224xwan5b3x4rr2f";
     };
     meta = {
       license = [ { fullName = "BSD-like (http://repoze.org/license.html)"; } ];
     };
   };
-  venusian = super.buildPythonPackage {
+  "venusian" = super.buildPythonPackage {
     name = "venusian-1.1.0";
-    buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/38/24/b4b470ab9e0a2e2e9b9030c7735828c8934b4c6b45befd1bb713ec2aeb2d/venusian-1.1.0.tar.gz";
-      md5 = "56bc5e6756e4bda37bcdb94f74a72b8f";
+      url = "https://files.pythonhosted.org/packages/38/24/b4b470ab9e0a2e2e9b9030c7735828c8934b4c6b45befd1bb713ec2aeb2d/venusian-1.1.0.tar.gz";
+      sha256 = "0zapz131686qm0gazwy8bh11vr57pr89jbwbl50s528sqy9f80lr";
     };
     meta = {
       license = [ { fullName = "BSD-derived (http://www.repoze.org/LICENSE.txt)"; } ];
     };
   };
-  waitress = super.buildPythonPackage {
+  "waitress" = super.buildPythonPackage {
     name = "waitress-1.1.0";
-    buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/3c/68/1c10dd5c556872ceebe88483b0436140048d39de83a84a06a8baa8136f4f/waitress-1.1.0.tar.gz";
-      md5 = "0f1eb7fdfdbf2e6d18decbda1733045c";
+      url = "https://files.pythonhosted.org/packages/3c/68/1c10dd5c556872ceebe88483b0436140048d39de83a84a06a8baa8136f4f/waitress-1.1.0.tar.gz";
+      sha256 = "1a85gyji0kajc3p0s1pwwfm06w4wfxjkvvl4rnrz3h164kbd6g6k";
     };
     meta = {
-      license = [ pkgs.lib.licenses.zpt21 ];
+      license = [ pkgs.lib.licenses.zpl21 ];
     };
   };
-  wcwidth = super.buildPythonPackage {
+  "wcwidth" = super.buildPythonPackage {
     name = "wcwidth-0.1.7";
-    buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/55/11/e4a2bb08bb450fdbd42cc709dd40de4ed2c472cf0ccb9e64af22279c5495/wcwidth-0.1.7.tar.gz";
-      md5 = "b3b6a0a08f0c8a34d1de8cf44150a4ad";
+      url = "https://files.pythonhosted.org/packages/55/11/e4a2bb08bb450fdbd42cc709dd40de4ed2c472cf0ccb9e64af22279c5495/wcwidth-0.1.7.tar.gz";
+      sha256 = "0pn6dflzm609m4r3i8ik5ni9ijjbb5fa3vg1n7hn6vkd49r77wrx";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.mit ];
+    };
+  };
+  "webob" = super.buildPythonPackage {
+    name = "webob-1.7.4";
+    doCheck = false;
+    src = fetchurl {
+      url = "https://files.pythonhosted.org/packages/75/34/731e23f52371852dfe7490a61644826ba7fe70fd52a377aaca0f4956ba7f/WebOb-1.7.4.tar.gz";
+      sha256 = "1na01ljg04z40il7vcrn8g29vaw7nvg1xvhk64cr4jys5wcay44d";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
-  wheel = super.buildPythonPackage {
-    name = "wheel-0.29.0";
-    buildInputs = with self; [];
+  "webtest" = super.buildPythonPackage {
+    name = "webtest-2.0.29";
     doCheck = false;
-    propagatedBuildInputs = with self; [];
+    propagatedBuildInputs = [
+      self."six"
+      self."webob"
+      self."waitress"
+      self."beautifulsoup4"
+    ];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/c9/1d/bd19e691fd4cfe908c76c429fe6e4436c9e83583c4414b54f6c85471954a/wheel-0.29.0.tar.gz";
-      md5 = "555a67e4507cedee23a0deb9651e452f";
+      url = "https://files.pythonhosted.org/packages/94/de/8f94738be649997da99c47b104aa3c3984ecec51a1d8153ed09638253d56/WebTest-2.0.29.tar.gz";
+      sha256 = "0bcj1ica5lnmj5zbvk46x28kgphcsgh7sfnwjmn0cr94mhawrg6v";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
-  zope.deprecation = super.buildPythonPackage {
+  "zope.deprecation" = super.buildPythonPackage {
     name = "zope.deprecation-4.3.0";
-    buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [setuptools];
+    propagatedBuildInputs = [
+      self."setuptools"
+    ];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/a1/18/2dc5e6bfe64fdc3b79411b67464c55bb0b43b127051a20f7f492ab767758/zope.deprecation-4.3.0.tar.gz";
-      md5 = "2166b2cb7e0e96a21104e6f8f9b696bb";
+      url = "https://files.pythonhosted.org/packages/a1/18/2dc5e6bfe64fdc3b79411b67464c55bb0b43b127051a20f7f492ab767758/zope.deprecation-4.3.0.tar.gz";
+      sha256 = "095jas41wbxgmw95kwdxqhbc3bgihw2hzj9b3qpdg85apcsf2lkx";
     };
     meta = {
-      license = [ pkgs.lib.licenses.zpt21 ];
+      license = [ pkgs.lib.licenses.zpl21 ];
     };
   };
-  zope.interface = super.buildPythonPackage {
-    name = "zope.interface-4.4.3";
-    buildInputs = with self; [];
+  "zope.interface" = super.buildPythonPackage {
+    name = "zope.interface-4.5.0";
     doCheck = false;
-    propagatedBuildInputs = with self; [setuptools];
+    propagatedBuildInputs = [
+      self."setuptools"
+    ];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/bd/d2/25349ed41f9dcff7b3baf87bd88a4c82396cf6e02f1f42bb68657a3132af/zope.interface-4.4.3.tar.gz";
-      md5 = "8700a4f527c1203b34b10c2b4e7a6912";
+      url = "https://files.pythonhosted.org/packages/ac/8a/657532df378c2cd2a1fe6b12be3b4097521570769d4852ec02c24bd3594e/zope.interface-4.5.0.tar.gz";
+      sha256 = "0k67m60ij06wkg82n15qgyn96waf4pmrkhv0njpkfzpmv5q89hsp";
     };
     meta = {
-      license = [ pkgs.lib.licenses.zpt21 ];
+      license = [ pkgs.lib.licenses.zpl21 ];
     };
   };
 
 ### Test requirements
 
   
 }

pytest.ini

@@ -1,3 +1,8 b''
 [pytest]
-testpaths = ./vcsserver
-addopts = -v
+testpaths = vcsserver
+norecursedirs = vcsserver/hook_utils/hook_templates
+cache_dir = /tmp/.pytest_cache
+
+
+addopts =
+  --pdbcls=IPython.terminal.debugger:TerminalPdb

release.nix

@@ -1,15 +1,16 b''
+# This file defines how to "build" for packaging.
+
 { pkgs ? import <nixpkgs> {}
 , doCheck ? true
 }:
 
 let
-
   vcsserver = import ./default.nix {
     inherit
       doCheck
       pkgs;
   };
 
 in {
   build = vcsserver;
 }

requirements.txt

@@ -1,41 +1,46 b''
-## core
-setuptools==30.1.0
+## dependencies
 
-Beaker==1.9.1
-configobj==5.0.6
+# our custom configobj
+https://code.rhodecode.com/upstream/configobj/archive/a11ff0a0bd4fbda9e3a91267e720f88329efb4a6.tar.gz?md5=9916c524ea11a6c418217af6b28d4b3c#egg=configobj==5.0.6
+dogpile.cache==0.6.6
+dogpile.core==0.4.1
 decorator==4.1.2
 dulwich==0.13.0
-hgsubversion==1.9.0
-hg-evolve==7.0.1
-infrae.cache==1.0.1
-mercurial==4.4.2
-msgpack-python==0.4.8
-pyramid-jinja2==2.7
-Jinja2==2.9.6
-pyramid==1.9.1
+hgsubversion==1.9.2
+hg-evolve==8.0.1
+mako==1.0.7
+markupsafe==1.0.0
+mercurial==4.6.2
+msgpack-python==0.5.6
+
+pastedeploy==1.5.2
+psutil==5.4.6
+pyramid==1.9.2
 pyramid-mako==1.0.2
+
+pygments==2.2.0
+pathlib2==2.3.0
 repoze.lru==0.7
 simplejson==3.11.1
-subprocess32==3.2.7
-
+subprocess32==3.5.1
+setproctitle==1.1.10
 subvertpy==0.10.1
 
 six==1.11.0
 translationstring==1.3
-WebOb==1.7.4
-wheel==0.29.0
+webob==1.7.4
 zope.deprecation==4.3.0
-zope.interface==4.4.3
+zope.interface==4.5.0
 
 ## http servers
-gevent==1.2.2
+gevent==1.3.5
 greenlet==0.4.13
-gunicorn==19.7.1
+gunicorn==19.9.0
 waitress==1.1.0
 
 ## debug
-ipdb==0.10.3
+ipdb==0.11.0
 ipython==5.1.0
 
 ## test related requirements
 -r requirements_test.txt

requirements_test.txt

@@ -1,15 +1,14 b''
 # test related requirements
-pytest==3.2.5
-py==1.5.2
+pytest==3.6.0
+py==1.5.3
 pytest-cov==2.5.1
-pytest-sugar==0.9.0
-pytest-runner==3.0.0
-pytest-catchlog==1.2.2
-pytest-profiling==1.2.11
+pytest-sugar==0.9.1
+pytest-runner==4.2.0
+pytest-profiling==1.3.0
 gprof2dot==2017.9.19
-pytest-timeout==1.2.0
+pytest-timeout==1.2.1
 
 mock==1.0.1
-WebTest==2.0.29
+webtest==2.0.29
 cov-core==1.15.0
 coverage==3.7.1

setup.py

@@ -1,132 +1,139 b''
 # -*- coding: utf-8 -*-
 # RhodeCode VCSServer provides access to different vcs backends via network.
 # Copyright (C) 2014-2017 RodeCode GmbH
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 
 # Import early to make sure things are patched up properly
 from setuptools import setup, find_packages
 
 import os
 import sys
 import pkgutil
 import platform
+import codecs
 
-from pip.download import PipSession
-from pip.req import parse_requirements
+try:  # for pip >= 10
+    from pip._internal.req import parse_requirements
+except ImportError:  # for pip <= 9.0.3
+    from pip.req import parse_requirements
 
-from codecs import open
+try:  # for pip >= 10
+    from pip._internal.download import PipSession
+except ImportError:  # for pip <= 9.0.3
+    from pip.download import PipSession
+
 
 
 if sys.version_info < (2, 7):
     raise Exception('VCSServer requires Python 2.7 or later')
 
 here = os.path.abspath(os.path.dirname(__file__))
 
 # defines current platform
 __platform__ = platform.system()
 __license__ = 'GPL V3'
 __author__ = 'RhodeCode GmbH'
 __url__ = 'https://code.rhodecode.com'
 is_windows = __platform__ in ('Windows',)
 
 
 def _get_requirements(req_filename, exclude=None, extras=None):
     extras = extras or []
     exclude = exclude or []
 
     try:
         parsed = parse_requirements(
             os.path.join(here, req_filename), session=PipSession())
     except TypeError:
         # try pip < 6.0.0, that doesn't support session
         parsed = parse_requirements(os.path.join(here, req_filename))
 
     requirements = []
     for ir in parsed:
         if ir.req and ir.name not in exclude:
             requirements.append(str(ir.req))
     return requirements + extras
 
 
 # requirements extract
 setup_requirements = ['pytest-runner']
 install_requirements = _get_requirements(
     'requirements.txt', exclude=['setuptools'])
 test_requirements = _get_requirements(
     'requirements_test.txt', extras=['configobj'])
 
 
 def get_version():
     version = pkgutil.get_data('vcsserver', 'VERSION')
     return version.strip()
 
 
 # additional files that goes into package itself
 package_data = {
     '': ['*.txt', '*.rst'],
     'configs': ['*.ini'],
     'vcsserver': ['VERSION'],
 }
 
 description = 'Version Control System Server'
 keywords = ' '.join([
     'CLI', 'RhodeCode', 'RhodeCode Enterprise', 'RhodeCode Tools'])
 
 # README/DESCRIPTION generation
 readme_file = 'README.rst'
 changelog_file = 'CHANGES.rst'
 try:
-    long_description = open(readme_file).read() + '\n\n' + \
-        open(changelog_file).read()
+    long_description = codecs.open(readme_file).read() + '\n\n' + \
+                       codecs.open(changelog_file).read()
 except IOError as err:
     sys.stderr.write(
         "[WARNING] Cannot find file specified as long_description (%s)\n "
         "or changelog (%s) skipping that file" % (readme_file, changelog_file))
     long_description = description
 
 
 setup(
     name='rhodecode-vcsserver',
     version=get_version(),
     description=description,
     long_description=long_description,
     keywords=keywords,
     license=__license__,
     author=__author__,
-    author_email='[e-mail]',
+    author_email='[e-mail]',
     url=__url__,
     setup_requires=setup_requirements,
     install_requires=install_requirements,
     tests_require=test_requirements,
     zip_safe=False,
     packages=find_packages(exclude=["docs", "tests*"]),
     package_data=package_data,
     include_package_data=True,
     classifiers=[
         'Development Status :: 6 - Mature',
         'Intended Audience :: Developers',
         'Operating System :: OS Independent',
         'Topic :: Software Development :: Version Control',
         'License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)',
         'Programming Language :: Python :: 2.7',
     ],
     entry_points={
         'console_scripts': [
             'vcsserver=vcsserver.main:main',
         ],
         'paste.app_factory': ['main=vcsserver.http_main:main']
     },
 )

shell.nix

@@ -1,41 +1,67 b''
-{ pkgs ? import <nixpkgs> {}
+# This file contains the adjustments which are desired for a development
+# environment.
+
+{ pkgs ? (import <nixpkgs> {})
+, pythonPackages ? "python27Packages"
 , doCheck ? false
 }:
 
 let
 
   vcsserver = import ./default.nix {
-    inherit pkgs doCheck;
+    inherit
+      pkgs
+      doCheck;
   };
 
   vcs-pythonPackages = vcsserver.pythonPackages;
 
 in vcsserver.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 vcs-pythonPackages; [
       ipdb
     ]);
 
-  # Somewhat snappier setup of the development environment
-  # TODO: think of supporting a stable path again, so that multiple shells
-  #       can share it.
-  postShellHook = ''
-    # Set locale
-    export LC_ALL="en_US.UTF-8"
+  # place to inject some required libs from develop installs
+  propagatedBuildInputs =
+    attrs.propagatedBuildInputs ++
+    [];
+
+
+  # Make sure we execute both hooks
+  shellHook = ''
+    runHook preShellHook
+    runHook postShellHook
+  '';
+
+  preShellHook = ''
+    echo "Entering VCS-Shell"
 
     # Custom prompt to distinguish from other dev envs.
     export PS1="\n\[\033[1;32m\][VCS-shell:\w]$\[\033[0m\] "
 
+    # Set locale
+    export LC_ALL="en_US.UTF-8"
+
+    # Setup a temporary directory.
     tmp_path=$(mktemp -d)
     export PATH="$tmp_path/bin:$PATH"
     export PYTHONPATH="$tmp_path/${vcs-pythonPackages.python.sitePackages}:$PYTHONPATH"
     mkdir -p $tmp_path/${vcs-pythonPackages.python.sitePackages}
+
+    # Develop installation
+    echo "[BEGIN]: develop install of rhodecode-vcsserver"
     python setup.py develop --prefix $tmp_path --allow-hosts ""
   '';
+
+  postShellHook = ''
+
+  '';
+
 })

vcsserver/VERSION

@@ -1,1 +1,1 b''
-4.12.4
  No newline at end of file
+4.13.0
  No newline at end of file

vcsserver/base.py

@@ -1,98 +1,91 b''
 # RhodeCode VCSServer provides access to different vcs backends via network.
 # Copyright (C) 2014-2018 RhodeCode GmbH
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 
 import sys
 import traceback
 import logging
 import urlparse
 
+from vcsserver.lib.rc_cache import region_meta
 log = logging.getLogger(__name__)
 
 
 class RepoFactory(object):
     """
     Utility to create instances of repository
 
     It provides internal caching of the `repo` object based on
     the :term:`call context`.
     """
+    repo_type = None
 
-    def __init__(self, repo_cache):
-        self._cache = repo_cache
+    def __init__(self):
+        self._cache_region = region_meta.dogpile_cache_regions['repo_object']
 
     def _create_config(self, path, config):
         config = {}
         return config
 
     def _create_repo(self, wire, create):
         raise NotImplementedError()
 
     def repo(self, wire, create=False):
         """
         Get a repository instance for the given path.
 
         Uses internally the low level beaker API since the decorators introduce
         significant overhead.
         """
-        def create_new_repo():
+        region = self._cache_region
+        context = wire.get('context', None)
+        repo_path = wire.get('path', '')
+        context_uid = '{}'.format(context)
+        cache = wire.get('cache', True)
+        cache_on = context and cache
+
+        @region.conditional_cache_on_arguments(condition=cache_on)
+        def create_new_repo(_repo_type, _repo_path, _context_uid):
             return self._create_repo(wire, create)
 
-        return self._repo(wire, create_new_repo)
-
-    def _repo(self, wire, createfunc):
-        context = wire.get('context', None)
-        cache = wire.get('cache', True)
-
-        if context and cache:
-            cache_key = (context, wire['path'])
-            log.debug(
-                'FETCH %s@%s repo object from cache. Context: %s',
-                self.__class__.__name__, wire['path'], context)
-            return self._cache.get(key=cache_key, createfunc=createfunc)
-        else:
-            log.debug(
-                'INIT %s@%s repo object based on wire %s. Context: %s',
-                self.__class__.__name__, wire['path'], wire, context)
-            return createfunc()
+        repo = create_new_repo(self.repo_type, repo_path, context_uid)
+        return repo
 
 
 def obfuscate_qs(query_string):
     if query_string is None:
         return None
 
     parsed = []
     for k, v in urlparse.parse_qsl(query_string, keep_blank_values=True):
         if k in ['auth_token', 'api_key']:
             v = "*****"
         parsed.append((k, v))
 
     return '&'.join('{}{}'.format(
         k, '={}'.format(v) if v else '') for k, v in parsed)
 
 
 def raise_from_original(new_type):
     """
     Raise a new exception type with original args and traceback.
     """
     exc_type, exc_value, exc_traceback = sys.exc_info()
 
-    traceback.format_exception(exc_type, exc_value, exc_traceback)
-
     try:
         raise new_type(*exc_value.args), None, exc_traceback
     finally:
         del exc_traceback

vcsserver/exceptions.py

@@ -1,70 +1,116 b''
 # RhodeCode VCSServer provides access to different vcs backends via network.
 # Copyright (C) 2014-2018 RhodeCode GmbH
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 
 """
 Special exception handling over the wire.
 
 Since we cannot assume that our client is able to import our exception classes,
 this module provides a "wrapping" mechanism to raise plain exceptions
 which contain an extra attribute `_vcs_kind` to allow a client to distinguish
 different error conditions.
 """
 
-import functools
-from pyramid.httpexceptions import HTTPLocked
+from pyramid.httpexceptions import HTTPLocked, HTTPForbidden
 
 
-def _make_exception(kind, *args):
+def _make_exception(kind, org_exc, *args):
     """
     Prepares a base `Exception` instance to be sent over the wire.
 
     To give our caller a hint what this is about, it will attach an attribute
     `_vcs_kind` to the exception.
     """
     exc = Exception(*args)
     exc._vcs_kind = kind
+    exc._org_exc = org_exc
     return exc
 
 
-AbortException = functools.partial(_make_exception, 'abort')
+def AbortException(org_exc=None):
+    def _make_exception_wrapper(*args):
+        return _make_exception('abort', org_exc, *args)
+    return _make_exception_wrapper
+
 
-ArchiveException = functools.partial(_make_exception, 'archive')
+def ArchiveException(org_exc=None):
+    def _make_exception_wrapper(*args):
+        return _make_exception('archive', org_exc, *args)
+    return _make_exception_wrapper
+
 
-LookupException = functools.partial(_make_exception, 'lookup')
+def LookupException(org_exc=None):
+    def _make_exception_wrapper(*args):
+        return _make_exception('lookup', org_exc, *args)
+    return _make_exception_wrapper
+
 
-VcsException = functools.partial(_make_exception, 'error')
+def VcsException(org_exc=None):
+    def _make_exception_wrapper(*args):
+        return _make_exception('error', org_exc, *args)
+    return _make_exception_wrapper
+
+
+def RepositoryLockedException(org_exc=None):
+    def _make_exception_wrapper(*args):
+        return _make_exception('repo_locked', org_exc, *args)
+    return _make_exception_wrapper
 
-RepositoryLockedException = functools.partial(_make_exception, 'repo_locked')
+
+def RepositoryBranchProtectedException(org_exc=None):
+    def _make_exception_wrapper(*args):
+        return _make_exception('repo_branch_protected', org_exc, *args)
+    return _make_exception_wrapper
 
-RequirementException = functools.partial(_make_exception, 'requirement')
+
+def RequirementException(org_exc=None):
+    def _make_exception_wrapper(*args):
+        return _make_exception('requirement', org_exc, *args)
+    return _make_exception_wrapper
+
 
-UnhandledException = functools.partial(_make_exception, 'unhandled')
+def UnhandledException(org_exc=None):
+    def _make_exception_wrapper(*args):
+        return _make_exception('unhandled', org_exc, *args)
+    return _make_exception_wrapper
+
 
-URLError = functools.partial(_make_exception, 'url_error')
+def URLError(org_exc=None):
+    def _make_exception_wrapper(*args):
+        return _make_exception('url_error', org_exc, *args)
+    return _make_exception_wrapper
 
-SubrepoMergeException = functools.partial(_make_exception, 'subrepo_merge_error')
+
+def SubrepoMergeException(org_exc=None):
+    def _make_exception_wrapper(*args):
+        return _make_exception('subrepo_merge_error', org_exc, *args)
+    return _make_exception_wrapper
 
 
 class HTTPRepoLocked(HTTPLocked):
     """
     Subclass of HTTPLocked response that allows to set the title and status
     code via constructor arguments.
     """
     def __init__(self, title, status_code=None, **kwargs):
         self.code = status_code or HTTPLocked.code
         self.title = title
         super(HTTPRepoLocked, self).__init__(**kwargs)
+
+
+class HTTPRepoBranchProtected(HTTPForbidden):
+    def __init__(self, *args, **kwargs):
+        super(HTTPForbidden, self).__init__(*args, **kwargs)

vcsserver/git.py

@@ -1,670 +1,675 b''
 # RhodeCode VCSServer provides access to different vcs backends via network.
 # Copyright (C) 2014-2018 RhodeCode GmbH
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 
 import logging
 import os
 import posixpath as vcspath
 import re
 import stat
 import traceback
 import urllib
 import urllib2
 from functools import wraps
 
 from dulwich import index, objects
 from dulwich.client import HttpGitClient, LocalGitClient
 from dulwich.errors import (
     NotGitRepository, ChecksumMismatch, WrongObjectException,
     MissingCommitError, ObjectMissing, HangupException,
     UnexpectedCommandError)
 from dulwich.repo import Repo as DulwichRepo, Tag
 from dulwich.server import update_server_info
 
 from vcsserver import exceptions, settings, subprocessio
 from vcsserver.utils import safe_str
 from vcsserver.base import RepoFactory, obfuscate_qs, raise_from_original
 from vcsserver.hgcompat import (
     hg_url as url_parser, httpbasicauthhandler, httpdigestauthhandler)
 from vcsserver.git_lfs.lib import LFSOidStore
 
 DIR_STAT = stat.S_IFDIR
 FILE_MODE = stat.S_IFMT
 GIT_LINK = objects.S_IFGITLINK
 
 log = logging.getLogger(__name__)
 
 
 def reraise_safe_exceptions(func):
     """Converts Dulwich exceptions to something neutral."""
     @wraps(func)
     def wrapper(*args, **kwargs):
         try:
             return func(*args, **kwargs)
         except (ChecksumMismatch, WrongObjectException, MissingCommitError,
                 ObjectMissing) as e:
-            raise exceptions.LookupException(e.message)
+            raise exceptions.LookupException(e)(e.message)
         except (HangupException, UnexpectedCommandError) as e:
-            raise exceptions.VcsException(e.message)
+            raise exceptions.VcsException(e)(e.message)
         except Exception as e:
             # NOTE(marcink): becuase of how dulwich handles some exceptions
             # (KeyError on empty repos), we cannot track this and catch all
             # exceptions, it's an exceptions from other handlers
             #if not hasattr(e, '_vcs_kind'):
                 #log.exception("Unhandled exception in git remote call")
                 #raise_from_original(exceptions.UnhandledException)
             raise
     return wrapper
 
 
 class Repo(DulwichRepo):
     """
     A wrapper for dulwich Repo class.
 
     Since dulwich is sometimes keeping .idx file descriptors open, it leads to
     "Too many open files" error. We need to close all opened file descriptors
     once the repo object is destroyed.
 
     TODO: mikhail: please check if we need this wrapper after updating dulwich
     to 0.12.0 +
     """
     def __del__(self):
         if hasattr(self, 'object_store'):
             self.close()
 
 
 class GitFactory(RepoFactory):
+    repo_type = 'git'
 
     def _create_repo(self, wire, create):
         repo_path = str_to_dulwich(wire['path'])
         return Repo(repo_path)
 
 
 class GitRemote(object):
 
     def __init__(self, factory):
         self._factory = factory
 
         self._bulk_methods = {
             "author": self.commit_attribute,
             "date": self.get_object_attrs,
             "message": self.commit_attribute,
             "parents": self.commit_attribute,
             "_commit": self.revision,
         }
 
     def _wire_to_config(self, wire):
         if 'config' in wire:
             return dict([(x[0] + '_' + x[1], x[2]) for x in wire['config']])
         return {}
 
     def _assign_ref(self, wire, ref, commit_id):
         repo = self._factory.repo(wire)
         repo[ref] = commit_id
 
     @reraise_safe_exceptions
     def add_object(self, wire, content):
         repo = self._factory.repo(wire)
         blob = objects.Blob()
         blob.set_raw_string(content)
         repo.object_store.add_object(blob)
         return blob.id
 
     @reraise_safe_exceptions
     def assert_correct_path(self, wire):
         path = wire.get('path')
         try:
             self._factory.repo(wire)
         except NotGitRepository as e:
             tb = traceback.format_exc()
             log.debug("Invalid Git path `%s`, tb: %s", path, tb)
             return False
 
         return True
 
     @reraise_safe_exceptions
     def bare(self, wire):
         repo = self._factory.repo(wire)
         return repo.bare
 
     @reraise_safe_exceptions
     def blob_as_pretty_string(self, wire, sha):
         repo = self._factory.repo(wire)
         return repo[sha].as_pretty_string()
 
     @reraise_safe_exceptions
     def blob_raw_length(self, wire, sha):
         repo = self._factory.repo(wire)
         blob = repo[sha]
         return blob.raw_length()
 
     def _parse_lfs_pointer(self, raw_content):
 
         spec_string = 'version https://git-lfs.github.com/spec'
         if raw_content and raw_content.startswith(spec_string):
             pattern = re.compile(r"""
             (?:\n)?
             ^version[ ]https://git-lfs\.github\.com/spec/(?P<spec_ver>v\d+)\n
             ^oid[ ] sha256:(?P<oid_hash>[0-9a-f]{64})\n
             ^size[ ](?P<oid_size>[0-9]+)\n
             (?:\n)?
             """, re.VERBOSE | re.MULTILINE)
             match = pattern.match(raw_content)
             if match:
                 return match.groupdict()
 
         return {}
 
     @reraise_safe_exceptions
     def is_large_file(self, wire, sha):
         repo = self._factory.repo(wire)
         blob = repo[sha]
         return self._parse_lfs_pointer(blob.as_raw_string())
 
     @reraise_safe_exceptions
     def in_largefiles_store(self, wire, oid):
         repo = self._factory.repo(wire)
         conf = self._wire_to_config(wire)
 
         store_location = conf.get('vcs_git_lfs_store_location')
         if store_location:
             repo_name = repo.path
             store = LFSOidStore(
                 oid=oid, repo=repo_name, store_location=store_location)
             return store.has_oid()
 
         return False
 
     @reraise_safe_exceptions
     def store_path(self, wire, oid):
         repo = self._factory.repo(wire)
         conf = self._wire_to_config(wire)
 
         store_location = conf.get('vcs_git_lfs_store_location')
         if store_location:
             repo_name = repo.path
             store = LFSOidStore(
                 oid=oid, repo=repo_name, store_location=store_location)
             return store.oid_path
         raise ValueError('Unable to fetch oid with path {}'.format(oid))
 
     @reraise_safe_exceptions
     def bulk_request(self, wire, rev, pre_load):
         result = {}
         for attr in pre_load:
             try:
                 method = self._bulk_methods[attr]
                 args = [wire, rev]
                 if attr == "date":
                     args.extend(["commit_time", "commit_timezone"])
                 elif attr in ["author", "message", "parents"]:
                     args.append(attr)
                 result[attr] = method(*args)
-            except KeyError:
-                raise exceptions.VcsException(
+            except KeyError as e:
+                raise exceptions.VcsException(e)(
                     "Unknown bulk attribute: %s" % attr)
         return result
 
     def _build_opener(self, url):
         handlers = []
         url_obj = url_parser(url)
         _, authinfo = url_obj.authinfo()
 
         if authinfo:
             # create a password manager
             passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
             passmgr.add_password(*authinfo)
 
             handlers.extend((httpbasicauthhandler(passmgr),
                              httpdigestauthhandler(passmgr)))
 
         return urllib2.build_opener(*handlers)
 
     @reraise_safe_exceptions
     def check_url(self, url, config):
         url_obj = url_parser(url)
         test_uri, _ = url_obj.authinfo()
         url_obj.passwd = '*****' if url_obj.passwd else url_obj.passwd
         url_obj.query = obfuscate_qs(url_obj.query)
         cleaned_uri = str(url_obj)
         log.info("Checking URL for remote cloning/import: %s", cleaned_uri)
 
         if not test_uri.endswith('info/refs'):
             test_uri = test_uri.rstrip('/') + '/info/refs'
 
         o = self._build_opener(url)
         o.addheaders = [('User-Agent', 'git/1.7.8.0')]  # fake some git
 
         q = {"service": 'git-upload-pack'}
         qs = '?%s' % urllib.urlencode(q)
         cu = "%s%s" % (test_uri, qs)
         req = urllib2.Request(cu, None, {})
 
         try:
             log.debug("Trying to open URL %s", cleaned_uri)
             resp = o.open(req)
             if resp.code != 200:
-                raise exceptions.URLError('Return Code is not 200')
+                raise exceptions.URLError()('Return Code is not 200')
         except Exception as e:
             log.warning("URL cannot be opened: %s", cleaned_uri, exc_info=True)
             # means it cannot be cloned
-            raise exceptions.URLError("[%s] org_exc: %s" % (cleaned_uri, e))
+            raise exceptions.URLError(e)("[%s] org_exc: %s" % (cleaned_uri, e))
 
         # now detect if it's proper git repo
         gitdata = resp.read()
         if 'service=git-upload-pack' in gitdata:
             pass
         elif re.findall(r'[0-9a-fA-F]{40}\s+refs', gitdata):
             # old style git can return some other format !
             pass
         else:
-            raise exceptions.URLError(
+            raise exceptions.URLError()(
                 "url [%s] does not look like an git" % (cleaned_uri,))
 
         return True
 
     @reraise_safe_exceptions
     def clone(self, wire, url, deferred, valid_refs, update_after_clone):
         remote_refs = self.fetch(wire, url, apply_refs=False)
         repo = self._factory.repo(wire)
         if isinstance(valid_refs, list):
             valid_refs = tuple(valid_refs)
 
         for k in remote_refs:
             # only parse heads/tags and skip so called deferred tags
             if k.startswith(valid_refs) and not k.endswith(deferred):
                 repo[k] = remote_refs[k]
 
         if update_after_clone:
             # we want to checkout HEAD
             repo["HEAD"] = remote_refs["HEAD"]
             index.build_index_from_tree(repo.path, repo.index_path(),
                                         repo.object_store, repo["HEAD"].tree)
 
     # TODO: this is quite complex, check if that can be simplified
     @reraise_safe_exceptions
     def commit(self, wire, commit_data, branch, commit_tree, updated, removed):
         repo = self._factory.repo(wire)
         object_store = repo.object_store
 
         # Create tree and populates it with blobs
         commit_tree = commit_tree and repo[commit_tree] or objects.Tree()
 
         for node in updated:
             # Compute subdirs if needed
             dirpath, nodename = vcspath.split(node['path'])
             dirnames = map(safe_str, dirpath and dirpath.split('/') or [])
             parent = commit_tree
             ancestors = [('', parent)]
 
             # Tries to dig for the deepest existing tree
             while dirnames:
                 curdir = dirnames.pop(0)
                 try:
                     dir_id = parent[curdir][1]
                 except KeyError:
                     # put curdir back into dirnames and stops
                     dirnames.insert(0, curdir)
                     break
                 else:
                     # If found, updates parent
                     parent = repo[dir_id]
                     ancestors.append((curdir, parent))
             # Now parent is deepest existing tree and we need to create
             # subtrees for dirnames (in reverse order)
             # [this only applies for nodes from added]
             new_trees = []
 
             blob = objects.Blob.from_string(node['content'])
 
             if dirnames:
                 # If there are trees which should be created we need to build
                 # them now (in reverse order)
                 reversed_dirnames = list(reversed(dirnames))
                 curtree = objects.Tree()
                 curtree[node['node_path']] = node['mode'], blob.id
                 new_trees.append(curtree)
                 for dirname in reversed_dirnames[:-1]:
                     newtree = objects.Tree()
                     newtree[dirname] = (DIR_STAT, curtree.id)
                     new_trees.append(newtree)
                     curtree = newtree
                 parent[reversed_dirnames[-1]] = (DIR_STAT, curtree.id)
             else:
                 parent.add(
                     name=node['node_path'], mode=node['mode'], hexsha=blob.id)
 
             new_trees.append(parent)
             # Update ancestors
             reversed_ancestors = reversed(
                 [(a[1], b[1], b[0]) for a, b in zip(ancestors, ancestors[1:])])
             for parent, tree, path in reversed_ancestors:
                 parent[path] = (DIR_STAT, tree.id)
                 object_store.add_object(tree)
 
             object_store.add_object(blob)
             for tree in new_trees:
                 object_store.add_object(tree)
 
         for node_path in removed:
             paths = node_path.split('/')
             tree = commit_tree
             trees = [tree]
             # Traverse deep into the forest...
             for path in paths:
                 try:
                     obj = repo[tree[path][1]]
                     if isinstance(obj, objects.Tree):
                         trees.append(obj)
                         tree = obj
                 except KeyError:
                     break
             # Cut down the blob and all rotten trees on the way back...
             for path, tree in reversed(zip(paths, trees)):
                 del tree[path]
                 if tree:
                     # This tree still has elements - don't remove it or any
                     # of it's parents
                     break
 
         object_store.add_object(commit_tree)
 
         # Create commit
         commit = objects.Commit()
         commit.tree = commit_tree.id
         for k, v in commit_data.iteritems():
             setattr(commit, k, v)
         object_store.add_object(commit)
 
         ref = 'refs/heads/%s' % branch
         repo.refs[ref] = commit.id
 
         return commit.id
 
     @reraise_safe_exceptions
     def fetch(self, wire, url, apply_refs=True, refs=None):
         if url != 'default' and '://' not in url:
             client = LocalGitClient(url)
         else:
             url_obj = url_parser(url)
             o = self._build_opener(url)
             url, _ = url_obj.authinfo()
             client = HttpGitClient(base_url=url, opener=o)
         repo = self._factory.repo(wire)
 
         determine_wants = repo.object_store.determine_wants_all
         if refs:
             def determine_wants_requested(references):
                 return [references[r] for r in references if r in refs]
             determine_wants = determine_wants_requested
 
         try:
             remote_refs = client.fetch(
                 path=url, target=repo, determine_wants=determine_wants)
         except NotGitRepository as e:
             log.warning(
                 'Trying to fetch from "%s" failed, not a Git repository.', url)
             # Exception can contain unicode which we convert
-            raise exceptions.AbortException(repr(e))
+            raise exceptions.AbortException(e)(repr(e))
 
         # mikhail: client.fetch() returns all the remote refs, but fetches only
         # refs filtered by `determine_wants` function. We need to filter result
         # as well
         if refs:
             remote_refs = {k: remote_refs[k] for k in remote_refs if k in refs}
 
         if apply_refs:
             # TODO: johbo: Needs proper test coverage with a git repository
             # that contains a tag object, so that we would end up with
             # a peeled ref at this point.
             PEELED_REF_MARKER = '^{}'
             for k in remote_refs:
                 if k.endswith(PEELED_REF_MARKER):
                     log.info("Skipping peeled reference %s", k)
                     continue
                 repo[k] = remote_refs[k]
 
             if refs:
                 # mikhail: explicitly set the head to the last ref.
                 repo['HEAD'] = remote_refs[refs[-1]]
 
             # TODO: mikhail: should we return remote_refs here to be
             # consistent?
         else:
             return remote_refs
 
     @reraise_safe_exceptions
     def sync_push(self, wire, url, refs=None):
         if self.check_url(url, wire):
             repo = self._factory.repo(wire)
             self.run_git_command(
                 wire, ['push', url, '--mirror'], fail_on_stderr=False,
                 _copts=['-c', 'core.askpass=""'],
                 extra_env={'GIT_TERMINAL_PROMPT': '0'})
 
     @reraise_safe_exceptions
     def get_remote_refs(self, wire, url):
         repo = Repo(url)
         return repo.get_refs()
 
     @reraise_safe_exceptions
     def get_description(self, wire):
         repo = self._factory.repo(wire)
         return repo.get_description()
 
     @reraise_safe_exceptions
     def get_file_history(self, wire, file_path, commit_id, limit):
         repo = self._factory.repo(wire)
         include = [commit_id]
         paths = [file_path]
 
         walker = repo.get_walker(include, paths=paths, max_entries=limit)
         return [x.commit.id for x in walker]
 
     @reraise_safe_exceptions
     def get_missing_revs(self, wire, rev1, rev2, path2):
         repo = self._factory.repo(wire)
         LocalGitClient(thin_packs=False).fetch(path2, repo)
 
         wire_remote = wire.copy()
         wire_remote['path'] = path2
         repo_remote = self._factory.repo(wire_remote)
         LocalGitClient(thin_packs=False).fetch(wire["path"], repo_remote)
 
         revs = [
             x.commit.id
             for x in repo_remote.get_walker(include=[rev2], exclude=[rev1])]
         return revs
 
     @reraise_safe_exceptions
     def get_object(self, wire, sha):
         repo = self._factory.repo(wire)
         obj = repo.get_object(sha)
         commit_id = obj.id
 
         if isinstance(obj, Tag):
             commit_id = obj.object[1]
 
         return {
             'id': obj.id,
             'type': obj.type_name,
             'commit_id': commit_id
         }
 
     @reraise_safe_exceptions
     def get_object_attrs(self, wire, sha, *attrs):
         repo = self._factory.repo(wire)
         obj = repo.get_object(sha)
         return list(getattr(obj, a) for a in attrs)
 
     @reraise_safe_exceptions
     def get_refs(self, wire):
         repo = self._factory.repo(wire)
         result = {}
         for ref, sha in repo.refs.as_dict().items():
             peeled_sha = repo.get_peeled(ref)
             result[ref] = peeled_sha
         return result
 
     @reraise_safe_exceptions
     def get_refs_path(self, wire):
         repo = self._factory.repo(wire)
         return repo.refs.path
 
     @reraise_safe_exceptions
-    def head(self, wire):
+    def head(self, wire, show_exc=True):
         repo = self._factory.repo(wire)
-        return repo.head()
+        try:
+            return repo.head()
+        except Exception:
+            if show_exc:
+                raise
 
     @reraise_safe_exceptions
     def init(self, wire):
         repo_path = str_to_dulwich(wire['path'])
         self.repo = Repo.init(repo_path)
 
     @reraise_safe_exceptions
     def init_bare(self, wire):
         repo_path = str_to_dulwich(wire['path'])
         self.repo = Repo.init_bare(repo_path)
 
     @reraise_safe_exceptions
     def revision(self, wire, rev):
         repo = self._factory.repo(wire)
         obj = repo[rev]
         obj_data = {
             'id': obj.id,
         }
         try:
             obj_data['tree'] = obj.tree
         except AttributeError:
             pass
         return obj_data
 
     @reraise_safe_exceptions
     def commit_attribute(self, wire, rev, attr):
         repo = self._factory.repo(wire)
         obj = repo[rev]
         return getattr(obj, attr)
 
     @reraise_safe_exceptions
     def set_refs(self, wire, key, value):
         repo = self._factory.repo(wire)
         repo.refs[key] = value
 
     @reraise_safe_exceptions
     def remove_ref(self, wire, key):
         repo = self._factory.repo(wire)
         del repo.refs[key]
 
     @reraise_safe_exceptions
     def tree_changes(self, wire, source_id, target_id):
         repo = self._factory.repo(wire)
         source = repo[source_id].tree if source_id else None
         target = repo[target_id].tree
         result = repo.object_store.tree_changes(source, target)
         return list(result)
 
     @reraise_safe_exceptions
     def tree_items(self, wire, tree_id):
         repo = self._factory.repo(wire)
         tree = repo[tree_id]
 
         result = []
         for item in tree.iteritems():
             item_sha = item.sha
             item_mode = item.mode
 
             if FILE_MODE(item_mode) == GIT_LINK:
                 item_type = "link"
             else:
                 item_type = repo[item_sha].type_name
 
             result.append((item.path, item_mode, item_sha, item_type))
         return result
 
     @reraise_safe_exceptions
     def update_server_info(self, wire):
         repo = self._factory.repo(wire)
         update_server_info(repo)
 
     @reraise_safe_exceptions
     def discover_git_version(self):
         stdout, _ = self.run_git_command(
             {}, ['--version'], _bare=True, _safe=True)
         prefix = 'git version'
         if stdout.startswith(prefix):
             stdout = stdout[len(prefix):]
         return stdout.strip()
 
     @reraise_safe_exceptions
     def run_git_command(self, wire, cmd, **opts):
         path = wire.get('path', None)
 
         if path and os.path.isdir(path):
             opts['cwd'] = path
 
         if '_bare' in opts:
             _copts = []
             del opts['_bare']
         else:
             _copts = ['-c', 'core.quotepath=false', ]
         safe_call = False
         if '_safe' in opts:
             # no exc on failure
             del opts['_safe']
             safe_call = True
 
         if '_copts' in opts:
             _copts.extend(opts['_copts'] or [])
             del opts['_copts']
 
         gitenv = os.environ.copy()
         gitenv.update(opts.pop('extra_env', {}))
         # need to clean fix GIT_DIR !
         if 'GIT_DIR' in gitenv:
             del gitenv['GIT_DIR']
         gitenv['GIT_CONFIG_NOGLOBAL'] = '1'
         gitenv['GIT_DISCOVERY_ACROSS_FILESYSTEM'] = '1'
 
         cmd = [settings.GIT_EXECUTABLE] + _copts + cmd
 
         try:
             _opts = {'env': gitenv, 'shell': False}
             _opts.update(opts)
             p = subprocessio.SubprocessIOChunker(cmd, **_opts)
 
             return ''.join(p), ''.join(p.error)
         except (EnvironmentError, OSError) as err:
             cmd = ' '.join(cmd)  # human friendly CMD
             tb_err = ("Couldn't run git command (%s).\n"
                       "Original error was:%s\n" % (cmd, err))
             log.exception(tb_err)
             if safe_call:
                 return '', err
             else:
-                raise exceptions.VcsException(tb_err)
+                raise exceptions.VcsException()(tb_err)
 
     @reraise_safe_exceptions
     def install_hooks(self, wire, force=False):
         from vcsserver.hook_utils import install_git_hooks
         repo = self._factory.repo(wire)
         return install_git_hooks(repo.path, repo.bare, force_create=force)
 
 
 def str_to_dulwich(value):
     """
     Dulwich 0.10.1a requires `unicode` objects to be passed in.
     """
     return value.decode(settings.WIRE_ENCODING)

vcsserver/hg.py

@@ -1,776 +1,793 b''
 # RhodeCode VCSServer provides access to different vcs backends via network.
 # Copyright (C) 2014-2018 RhodeCode GmbH
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 
 import io
 import logging
 import stat
 import urllib
 import urllib2
 
 from hgext import largefiles, rebase
 from hgext.strip import strip as hgext_strip
 from mercurial import commands
 from mercurial import unionrepo
 from mercurial import verify
 
 from vcsserver import exceptions
 from vcsserver.base import RepoFactory, obfuscate_qs, raise_from_original
 from vcsserver.hgcompat import (
     archival, bin, clone, config as hgconfig, diffopts, hex,
     hg_url as url_parser, httpbasicauthhandler, httpdigestauthhandler,
-    httppeer, localrepository, match, memctx, exchange, memfilectx, nullrev,
+    makepeer, localrepository, match, memctx, exchange, memfilectx, nullrev,
     patch, peer, revrange, ui, hg_tag, Abort, LookupError, RepoError,
     RepoLookupError, InterventionRequired, RequirementError)
 
 log = logging.getLogger(__name__)
 
 
 def make_ui_from_config(repo_config):
     baseui = ui.ui()
 
     # clean the baseui object
     baseui._ocfg = hgconfig.config()
     baseui._ucfg = hgconfig.config()
     baseui._tcfg = hgconfig.config()
 
     for section, option, value in repo_config:
         baseui.setconfig(section, option, value)
 
     # make our hgweb quiet so it doesn't print output
     baseui.setconfig('ui', 'quiet', 'true')
 
     baseui.setconfig('ui', 'paginate', 'never')
     # force mercurial to only use 1 thread, otherwise it may try to set a
     # signal in a non-main thread, thus generating a ValueError.
     baseui.setconfig('worker', 'numcpus', 1)
 
     # If there is no config for the largefiles extension, we explicitly disable
     # it here. This overrides settings from repositories hgrc file. Recent
     # mercurial versions enable largefiles in hgrc on clone from largefile
     # repo.
     if not baseui.hasconfig('extensions', 'largefiles'):
         log.debug('Explicitly disable largefiles extension for repo.')
         baseui.setconfig('extensions', 'largefiles', '!')
 
     return baseui
 
 
 def reraise_safe_exceptions(func):
     """Decorator for converting mercurial exceptions to something neutral."""
     def wrapper(*args, **kwargs):
         try:
             return func(*args, **kwargs)
-        except (Abort, InterventionRequired):
-            raise_from_original(exceptions.AbortException)
-        except RepoLookupError:
-            raise_from_original(exceptions.LookupException)
-        except RequirementError:
-            raise_from_original(exceptions.RequirementException)
-        except RepoError:
-            raise_from_original(exceptions.VcsException)
-        except LookupError:
-            raise_from_original(exceptions.LookupException)
+        except (Abort, InterventionRequired) as e:
+            raise_from_original(exceptions.AbortException(e))
+        except RepoLookupError as e:
+            raise_from_original(exceptions.LookupException(e))
+        except RequirementError as e:
+            raise_from_original(exceptions.RequirementException(e))
+        except RepoError as e:
+            raise_from_original(exceptions.VcsException(e))
+        except LookupError as e:
+            raise_from_original(exceptions.LookupException(e))
         except Exception as e:
             if not hasattr(e, '_vcs_kind'):
                 log.exception("Unhandled exception in hg remote call")
-                raise_from_original(exceptions.UnhandledException)
+                raise_from_original(exceptions.UnhandledException(e))
+
             raise
     return wrapper
 
 
 class MercurialFactory(RepoFactory):
+    repo_type = 'hg'
 
     def _create_config(self, config, hooks=True):
         if not hooks:
             hooks_to_clean = frozenset((
                 'changegroup.repo_size', 'preoutgoing.pre_pull',
                 'outgoing.pull_logger', 'prechangegroup.pre_push'))
             new_config = []
             for section, option, value in config:
                 if section == 'hooks' and option in hooks_to_clean:
                     continue
                 new_config.append((section, option, value))
             config = new_config
 
         baseui = make_ui_from_config(config)
         return baseui
 
     def _create_repo(self, wire, create):
         baseui = self._create_config(wire["config"])
         return localrepository(baseui, wire["path"], create)
 
 
 class HgRemote(object):
 
     def __init__(self, factory):
         self._factory = factory
 
         self._bulk_methods = {
             "affected_files": self.ctx_files,
             "author": self.ctx_user,
             "branch": self.ctx_branch,
             "children": self.ctx_children,
             "date": self.ctx_date,
             "message": self.ctx_description,
             "parents": self.ctx_parents,
             "status": self.ctx_status,
             "obsolete": self.ctx_obsolete,
             "phase": self.ctx_phase,
             "hidden": self.ctx_hidden,
             "_file_paths": self.ctx_list,
         }
 
     @reraise_safe_exceptions
     def discover_hg_version(self):
         from mercurial import util
         return util.version()
 
     @reraise_safe_exceptions
     def archive_repo(self, archive_path, mtime, file_info, kind):
         if kind == "tgz":
             archiver = archival.tarit(archive_path, mtime, "gz")
         elif kind == "tbz2":
             archiver = archival.tarit(archive_path, mtime, "bz2")
         elif kind == 'zip':
             archiver = archival.zipit(archive_path, mtime)
         else:
-            raise exceptions.ArchiveException(
+            raise exceptions.ArchiveException()(
                 'Remote does not support: "%s".' % kind)
 
         for f_path, f_mode, f_is_link, f_content in file_info:
             archiver.addfile(f_path, f_mode, f_is_link, f_content)
         archiver.done()
 
     @reraise_safe_exceptions
     def bookmarks(self, wire):
         repo = self._factory.repo(wire)
         return dict(repo._bookmarks)
 
     @reraise_safe_exceptions
     def branches(self, wire, normal, closed):
         repo = self._factory.repo(wire)
         iter_branches = repo.branchmap().iterbranches()
         bt = {}
         for branch_name, _heads, tip, is_closed in iter_branches:
             if normal and not is_closed:
                 bt[branch_name] = tip
             if closed and is_closed:
                 bt[branch_name] = tip
 
         return bt
 
     @reraise_safe_exceptions
     def bulk_request(self, wire, rev, pre_load):
         result = {}
         for attr in pre_load:
             try:
                 method = self._bulk_methods[attr]
                 result[attr] = method(wire, rev)
-            except KeyError:
-                raise exceptions.VcsException(
+            except KeyError as e:
+                raise exceptions.VcsException(e)(
                     'Unknown bulk attribute: "%s"' % attr)
         return result
 
     @reraise_safe_exceptions
     def clone(self, wire, source, dest, update_after_clone=False, hooks=True):
         baseui = self._factory._create_config(wire["config"], hooks=hooks)
         clone(baseui, source, dest, noupdate=not update_after_clone)
 
     @reraise_safe_exceptions
     def commitctx(
             self, wire, message, parents, commit_time, commit_timezone,
             user, files, extra, removed, updated):
 
         def _filectxfn(_repo, memctx, path):
             """
             Marks given path as added/changed/removed in a given _repo. This is
             for internal mercurial commit function.
             """
 
             # check if this path is removed
             if path in removed:
                 # returning None is a way to mark node for removal
                 return None
 
             # check if this path is added
             for node in updated:
                 if node['path'] == path:
                     return memfilectx(
                         _repo,
+                        changectx=memctx,
                         path=node['path'],
                         data=node['content'],
                         islink=False,
                         isexec=bool(node['mode'] & stat.S_IXUSR),
-                        copied=False,
-                        memctx=memctx)
+                        copied=False)
 
-            raise exceptions.AbortException(
+            raise exceptions.AbortException()(
                 "Given path haven't been marked as added, "
                 "changed or removed (%s)" % path)
 
         repo = self._factory.repo(wire)
 
         commit_ctx = memctx(
             repo=repo,
             parents=parents,
             text=message,
             files=files,
             filectxfn=_filectxfn,
             user=user,
             date=(commit_time, commit_timezone),
             extra=extra)
 
         n = repo.commitctx(commit_ctx)
         new_id = hex(n)
 
         return new_id
 
     @reraise_safe_exceptions
     def ctx_branch(self, wire, revision):
         repo = self._factory.repo(wire)
         ctx = repo[revision]
         return ctx.branch()
 
     @reraise_safe_exceptions
     def ctx_children(self, wire, revision):
         repo = self._factory.repo(wire)
         ctx = repo[revision]
         return [child.rev() for child in ctx.children()]
 
     @reraise_safe_exceptions
     def ctx_date(self, wire, revision):
         repo = self._factory.repo(wire)
         ctx = repo[revision]
         return ctx.date()
 
     @reraise_safe_exceptions
     def ctx_description(self, wire, revision):
         repo = self._factory.repo(wire)
         ctx = repo[revision]
         return ctx.description()
 
     @reraise_safe_exceptions
     def ctx_diff(
             self, wire, revision, git=True, ignore_whitespace=True, context=3):
         repo = self._factory.repo(wire)
         ctx = repo[revision]
         result = ctx.diff(
             git=git, ignore_whitespace=ignore_whitespace, context=context)
         return list(result)
 
     @reraise_safe_exceptions
     def ctx_files(self, wire, revision):
         repo = self._factory.repo(wire)
         ctx = repo[revision]
         return ctx.files()
 
     @reraise_safe_exceptions
     def ctx_list(self, path, revision):
         repo = self._factory.repo(path)
         ctx = repo[revision]
         return list(ctx)
 
     @reraise_safe_exceptions
     def ctx_parents(self, wire, revision):
         repo = self._factory.repo(wire)
         ctx = repo[revision]
         return [parent.rev() for parent in ctx.parents()]
 
     @reraise_safe_exceptions
     def ctx_phase(self, wire, revision):
         repo = self._factory.repo(wire)
         ctx = repo[revision]
         # public=0, draft=1, secret=3
         return ctx.phase()
 
     @reraise_safe_exceptions
     def ctx_obsolete(self, wire, revision):
         repo = self._factory.repo(wire)
         ctx = repo[revision]
         return ctx.obsolete()
 
     @reraise_safe_exceptions
     def ctx_hidden(self, wire, revision):
         repo = self._factory.repo(wire)
         ctx = repo[revision]
         return ctx.hidden()
 
     @reraise_safe_exceptions
     def ctx_substate(self, wire, revision):
         repo = self._factory.repo(wire)
         ctx = repo[revision]
         return ctx.substate
 
     @reraise_safe_exceptions
     def ctx_status(self, wire, revision):
         repo = self._factory.repo(wire)
         ctx = repo[revision]
         status = repo[ctx.p1().node()].status(other=ctx.node())
         # object of status (odd, custom named tuple in mercurial) is not
         # correctly serializable, we make it a list, as the underling
         # API expects this to be a list
         return list(status)
 
     @reraise_safe_exceptions
     def ctx_user(self, wire, revision):
         repo = self._factory.repo(wire)
         ctx = repo[revision]
         return ctx.user()
 
     @reraise_safe_exceptions
     def check_url(self, url, config):
         _proto = None
         if '+' in url[:url.find('://')]:
             _proto = url[0:url.find('+')]
             url = url[url.find('+') + 1:]
         handlers = []
         url_obj = url_parser(url)
         test_uri, authinfo = url_obj.authinfo()
         url_obj.passwd = '*****' if url_obj.passwd else url_obj.passwd
         url_obj.query = obfuscate_qs(url_obj.query)
 
         cleaned_uri = str(url_obj)
         log.info("Checking URL for remote cloning/import: %s", cleaned_uri)
 
         if authinfo:
             # create a password manager
             passmgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
             passmgr.add_password(*authinfo)
 
             handlers.extend((httpbasicauthhandler(passmgr),
                              httpdigestauthhandler(passmgr)))
 
         o = urllib2.build_opener(*handlers)
         o.addheaders = [('Content-Type', 'application/mercurial-0.1'),
                         ('Accept', 'application/mercurial-0.1')]
 
         q = {"cmd": 'between'}
         q.update({'pairs': "%s-%s" % ('0' * 40, '0' * 40)})
         qs = '?%s' % urllib.urlencode(q)
         cu = "%s%s" % (test_uri, qs)
         req = urllib2.Request(cu, None, {})
 
         try:
             log.debug("Trying to open URL %s", cleaned_uri)
             resp = o.open(req)
             if resp.code != 200:
-                raise exceptions.URLError('Return Code is not 200')
+                raise exceptions.URLError()('Return Code is not 200')
         except Exception as e:
             log.warning("URL cannot be opened: %s", cleaned_uri, exc_info=True)
             # means it cannot be cloned
-            raise exceptions.URLError("[%s] org_exc: %s" % (cleaned_uri, e))
+            raise exceptions.URLError(e)("[%s] org_exc: %s" % (cleaned_uri, e))
 
         # now check if it's a proper hg repo, but don't do it for svn
         try:
             if _proto == 'svn':
                 pass
             else:
                 # check for pure hg repos
                 log.debug(
                     "Verifying if URL is a Mercurial repository: %s",
                     cleaned_uri)
-                httppeer(make_ui_from_config(config), url).lookup('tip')
+                ui = make_ui_from_config(config)
+                peer_checker = makepeer(ui, url)
+                peer_checker.lookup('tip')
         except Exception as e:
             log.warning("URL is not a valid Mercurial repository: %s",
                         cleaned_uri)
-            raise exceptions.URLError(
+            raise exceptions.URLError(e)(
                 "url [%s] does not look like an hg repo org_exc: %s"
                 % (cleaned_uri, e))
 
         log.info("URL is a valid Mercurial repository: %s", cleaned_uri)
         return True
 
     @reraise_safe_exceptions
     def diff(
             self, wire, rev1, rev2, file_filter, opt_git, opt_ignorews,
             context):
         repo = self._factory.repo(wire)
 
         if file_filter:
             match_filter = match(file_filter[0], '', [file_filter[1]])
         else:
             match_filter = file_filter
         opts = diffopts(git=opt_git, ignorews=opt_ignorews, context=context)
 
         try:
             return "".join(patch.diff(
                 repo, node1=rev1, node2=rev2, match=match_filter, opts=opts))
-        except RepoLookupError:
-            raise exceptions.LookupException()
+        except RepoLookupError as e:
+            raise exceptions.LookupException(e)()
 
     @reraise_safe_exceptions
     def file_history(self, wire, revision, path, limit):
         repo = self._factory.repo(wire)
 
         ctx = repo[revision]
         fctx = ctx.filectx(path)
 
         def history_iter():
             limit_rev = fctx.rev()
             for obj in reversed(list(fctx.filelog())):
                 obj = fctx.filectx(obj)
                 if limit_rev >= obj.rev():
                     yield obj
 
         history = []
         for cnt, obj in enumerate(history_iter()):
             if limit and cnt >= limit:
                 break
             history.append(hex(obj.node()))
 
         return [x for x in history]
 
     @reraise_safe_exceptions
     def file_history_untill(self, wire, revision, path, limit):
         repo = self._factory.repo(wire)
         ctx = repo[revision]
         fctx = ctx.filectx(path)
 
         file_log = list(fctx.filelog())
         if limit:
             # Limit to the last n items
             file_log = file_log[-limit:]
 
         return [hex(fctx.filectx(cs).node()) for cs in reversed(file_log)]
 
     @reraise_safe_exceptions
     def fctx_annotate(self, wire, revision, path):
         repo = self._factory.repo(wire)
         ctx = repo[revision]
         fctx = ctx.filectx(path)
 
         result = []
-        for i, (a_line, content) in enumerate(fctx.annotate()):
-            ln_no = i + 1
-            sha = hex(a_line.fctx.node())
+        for i, annotate_obj in enumerate(fctx.annotate(), 1):
+            ln_no = i
+            sha = hex(annotate_obj.fctx.node())
+            content = annotate_obj.text
             result.append((ln_no, sha, content))
         return result
 
     @reraise_safe_exceptions
     def fctx_data(self, wire, revision, path):
         repo = self._factory.repo(wire)
         ctx = repo[revision]
         fctx = ctx.filectx(path)
         return fctx.data()
 
     @reraise_safe_exceptions
     def fctx_flags(self, wire, revision, path):
         repo = self._factory.repo(wire)
         ctx = repo[revision]
         fctx = ctx.filectx(path)
         return fctx.flags()
 
     @reraise_safe_exceptions
     def fctx_size(self, wire, revision, path):
         repo = self._factory.repo(wire)
         ctx = repo[revision]
         fctx = ctx.filectx(path)
         return fctx.size()
 
     @reraise_safe_exceptions
     def get_all_commit_ids(self, wire, name):
         repo = self._factory.repo(wire)
         revs = repo.filtered(name).changelog.index
         return map(lambda x: hex(x[7]), revs)[:-1]
 
     @reraise_safe_exceptions
     def get_config_value(self, wire, section, name, untrusted=False):
         repo = self._factory.repo(wire)
         return repo.ui.config(section, name, untrusted=untrusted)
 
     @reraise_safe_exceptions
     def get_config_bool(self, wire, section, name, untrusted=False):
         repo = self._factory.repo(wire)
         return repo.ui.configbool(section, name, untrusted=untrusted)
 
     @reraise_safe_exceptions
     def get_config_list(self, wire, section, name, untrusted=False):
         repo = self._factory.repo(wire)
         return repo.ui.configlist(section, name, untrusted=untrusted)
 
     @reraise_safe_exceptions
     def is_large_file(self, wire, path):
         return largefiles.lfutil.isstandin(path)
 
     @reraise_safe_exceptions
     def in_largefiles_store(self, wire, sha):
         repo = self._factory.repo(wire)
         return largefiles.lfutil.instore(repo, sha)
 
     @reraise_safe_exceptions
     def in_user_cache(self, wire, sha):
         repo = self._factory.repo(wire)
         return largefiles.lfutil.inusercache(repo.ui, sha)
 
     @reraise_safe_exceptions
     def store_path(self, wire, sha):
         repo = self._factory.repo(wire)
         return largefiles.lfutil.storepath(repo, sha)
 
     @reraise_safe_exceptions
     def link(self, wire, sha, path):
         repo = self._factory.repo(wire)
         largefiles.lfutil.link(
             largefiles.lfutil.usercachepath(repo.ui, sha), path)
 
     @reraise_safe_exceptions
     def localrepository(self, wire, create=False):
         self._factory.repo(wire, create=create)
 
     @reraise_safe_exceptions
     def lookup(self, wire, revision, both):
-        # TODO Paris: Ugly hack to "deserialize" long for msgpack
-        if isinstance(revision, float):
-            revision = long(revision)
+
         repo = self._factory.repo(wire)
+
+        if isinstance(revision, int):
+            # NOTE(marcink):
+            # since Mercurial doesn't support indexes properly
+            # we need to shift accordingly by one to get proper index, e.g
+            # repo[-1] => repo[-2]
+            # repo[0]  => repo[-1]
+            # repo[1]  => repo[2] we also never call repo[0] because
+            # it's actually second commit
+            if revision <= 0:
+                revision = revision + -1
+            else:
+                revision = revision + 1
+
         try:
             ctx = repo[revision]
-        except RepoLookupError:
-            raise exceptions.LookupException(revision)
+        except RepoLookupError as e:
+            raise exceptions.LookupException(e)(revision)
         except LookupError as e:
-            raise exceptions.LookupException(e.name)
+            raise exceptions.LookupException(e)(e.name)
 
         if not both:
             return ctx.hex()
 
         ctx = repo[ctx.hex()]
         return ctx.hex(), ctx.rev()
 
     @reraise_safe_exceptions
     def pull(self, wire, url, commit_ids=None):
         repo = self._factory.repo(wire)
         # Disable any prompts for this repo
         repo.ui.setconfig('ui', 'interactive', 'off', '-y')
 
         remote = peer(repo, {}, url)
         # Disable any prompts for this remote
         remote.ui.setconfig('ui', 'interactive', 'off', '-y')
 
         if commit_ids:
             commit_ids = [bin(commit_id) for commit_id in commit_ids]
 
         return exchange.pull(
             repo, remote, heads=commit_ids, force=None).cgresult
 
     @reraise_safe_exceptions
     def sync_push(self, wire, url):
         if self.check_url(url, wire['config']):
             repo = self._factory.repo(wire)
 
             # Disable any prompts for this repo
             repo.ui.setconfig('ui', 'interactive', 'off', '-y')
 
             bookmarks = dict(repo._bookmarks).keys()
             remote = peer(repo, {}, url)
             # Disable any prompts for this remote
             remote.ui.setconfig('ui', 'interactive', 'off', '-y')
 
             return exchange.push(
                 repo, remote, newbranch=True, bookmarks=bookmarks).cgresult
 
     @reraise_safe_exceptions
     def revision(self, wire, rev):
         repo = self._factory.repo(wire)
         ctx = repo[rev]
         return ctx.rev()
 
     @reraise_safe_exceptions
     def rev_range(self, wire, filter):
         repo = self._factory.repo(wire)
         revisions = [rev for rev in revrange(repo, filter)]
         return revisions
 
     @reraise_safe_exceptions
     def rev_range_hash(self, wire, node):
         repo = self._factory.repo(wire)
 
         def get_revs(repo, rev_opt):
             if rev_opt:
                 revs = revrange(repo, rev_opt)
                 if len(revs) == 0:
                     return (nullrev, nullrev)
                 return max(revs), min(revs)
             else:
                 return len(repo) - 1, 0
 
         stop, start = get_revs(repo, [node + ':'])
         revs = [hex(repo[r].node()) for r in xrange(start, stop + 1)]
         return revs
 
     @reraise_safe_exceptions
     def revs_from_revspec(self, wire, rev_spec, *args, **kwargs):
         other_path = kwargs.pop('other_path', None)
 
         # case when we want to compare two independent repositories
         if other_path and other_path != wire["path"]:
             baseui = self._factory._create_config(wire["config"])
             repo = unionrepo.unionrepository(baseui, other_path, wire["path"])
         else:
             repo = self._factory.repo(wire)
         return list(repo.revs(rev_spec, *args))
 
     @reraise_safe_exceptions
     def strip(self, wire, revision, update, backup):
         repo = self._factory.repo(wire)
         ctx = repo[revision]
         hgext_strip(
             repo.baseui, repo, ctx.node(), update=update, backup=backup)
 
     @reraise_safe_exceptions
     def verify(self, wire,):
         repo = self._factory.repo(wire)
         baseui = self._factory._create_config(wire['config'])
         baseui.setconfig('ui', 'quiet', 'false')
         output = io.BytesIO()
 
         def write(data, **unused_kwargs):
             output.write(data)
         baseui.write = write
 
         repo.ui = baseui
         verify.verify(repo)
         return output.getvalue()
 
     @reraise_safe_exceptions
     def tag(self, wire, name, revision, message, local, user,
             tag_time, tag_timezone):
         repo = self._factory.repo(wire)
         ctx = repo[revision]
         node = ctx.node()
 
         date = (tag_time, tag_timezone)
         try:
             hg_tag.tag(repo, name, node, message, local, user, date)
         except Abort as e:
             log.exception("Tag operation aborted")
             # Exception can contain unicode which we convert
-            raise exceptions.AbortException(repr(e))
+            raise exceptions.AbortException(e)(repr(e))
 
     @reraise_safe_exceptions
     def tags(self, wire):
         repo = self._factory.repo(wire)
         return repo.tags()
 
     @reraise_safe_exceptions
     def update(self, wire, node=None, clean=False):
         repo = self._factory.repo(wire)
         baseui = self._factory._create_config(wire['config'])
         commands.update(baseui, repo, node=node, clean=clean)
 
     @reraise_safe_exceptions
     def identify(self, wire):
         repo = self._factory.repo(wire)
         baseui = self._factory._create_config(wire['config'])
         output = io.BytesIO()
         baseui.write = output.write
         # This is required to get a full node id
         baseui.debugflag = True
         commands.identify(baseui, repo, id=True)
 
         return output.getvalue()
 
     @reraise_safe_exceptions
     def pull_cmd(self, wire, source, bookmark=None, branch=None, revision=None,
                  hooks=True):
         repo = self._factory.repo(wire)
         baseui = self._factory._create_config(wire['config'], hooks=hooks)
 
         # Mercurial internally has a lot of logic that checks ONLY if
         # option is defined, we just pass those if they are defined then
         opts = {}
         if bookmark:
             opts['bookmark'] = bookmark
         if branch:
             opts['branch'] = branch
         if revision:
             opts['rev'] = revision
 
         commands.pull(baseui, repo, source, **opts)
 
     @reraise_safe_exceptions
     def heads(self, wire, branch=None):
         repo = self._factory.repo(wire)
         baseui = self._factory._create_config(wire['config'])
         output = io.BytesIO()
 
         def write(data, **unused_kwargs):
             output.write(data)
 
         baseui.write = write
         if branch:
             args = [branch]
         else:
             args = []
         commands.heads(baseui, repo, template='{node} ', *args)
 
         return output.getvalue()
 
     @reraise_safe_exceptions
     def ancestor(self, wire, revision1, revision2):
         repo = self._factory.repo(wire)
         changelog = repo.changelog
         lookup = repo.lookup
         a = changelog.ancestor(lookup(revision1), lookup(revision2))
         return hex(a)
 
     @reraise_safe_exceptions
     def push(self, wire, revisions, dest_path, hooks=True,
              push_branches=False):
         repo = self._factory.repo(wire)
         baseui = self._factory._create_config(wire['config'], hooks=hooks)
         commands.push(baseui, repo, dest=dest_path, rev=revisions,
                       new_branch=push_branches)
 
     @reraise_safe_exceptions
     def merge(self, wire, revision):
         repo = self._factory.repo(wire)
         baseui = self._factory._create_config(wire['config'])
         repo.ui.setconfig('ui', 'merge', 'internal:dump')
 
         # In case of sub repositories are used mercurial prompts the user in
         # case of merge conflicts or different sub repository sources. By
         # setting the interactive flag to `False` mercurial doesn't prompt the
         # used but instead uses a default value.
         repo.ui.setconfig('ui', 'interactive', False)
 
         commands.merge(baseui, repo, rev=revision)
 
     @reraise_safe_exceptions
     def commit(self, wire, message, username, close_branch=False):
         repo = self._factory.repo(wire)
         baseui = self._factory._create_config(wire['config'])
         repo.ui.setconfig('ui', 'username', username)
         commands.commit(baseui, repo, message=message, close_branch=close_branch)
 
     @reraise_safe_exceptions
     def rebase(self, wire, source=None, dest=None, abort=False):
         repo = self._factory.repo(wire)
         baseui = self._factory._create_config(wire['config'])
         repo.ui.setconfig('ui', 'merge', 'internal:dump')
         rebase.rebase(
             baseui, repo, base=source, dest=dest, abort=abort, keep=not abort)
 
     @reraise_safe_exceptions
     def bookmark(self, wire, bookmark, revision=None):
         repo = self._factory.repo(wire)
         baseui = self._factory._create_config(wire['config'])
         commands.bookmark(baseui, repo, bookmark, rev=revision, force=True)
 
     @reraise_safe_exceptions
     def install_hooks(self, wire, force=False):
         # we don't need any special hooks for Mercurial
         pass

vcsserver/hgcompat.py

@@ -1,63 +1,63 b''
 # RhodeCode VCSServer provides access to different vcs backends via network.
 # Copyright (C) 2014-2018 RhodeCode GmbH
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 
 """
 Mercurial libs compatibility
 """
 
 import mercurial
 from mercurial import demandimport
 # patch demandimport, due to bug in mercurial when it always triggers
 # demandimport.enable()
 demandimport.enable = lambda *args, **kwargs: 1
 
 from mercurial import ui
 from mercurial import patch
 from mercurial import config
 from mercurial import extensions
 from mercurial import scmutil
 from mercurial import archival
 from mercurial import discovery
 from mercurial import unionrepo
 from mercurial import localrepo
 from mercurial import merge as hg_merge
 from mercurial import subrepo
 from mercurial import tags as hg_tag
 
 from mercurial.commands import clone, nullid, pull
 from mercurial.context import memctx, memfilectx
 from mercurial.error import (
     LookupError, RepoError, RepoLookupError, Abort, InterventionRequired,
     RequirementError)
 from mercurial.hgweb import hgweb_mod
 from mercurial.localrepo import localrepository
 from mercurial.match import match
 from mercurial.mdiff import diffopts
 from mercurial.node import bin, hex
 from mercurial.encoding import tolocal
 from mercurial.discovery import findcommonoutgoing
 from mercurial.hg import peer
-from mercurial.httppeer import httppeer
+from mercurial.httppeer import makepeer
 from mercurial.util import url as hg_url
 from mercurial.scmutil import revrange
 from mercurial.node import nullrev
 from mercurial import exchange
 from hgext import largefiles
 
 # those authnadlers are patched for python 2.6.5 bug an
 # infinit looping when given invalid resources
 from mercurial.url import httpbasicauthhandler, httpdigestauthhandler

vcsserver/hgpatches.py

@@ -1,134 +1,134 b''
 # RhodeCode VCSServer provides access to different vcs backends via network.
 # Copyright (C) 2014-2018 RhodeCode GmbH
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 
 """
 Adjustments to Mercurial
 
 Intentionally kept separate from `hgcompat` and `hg`, so that these patches can
 be applied without having to import the whole Mercurial machinery.
 
 Imports are function local, so that just importing this module does not cause
 side-effects other than these functions being defined.
 """
 
 import logging
 
 
 def patch_largefiles_capabilities():
     """
     Patches the capabilities function in the largefiles extension.
     """
     from vcsserver import hgcompat
     lfproto = hgcompat.largefiles.proto
     wrapper = _dynamic_capabilities_wrapper(
         lfproto, hgcompat.extensions.extensions)
-    lfproto.capabilities = wrapper
+    lfproto._capabilities = wrapper
 
 
 def _dynamic_capabilities_wrapper(lfproto, extensions):
 
-    wrapped_capabilities = lfproto.capabilities
+    wrapped_capabilities = lfproto._capabilities
     logger = logging.getLogger('vcsserver.hg')
 
-    def _dynamic_capabilities(repo, proto):
+    def _dynamic_capabilities(orig, repo, proto):
         """
         Adds dynamic behavior, so that the capability is only added if the
         extension is enabled in the current ui object.
         """
         if 'largefiles' in dict(extensions(repo.ui)):
             logger.debug('Extension largefiles enabled')
             calc_capabilities = wrapped_capabilities
+            return calc_capabilities(orig, repo, proto)
         else:
             logger.debug('Extension largefiles disabled')
-            calc_capabilities = lfproto.capabilitiesorig
-        return calc_capabilities(repo, proto)
+            return orig(repo, proto)
 
     return _dynamic_capabilities
 
 
 def patch_subrepo_type_mapping():
     from collections import defaultdict
     from hgcompat import subrepo
     from exceptions import SubrepoMergeException
 
     class NoOpSubrepo(subrepo.abstractsubrepo):
 
         def __init__(self, ctx, path, *args, **kwargs):
             """Initialize abstractsubrepo part
 
             ``ctx`` is the context referring this subrepository in the
             parent repository.
 
             ``path`` is the path to this subrepository as seen from
             innermost repository.
             """
             self.ui = ctx.repo().ui
             self._ctx = ctx
             self._path = path
 
         def storeclean(self, path):
             """
             returns true if the repository has not changed since it was last
             cloned from or pushed to a given repository.
             """
             return True
 
         def dirty(self, ignoreupdate=False, missing=False):
             """returns true if the dirstate of the subrepo is dirty or does not
             match current stored state. If ignoreupdate is true, only check
             whether the subrepo has uncommitted changes in its dirstate.
             """
             return False
 
         def basestate(self):
             """current working directory base state, disregarding .hgsubstate
             state and working directory modifications"""
             substate = subrepo.state(self._ctx, self.ui)
             file_system_path, rev, repotype = substate.get(self._path)
             return rev
 
         def remove(self):
             """remove the subrepo
 
             (should verify the dirstate is not dirty first)
             """
             pass
 
         def get(self, state, overwrite=False):
             """run whatever commands are needed to put the subrepo into
             this state
             """
             pass
 
         def merge(self, state):
             """merge currently-saved state with the new state."""
-            raise SubrepoMergeException()
+            raise SubrepoMergeException()()
 
         def push(self, opts):
             """perform whatever action is analogous to 'hg push'
 
             This may be a no-op on some systems.
             """
             pass
 
     # Patch subrepo type mapping to always return our NoOpSubrepo class
     # whenever a subrepo class is looked up.
     subrepo.types = {
         'hg': NoOpSubrepo,
         'git': NoOpSubrepo,
         'svn': NoOpSubrepo
     }

vcsserver/hooks.py

@@ -1,570 +1,657 b''
 # -*- coding: utf-8 -*-
 
 # RhodeCode VCSServer provides access to different vcs backends via network.
 # Copyright (C) 2014-2018 RhodeCode GmbH
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 
 import io
 import os
 import sys
 import logging
 import collections
 import importlib
 import base64
 
 from httplib import HTTPConnection
 
 
 import mercurial.scmutil
 import mercurial.node
 import simplejson as json
 
 from vcsserver import exceptions, subprocessio, settings
 
 log = logging.getLogger(__name__)
 
 
 class HooksHttpClient(object):
     connection = None
 
     def __init__(self, hooks_uri):
         self.hooks_uri = hooks_uri
 
     def __call__(self, method, extras):
         connection = HTTPConnection(self.hooks_uri)
         body = self._serialize(method, extras)
         try:
             connection.request('POST', '/', body)
         except Exception:
             log.error('Connection failed on %s', connection)
             raise
         response = connection.getresponse()
         return json.loads(response.read())
 
     def _serialize(self, hook_name, extras):
         data = {
             'method': hook_name,
             'extras': extras
         }
         return json.dumps(data)
 
 
 class HooksDummyClient(object):
     def __init__(self, hooks_module):
         self._hooks_module = importlib.import_module(hooks_module)
 
     def __call__(self, hook_name, extras):
         with self._hooks_module.Hooks() as hooks:
             return getattr(hooks, hook_name)(extras)
 
 
 class RemoteMessageWriter(object):
     """Writer base class."""
     def write(self, message):
         raise NotImplementedError()
 
 
 class HgMessageWriter(RemoteMessageWriter):
     """Writer that knows how to send messages to mercurial clients."""
 
     def __init__(self, ui):
         self.ui = ui
 
     def write(self, message):
         # TODO: Check why the quiet flag is set by default.
         old = self.ui.quiet
         self.ui.quiet = False
         self.ui.status(message.encode('utf-8'))
         self.ui.quiet = old
 
 
 class GitMessageWriter(RemoteMessageWriter):
     """Writer that knows how to send messages to git clients."""
 
     def __init__(self, stdout=None):
         self.stdout = stdout or sys.stdout
 
     def write(self, message):
         self.stdout.write(message.encode('utf-8'))
 
 
 class SvnMessageWriter(RemoteMessageWriter):
     """Writer that knows how to send messages to svn clients."""
 
     def __init__(self, stderr=None):
         # SVN needs data sent to stderr for back-to-client messaging
         self.stderr = stderr or sys.stderr
 
     def write(self, message):
         self.stderr.write(message.encode('utf-8'))
 
 
 def _handle_exception(result):
     exception_class = result.get('exception')
     exception_traceback = result.get('exception_traceback')
 
     if exception_traceback:
         log.error('Got traceback from remote call:%s', exception_traceback)
 
     if exception_class == 'HTTPLockedRC':
-        raise exceptions.RepositoryLockedException(*result['exception_args'])
+        raise exceptions.RepositoryLockedException()(*result['exception_args'])
+    elif exception_class == 'HTTPBranchProtected':
+        raise exceptions.RepositoryBranchProtectedException()(*result['exception_args'])
     elif exception_class == 'RepositoryError':
-        raise exceptions.VcsException(*result['exception_args'])
+        raise exceptions.VcsException()(*result['exception_args'])
     elif exception_class:
         raise Exception('Got remote exception "%s" with args "%s"' %
                         (exception_class, result['exception_args']))
 
 
 def _get_hooks_client(extras):
     if 'hooks_uri' in extras:
         protocol = extras.get('hooks_protocol')
         return HooksHttpClient(extras['hooks_uri'])
     else:
         return HooksDummyClient(extras['hooks_module'])
 
 
 def _call_hook(hook_name, extras, writer):
     hooks_client = _get_hooks_client(extras)
     log.debug('Hooks, using client:%s', hooks_client)
     result = hooks_client(hook_name, extras)
     log.debug('Hooks got result: %s', result)
     writer.write(result['output'])
     _handle_exception(result)
 
     return result['status']
 
 
 def _extras_from_ui(ui):
     hook_data = ui.config('rhodecode', 'RC_SCM_DATA')
     if not hook_data:
         # maybe it's inside environ ?
         env_hook_data = os.environ.get('RC_SCM_DATA')
         if env_hook_data:
             hook_data = env_hook_data
 
     extras = {}
     if hook_data:
         extras = json.loads(hook_data)
     return extras
 
 
-def _rev_range_hash(repo, node):
+def _rev_range_hash(repo, node, check_heads=False):
 
     commits = []
-    for rev in xrange(repo[node], len(repo)):
+    revs = []
+    start = repo[node].rev()
+    end = len(repo)
+    for rev in range(start, end):
+        revs.append(rev)
         ctx = repo[rev]
         commit_id = mercurial.node.hex(ctx.node())
         branch = ctx.branch()
         commits.append((commit_id, branch))
 
-    return commits
+    parent_heads = []
+    if check_heads:
+        parent_heads = _check_heads(repo, start, end, revs)
+    return commits, parent_heads
+
+
+def _check_heads(repo, start, end, commits):
+    changelog = repo.changelog
+    parents = set()
+
+    for new_rev in commits:
+        for p in changelog.parentrevs(new_rev):
+            if p == mercurial.node.nullrev:
+                continue
+            if p < start:
+                parents.add(p)
+
+    for p in parents:
+        branch = repo[p].branch()
+        # The heads descending from that parent, on the same branch
+        parent_heads = set([p])
+        reachable = set([p])
+        for x in xrange(p + 1, end):
+            if repo[x].branch() != branch:
+                continue
+            for pp in changelog.parentrevs(x):
+                if pp in reachable:
+                    reachable.add(x)
+                    parent_heads.discard(pp)
+                    parent_heads.add(x)
+        # More than one head? Suggest merging
+        if len(parent_heads) > 1:
+            return list(parent_heads)
+
+    return []
 
 
 def repo_size(ui, repo, **kwargs):
     extras = _extras_from_ui(ui)
     return _call_hook('repo_size', extras, HgMessageWriter(ui))
 
 
 def pre_pull(ui, repo, **kwargs):
     extras = _extras_from_ui(ui)
     return _call_hook('pre_pull', extras, HgMessageWriter(ui))
 
 
 def pre_pull_ssh(ui, repo, **kwargs):
     extras = _extras_from_ui(ui)
     if extras and extras.get('SSH'):
         return pre_pull(ui, repo, **kwargs)
     return 0
 
 
 def post_pull(ui, repo, **kwargs):
     extras = _extras_from_ui(ui)
     return _call_hook('post_pull', extras, HgMessageWriter(ui))
 
 
 def post_pull_ssh(ui, repo, **kwargs):
     extras = _extras_from_ui(ui)
     if extras and extras.get('SSH'):
         return post_pull(ui, repo, **kwargs)
     return 0
 
 
 def pre_push(ui, repo, node=None, **kwargs):
+    """
+    Mercurial pre_push hook
+    """
     extras = _extras_from_ui(ui)
+    detect_force_push = extras.get('detect_force_push')
 
     rev_data = []
     if node and kwargs.get('hooktype') == 'pretxnchangegroup':
         branches = collections.defaultdict(list)
-        for commit_id, branch in _rev_range_hash(repo, node):
+        commits, _heads = _rev_range_hash(repo, node, check_heads=detect_force_push)
+        for commit_id, branch in commits:
             branches[branch].append(commit_id)
 
-        for branch, commits in branches.iteritems():
+        for branch, commits in branches.items():
             old_rev = kwargs.get('node_last') or commits[0]
             rev_data.append({
                 'old_rev': old_rev,
                 'new_rev': commits[-1],
                 'ref': '',
                 'type': 'branch',
                 'name': branch,
             })
 
+        for push_ref in rev_data:
+            push_ref['multiple_heads'] = _heads
+
     extras['commit_ids'] = rev_data
     return _call_hook('pre_push', extras, HgMessageWriter(ui))
 
 
 def pre_push_ssh(ui, repo, node=None, **kwargs):
-    if _extras_from_ui(ui).get('SSH'):
+    extras = _extras_from_ui(ui)
+    if extras.get('SSH'):
         return pre_push(ui, repo, node, **kwargs)
 
     return 0
 
 
 def pre_push_ssh_auth(ui, repo, node=None, **kwargs):
+    """
+    Mercurial pre_push hook for SSH
+    """
     extras = _extras_from_ui(ui)
     if extras.get('SSH'):
         permission = extras['SSH_PERMISSIONS']
 
         if 'repository.write' == permission or 'repository.admin' == permission:
             return 0
 
         # non-zero ret code
         return 1
 
     return 0
 
 
 def post_push(ui, repo, node, **kwargs):
+    """
+    Mercurial post_push hook
+    """
     extras = _extras_from_ui(ui)
 
     commit_ids = []
     branches = []
     bookmarks = []
     tags = []
 
-    for commit_id, branch in _rev_range_hash(repo, node):
+    commits, _heads = _rev_range_hash(repo, node)
+    for commit_id, branch in commits:
         commit_ids.append(commit_id)
         if branch not in branches:
             branches.append(branch)
 
     if hasattr(ui, '_rc_pushkey_branches'):
         bookmarks = ui._rc_pushkey_branches
 
     extras['commit_ids'] = commit_ids
     extras['new_refs'] = {
         'branches': branches,
         'bookmarks': bookmarks,
         'tags': tags
     }
 
     return _call_hook('post_push', extras, HgMessageWriter(ui))
 
 
 def post_push_ssh(ui, repo, node, **kwargs):
+    """
+    Mercurial post_push hook for SSH
+    """
     if _extras_from_ui(ui).get('SSH'):
         return post_push(ui, repo, node, **kwargs)
     return 0
 
 
 def key_push(ui, repo, **kwargs):
     if kwargs['new'] != '0' and kwargs['namespace'] == 'bookmarks':
         # store new bookmarks in our UI object propagated later to post_push
         ui._rc_pushkey_branches = repo[kwargs['key']].bookmarks()
     return
 
 
 # backward compat
 log_pull_action = post_pull
 
 # backward compat
 log_push_action = post_push
 
 
 def handle_git_pre_receive(unused_repo_path, unused_revs, unused_env):
     """
     Old hook name: keep here for backward compatibility.
 
     This is only required when the installed git hooks are not upgraded.
     """
     pass
 
 
 def handle_git_post_receive(unused_repo_path, unused_revs, unused_env):
     """
     Old hook name: keep here for backward compatibility.
 
     This is only required when the installed git hooks are not upgraded.
     """
     pass
 
 
 HookResponse = collections.namedtuple('HookResponse', ('status', 'output'))
 
 
 def git_pre_pull(extras):
     """
     Pre pull hook.
 
     :param extras: dictionary containing the keys defined in simplevcs
     :type extras: dict
 
     :return: status code of the hook. 0 for success.
     :rtype: int
     """
     if 'pull' not in extras['hooks']:
         return HookResponse(0, '')
 
     stdout = io.BytesIO()
     try:
         status = _call_hook('pre_pull', extras, GitMessageWriter(stdout))
     except Exception as error:
         status = 128
         stdout.write('ERROR: %s\n' % str(error))
 
     return HookResponse(status, stdout.getvalue())
 
 
 def git_post_pull(extras):
     """
     Post pull hook.
 
     :param extras: dictionary containing the keys defined in simplevcs
     :type extras: dict
 
     :return: status code of the hook. 0 for success.
     :rtype: int
     """
     if 'pull' not in extras['hooks']:
         return HookResponse(0, '')
 
     stdout = io.BytesIO()
     try:
         status = _call_hook('post_pull', extras, GitMessageWriter(stdout))
     except Exception as error:
         status = 128
         stdout.write('ERROR: %s\n' % error)
 
     return HookResponse(status, stdout.getvalue())
 
 
 def _parse_git_ref_lines(revision_lines):
     rev_data = []
     for revision_line in revision_lines or []:
         old_rev, new_rev, ref = revision_line.strip().split(' ')
         ref_data = ref.split('/', 2)
         if ref_data[1] in ('tags', 'heads'):
             rev_data.append({
                 'old_rev': old_rev,
                 'new_rev': new_rev,
                 'ref': ref,
                 'type': ref_data[1],
                 'name': ref_data[2],
             })
     return rev_data
 
 
 def git_pre_receive(unused_repo_path, revision_lines, env):
     """
     Pre push hook.
 
     :param extras: dictionary containing the keys defined in simplevcs
     :type extras: dict
 
     :return: status code of the hook. 0 for success.
     :rtype: int
     """
     extras = json.loads(env['RC_SCM_DATA'])
     rev_data = _parse_git_ref_lines(revision_lines)
     if 'push' not in extras['hooks']:
         return 0
+    empty_commit_id = '0' * 40
+
+    detect_force_push = extras.get('detect_force_push')
+
+    for push_ref in rev_data:
+        # store our git-env which holds the temp store
+        push_ref['git_env'] = [
+            (k, v) for k, v in os.environ.items() if k.startswith('GIT')]
+        push_ref['pruned_sha'] = ''
+        if not detect_force_push:
+            # don't check for forced-push when we don't need to
+            continue
+
+        type_ = push_ref['type']
+        new_branch = push_ref['old_rev'] == empty_commit_id
+        if type_ == 'heads' and not new_branch:
+            old_rev = push_ref['old_rev']
+            new_rev = push_ref['new_rev']
+            cmd = [settings.GIT_EXECUTABLE, 'rev-list',
+                   old_rev, '^{}'.format(new_rev)]
+            stdout, stderr = subprocessio.run_command(
+                cmd, env=os.environ.copy())
+            # means we're having some non-reachable objects, this forced push
+            # was used
+            if stdout:
+                push_ref['pruned_sha'] = stdout.splitlines()
+
     extras['commit_ids'] = rev_data
     return _call_hook('pre_push', extras, GitMessageWriter())
 
 
 def git_post_receive(unused_repo_path, revision_lines, env):
     """
     Post push hook.
 
     :param extras: dictionary containing the keys defined in simplevcs
     :type extras: dict
 
     :return: status code of the hook. 0 for success.
     :rtype: int
     """
     extras = json.loads(env['RC_SCM_DATA'])
     if 'push' not in extras['hooks']:
         return 0
 
     rev_data = _parse_git_ref_lines(revision_lines)
 
     git_revs = []
 
     # N.B.(skreft): it is ok to just call git, as git before calling a
     # subcommand sets the PATH environment variable so that it point to the
     # correct version of the git executable.
     empty_commit_id = '0' * 40
     branches = []
     tags = []
     for push_ref in rev_data:
         type_ = push_ref['type']
 
         if type_ == 'heads':
             if push_ref['old_rev'] == empty_commit_id:
                 # starting new branch case
                 if push_ref['name'] not in branches:
                     branches.append(push_ref['name'])
 
                 # Fix up head revision if needed
                 cmd = [settings.GIT_EXECUTABLE, 'show', 'HEAD']
                 try:
                     subprocessio.run_command(cmd, env=os.environ.copy())
                 except Exception:
                     cmd = [settings.GIT_EXECUTABLE, 'symbolic-ref', 'HEAD',
                            'refs/heads/%s' % push_ref['name']]
                     print("Setting default branch to %s" % push_ref['name'])
                     subprocessio.run_command(cmd, env=os.environ.copy())
 
                 cmd = [settings.GIT_EXECUTABLE, 'for-each-ref',
                        '--format=%(refname)', 'refs/heads/*']
                 stdout, stderr = subprocessio.run_command(
                     cmd, env=os.environ.copy())
                 heads = stdout
                 heads = heads.replace(push_ref['ref'], '')
-                heads = ' '.join(head for head in heads.splitlines() if head)
+                heads = ' '.join(head for head
+                                 in heads.splitlines() if head) or '.'
                 cmd = [settings.GIT_EXECUTABLE, 'log', '--reverse',
                        '--pretty=format:%H', '--', push_ref['new_rev'],
                        '--not', heads]
                 stdout, stderr = subprocessio.run_command(
                     cmd, env=os.environ.copy())
                 git_revs.extend(stdout.splitlines())
             elif push_ref['new_rev'] == empty_commit_id:
                 # delete branch case
                 git_revs.append('delete_branch=>%s' % push_ref['name'])
             else:
                 if push_ref['name'] not in branches:
                     branches.append(push_ref['name'])
 
                 cmd = [settings.GIT_EXECUTABLE, 'log',
                        '{old_rev}..{new_rev}'.format(**push_ref),
                        '--reverse', '--pretty=format:%H']
                 stdout, stderr = subprocessio.run_command(
                     cmd, env=os.environ.copy())
                 git_revs.extend(stdout.splitlines())
         elif type_ == 'tags':
             if push_ref['name'] not in tags:
                 tags.append(push_ref['name'])
             git_revs.append('tag=>%s' % push_ref['name'])
 
     extras['commit_ids'] = git_revs
     extras['new_refs'] = {
         'branches': branches,
         'bookmarks': [],
         'tags': tags,
     }
 
     if 'repo_size' in extras['hooks']:
         try:
             _call_hook('repo_size', extras, GitMessageWriter())
         except:
             pass
 
     return _call_hook('post_push', extras, GitMessageWriter())
 
 
 def _get_extras_from_txn_id(path, txn_id):
     extras = {}
     try:
         cmd = ['svnlook', 'pget',
                '-t', txn_id,
                '--revprop', path, 'rc-scm-extras']
         stdout, stderr = subprocessio.run_command(
             cmd, env=os.environ.copy())
         extras = json.loads(base64.urlsafe_b64decode(stdout))
     except Exception:
         log.exception('Failed to extract extras info from txn_id')
 
     return extras
 
 
 def svn_pre_commit(repo_path, commit_data, env):
     path, txn_id = commit_data
     branches = []
     tags = []
 
     if env.get('RC_SCM_DATA'):
         extras = json.loads(env['RC_SCM_DATA'])
     else:
         # fallback method to read from TXN-ID stored data
         extras = _get_extras_from_txn_id(path, txn_id)
         if not extras:
             return 0
 
     extras['commit_ids'] = []
     extras['txn_id'] = txn_id
     extras['new_refs'] = {
         'branches': branches,
         'bookmarks': [],
         'tags': tags,
     }
 
     return _call_hook('pre_push', extras, SvnMessageWriter())
 
 
 def _get_extras_from_commit_id(commit_id, path):
     extras = {}
     try:
         cmd = ['svnlook', 'pget',
                '-r', commit_id,
                '--revprop', path, 'rc-scm-extras']
         stdout, stderr = subprocessio.run_command(
             cmd, env=os.environ.copy())
         extras = json.loads(base64.urlsafe_b64decode(stdout))
     except Exception:
         log.exception('Failed to extract extras info from commit_id')
 
     return extras
 
 
 def svn_post_commit(repo_path, commit_data, env):
     """
     commit_data is path, rev, txn_id
     """
     path, commit_id, txn_id = commit_data
     branches = []
     tags = []
 
     if env.get('RC_SCM_DATA'):
         extras = json.loads(env['RC_SCM_DATA'])
     else:
         # fallback method to read from TXN-ID stored data
         extras = _get_extras_from_commit_id(commit_id, path)
         if not extras:
             return 0
 
     extras['commit_ids'] = [commit_id]
     extras['txn_id'] = txn_id
     extras['new_refs'] = {
         'branches': branches,
         'bookmarks': [],
         'tags': tags,
     }
 
     if 'repo_size' in extras['hooks']:
         try:
             _call_hook('repo_size', extras, SvnMessageWriter())
         except Exception:
             pass
 
     return _call_hook('post_push', extras, SvnMessageWriter())

vcsserver/http_main.py

@@ -1,487 +1,563 b''
 # RhodeCode VCSServer provides access to different vcs backends via network.
 # Copyright (C) 2014-2018 RhodeCode GmbH
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 
 import os
+import sys
 import base64
 import locale
 import logging
 import uuid
 import wsgiref.util
 import traceback
 from itertools import chain
 
 import simplejson as json
 import msgpack
-from beaker.cache import CacheManager
-from beaker.util import parse_cache_config_options
 from pyramid.config import Configurator
+from pyramid.settings import asbool, aslist
 from pyramid.wsgi import wsgiapp
 from pyramid.compat import configparser
 
+
+log = logging.getLogger(__name__)
+
+# due to Mercurial/glibc2.27 problems we need to detect if locale settings are
+# causing problems and "fix" it in case they do and fallback to LC_ALL = C
+
+try:
+    locale.setlocale(locale.LC_ALL, '')
+except locale.Error as e:
+    log.error(
+        'LOCALE ERROR: failed to set LC_ALL, fallback to LC_ALL=C, org error: %s', e)
+    os.environ['LC_ALL'] = 'C'
+
+
 from vcsserver import remote_wsgi, scm_app, settings, hgpatches
 from vcsserver.git_lfs.app import GIT_LFS_CONTENT_TYPE, GIT_LFS_PROTO_PAT
 from vcsserver.echo_stub import remote_wsgi as remote_wsgi_stub
 from vcsserver.echo_stub.echo_app import EchoApp
-from vcsserver.exceptions import HTTPRepoLocked
+from vcsserver.exceptions import HTTPRepoLocked, HTTPRepoBranchProtected
+from vcsserver.lib.exc_tracking import store_exception
 from vcsserver.server import VcsServer
 
 try:
     from vcsserver.git import GitFactory, GitRemote
 except ImportError:
     GitFactory = None
     GitRemote = None
 
 try:
     from vcsserver.hg import MercurialFactory, HgRemote
 except ImportError:
     MercurialFactory = None
     HgRemote = None
 
 try:
     from vcsserver.svn import SubversionFactory, SvnRemote
 except ImportError:
     SubversionFactory = None
     SvnRemote = None
 
-log = logging.getLogger(__name__)
+
 
 
 def _is_request_chunked(environ):
     stream = environ.get('HTTP_TRANSFER_ENCODING', '') == 'chunked'
     return stream
 
 
+def _int_setting(settings, name, default):
+    settings[name] = int(settings.get(name, default))
+
+
+def _bool_setting(settings, name, default):
+    input_val = settings.get(name, default)
+    if isinstance(input_val, unicode):
+        input_val = input_val.encode('utf8')
+    settings[name] = asbool(input_val)
+
+
+def _list_setting(settings, name, default):
+    raw_value = settings.get(name, default)
+
+    # Otherwise we assume it uses pyramids space/newline separation.
+    settings[name] = aslist(raw_value)
+
+
+def _string_setting(settings, name, default, lower=True):
+    value = settings.get(name, default)
+    if lower:
+        value = value.lower()
+    settings[name] = value
+
+
 class VCS(object):
     def __init__(self, locale=None, cache_config=None):
         self.locale = locale
         self.cache_config = cache_config
         self._configure_locale()
-        self._initialize_cache()
 
         if GitFactory and GitRemote:
-            git_repo_cache = self.cache.get_cache_region(
-                'git', region='repo_object')
-            git_factory = GitFactory(git_repo_cache)
+            git_factory = GitFactory()
             self._git_remote = GitRemote(git_factory)
         else:
             log.info("Git client import failed")
 
         if MercurialFactory and HgRemote:
-            hg_repo_cache = self.cache.get_cache_region(
-                'hg', region='repo_object')
-            hg_factory = MercurialFactory(hg_repo_cache)
+            hg_factory = MercurialFactory()
             self._hg_remote = HgRemote(hg_factory)
         else:
             log.info("Mercurial client import failed")
 
         if SubversionFactory and SvnRemote:
-            svn_repo_cache = self.cache.get_cache_region(
-                'svn', region='repo_object')
-            svn_factory = SubversionFactory(svn_repo_cache)
+            svn_factory = SubversionFactory()
+
             # hg factory is used for svn url validation
-            hg_repo_cache = self.cache.get_cache_region(
-                'hg', region='repo_object')
-            hg_factory = MercurialFactory(hg_repo_cache)
+            hg_factory = MercurialFactory()
             self._svn_remote = SvnRemote(svn_factory, hg_factory=hg_factory)
         else:
             log.info("Subversion client import failed")
 
         self._vcsserver = VcsServer()
 
-    def _initialize_cache(self):
-        cache_config = parse_cache_config_options(self.cache_config)
-        log.info('Initializing beaker cache: %s' % cache_config)
-        self.cache = CacheManager(**cache_config)
-
     def _configure_locale(self):
         if self.locale:
             log.info('Settings locale: `LC_ALL` to %s' % self.locale)
         else:
             log.info(
                 'Configuring locale subsystem based on environment variables')
         try:
             # If self.locale is the empty string, then the locale
             # module will use the environment variables. See the
             # documentation of the package `locale`.
             locale.setlocale(locale.LC_ALL, self.locale)
 
             language_code, encoding = locale.getlocale()
             log.info(
                 'Locale set to language code "%s" with encoding "%s".',
                 language_code, encoding)
         except locale.Error:
             log.exception(
                 'Cannot set locale, not configuring the locale system')
 
 
 class WsgiProxy(object):
     def __init__(self, wsgi):
         self.wsgi = wsgi
 
     def __call__(self, environ, start_response):
         input_data = environ['wsgi.input'].read()
         input_data = msgpack.unpackb(input_data)
 
         error = None
         try:
             data, status, headers = self.wsgi.handle(
                 input_data['environment'], input_data['input_data'],
                 *input_data['args'], **input_data['kwargs'])
         except Exception as e:
             data, status, headers = [], None, None
             error = {
                 'message': str(e),
                 '_vcs_kind': getattr(e, '_vcs_kind', None)
             }
 
         start_response(200, {})
         return self._iterator(error, status, headers, data)
 
     def _iterator(self, error, status, headers, data):
         initial_data = [
             error,
             status,
             headers,
         ]
 
         for d in chain(initial_data, data):
             yield msgpack.packb(d)
 
 
 class HTTPApplication(object):
     ALLOWED_EXCEPTIONS = ('KeyError', 'URLError')
 
     remote_wsgi = remote_wsgi
     _use_echo_app = False
 
     def __init__(self, settings=None, global_config=None):
+        self._sanitize_settings_and_apply_defaults(settings)
+
         self.config = Configurator(settings=settings)
         self.global_config = global_config
+        self.config.include('vcsserver.lib.rc_cache')
 
         locale = settings.get('locale', '') or 'en_US.UTF-8'
         vcs = VCS(locale=locale, cache_config=settings)
         self._remotes = {
             'hg': vcs._hg_remote,
             'git': vcs._git_remote,
             'svn': vcs._svn_remote,
             'server': vcs._vcsserver,
         }
         if settings.get('dev.use_echo_app', 'false').lower() == 'true':
             self._use_echo_app = True
             log.warning("Using EchoApp for VCS operations.")
             self.remote_wsgi = remote_wsgi_stub
         self._configure_settings(settings)
         self._configure()
 
     def _configure_settings(self, app_settings):
         """
         Configure the settings module.
         """
         git_path = app_settings.get('git_path', None)
         if git_path:
             settings.GIT_EXECUTABLE = git_path
         binary_dir = app_settings.get('core.binary_dir', None)
         if binary_dir:
             settings.BINARY_DIR = binary_dir
 
+    def _sanitize_settings_and_apply_defaults(self, settings):
+        # repo_object cache
+        _string_setting(
+            settings,
+            'rc_cache.repo_object.backend',
+            'dogpile.cache.rc.memory_lru')
+        _int_setting(
+            settings,
+            'rc_cache.repo_object.expiration_time',
+            300)
+        _int_setting(
+            settings,
+            'rc_cache.repo_object.max_size',
+            1024)
+
     def _configure(self):
         self.config.add_renderer(
             name='msgpack',
             factory=self._msgpack_renderer_factory)
 
         self.config.add_route('service', '/_service')
         self.config.add_route('status', '/status')
         self.config.add_route('hg_proxy', '/proxy/hg')
         self.config.add_route('git_proxy', '/proxy/git')
         self.config.add_route('vcs', '/{backend}')
         self.config.add_route('stream_git', '/stream/git/*repo_name')
         self.config.add_route('stream_hg', '/stream/hg/*repo_name')
 
         self.config.add_view(
             self.status_view, route_name='status', renderer='json')
         self.config.add_view(
             self.service_view, route_name='service', renderer='msgpack')
 
         self.config.add_view(self.hg_proxy(), route_name='hg_proxy')
         self.config.add_view(self.git_proxy(), route_name='git_proxy')
         self.config.add_view(
             self.vcs_view, route_name='vcs', renderer='msgpack',
             custom_predicates=[self.is_vcs_view])
 
         self.config.add_view(self.hg_stream(), route_name='stream_hg')
         self.config.add_view(self.git_stream(), route_name='stream_git')
 
         def notfound(request):
             return {'status': '404 NOT FOUND'}
         self.config.add_notfound_view(notfound, renderer='json')
 
         self.config.add_view(self.handle_vcs_exception, context=Exception)
 
         self.config.add_tween(
             'vcsserver.tweens.RequestWrapperTween',
         )
 
     def wsgi_app(self):
         return self.config.make_wsgi_app()
 
     def vcs_view(self, request):
         remote = self._remotes[request.matchdict['backend']]
         payload = msgpack.unpackb(request.body, use_list=True)
         method = payload.get('method')
         params = payload.get('params')
         wire = params.get('wire')
         args = params.get('args')
         kwargs = params.get('kwargs')
+        context_uid = None
+
         if wire:
             try:
-                wire['context'] = uuid.UUID(wire['context'])
+                wire['context'] = context_uid = uuid.UUID(wire['context'])
             except KeyError:
                 pass
             args.insert(0, wire)
 
-        log.debug('method called:%s with kwargs:%s', method, kwargs)
+        log.debug('method called:%s with kwargs:%s context_uid: %s',
+                  method, kwargs, context_uid)
         try:
             resp = getattr(remote, method)(*args, **kwargs)
         except Exception as e:
-            tb_info = traceback.format_exc()
+            exc_info = list(sys.exc_info())
+            exc_type, exc_value, exc_traceback = exc_info
+
+            org_exc = getattr(e, '_org_exc', None)
+            org_exc_name = None
+            if org_exc:
+                org_exc_name = org_exc.__class__.__name__
+                # replace our "faked" exception with our org
+                exc_info[0] = org_exc.__class__
+                exc_info[1] = org_exc
+
+            store_exception(id(exc_info), exc_info)
+
+            tb_info = ''.join(
+                traceback.format_exception(exc_type, exc_value, exc_traceback))
 
             type_ = e.__class__.__name__
             if type_ not in self.ALLOWED_EXCEPTIONS:
                 type_ = None
 
             resp = {
                 'id': payload.get('id'),
                 'error': {
                     'message': e.message,
                     'traceback': tb_info,
+                    'org_exc': org_exc_name,
                     'type': type_
                 }
             }
             try:
-                resp['error']['_vcs_kind'] = e._vcs_kind
+                resp['error']['_vcs_kind'] = getattr(e, '_vcs_kind', None)
             except AttributeError:
                 pass
         else:
             resp = {
                 'id': payload.get('id'),
                 'result': resp
             }
 
         return resp
 
     def status_view(self, request):
         import vcsserver
         return {'status': 'OK', 'vcsserver_version': vcsserver.__version__,
                 'pid': os.getpid()}
 
     def service_view(self, request):
         import vcsserver
 
         payload = msgpack.unpackb(request.body, use_list=True)
 
         try:
             path = self.global_config['__file__']
             config = configparser.ConfigParser()
             config.read(path)
             parsed_ini = config
             if parsed_ini.has_section('server:main'):
                 parsed_ini = dict(parsed_ini.items('server:main'))
         except Exception:
             log.exception('Failed to read .ini file for display')
             parsed_ini = {}
 
         resp = {
             'id': payload.get('id'),
             'result': dict(
                 version=vcsserver.__version__,
                 config=parsed_ini,
                 payload=payload,
             )
         }
         return resp
 
     def _msgpack_renderer_factory(self, info):
         def _render(value, system):
             value = msgpack.packb(value)
             request = system.get('request')
             if request is not None:
                 response = request.response
                 ct = response.content_type
                 if ct == response.default_content_type:
                     response.content_type = 'application/x-msgpack'
             return value
         return _render
 
     def set_env_from_config(self, environ, config):
         dict_conf = {}
         try:
             for elem in config:
                 if elem[0] == 'rhodecode':
                     dict_conf = json.loads(elem[2])
                     break
         except Exception:
             log.exception('Failed to fetch SCM CONFIG')
             return
 
         username = dict_conf.get('username')
         if username:
             environ['REMOTE_USER'] = username
             # mercurial specific, some extension api rely on this
             environ['HGUSER'] = username
 
         ip = dict_conf.get('ip')
         if ip:
             environ['REMOTE_HOST'] = ip
 
         if _is_request_chunked(environ):
             # set the compatibility flag for webob
             environ['wsgi.input_terminated'] = True
 
     def hg_proxy(self):
         @wsgiapp
         def _hg_proxy(environ, start_response):
             app = WsgiProxy(self.remote_wsgi.HgRemoteWsgi())
             return app(environ, start_response)
         return _hg_proxy
 
     def git_proxy(self):
         @wsgiapp
         def _git_proxy(environ, start_response):
             app = WsgiProxy(self.remote_wsgi.GitRemoteWsgi())
             return app(environ, start_response)
         return _git_proxy
 
     def hg_stream(self):
         if self._use_echo_app:
             @wsgiapp
             def _hg_stream(environ, start_response):
                 app = EchoApp('fake_path', 'fake_name', None)
                 return app(environ, start_response)
             return _hg_stream
         else:
             @wsgiapp
             def _hg_stream(environ, start_response):
                 log.debug('http-app: handling hg stream')
                 repo_path = environ['HTTP_X_RC_REPO_PATH']
                 repo_name = environ['HTTP_X_RC_REPO_NAME']
                 packed_config = base64.b64decode(
                     environ['HTTP_X_RC_REPO_CONFIG'])
                 config = msgpack.unpackb(packed_config)
                 app = scm_app.create_hg_wsgi_app(
                     repo_path, repo_name, config)
 
                 # Consistent path information for hgweb
                 environ['PATH_INFO'] = environ['HTTP_X_RC_PATH_INFO']
                 environ['REPO_NAME'] = repo_name
                 self.set_env_from_config(environ, config)
 
                 log.debug('http-app: starting app handler '
                           'with %s and process request', app)
                 return app(environ, ResponseFilter(start_response))
             return _hg_stream
 
     def git_stream(self):
         if self._use_echo_app:
             @wsgiapp
             def _git_stream(environ, start_response):
                 app = EchoApp('fake_path', 'fake_name', None)
                 return app(environ, start_response)
             return _git_stream
         else:
             @wsgiapp
             def _git_stream(environ, start_response):
                 log.debug('http-app: handling git stream')
                 repo_path = environ['HTTP_X_RC_REPO_PATH']
                 repo_name = environ['HTTP_X_RC_REPO_NAME']
                 packed_config = base64.b64decode(
                     environ['HTTP_X_RC_REPO_CONFIG'])
                 config = msgpack.unpackb(packed_config)
 
                 environ['PATH_INFO'] = environ['HTTP_X_RC_PATH_INFO']
                 self.set_env_from_config(environ, config)
 
                 content_type = environ.get('CONTENT_TYPE', '')
 
                 path = environ['PATH_INFO']
                 is_lfs_request = GIT_LFS_CONTENT_TYPE in content_type
                 log.debug(
                     'LFS: Detecting if request `%s` is LFS server path based '
                     'on content type:`%s`, is_lfs:%s',
                     path, content_type, is_lfs_request)
 
                 if not is_lfs_request:
                     # fallback detection by path
                     if GIT_LFS_PROTO_PAT.match(path):
                         is_lfs_request = True
                     log.debug(
                         'LFS: fallback detection by path of: `%s`, is_lfs:%s',
                         path, is_lfs_request)
 
                 if is_lfs_request:
                     app = scm_app.create_git_lfs_wsgi_app(
                         repo_path, repo_name, config)
                 else:
                     app = scm_app.create_git_wsgi_app(
                         repo_path, repo_name, config)
 
                 log.debug('http-app: starting app handler '
                           'with %s and process request', app)
 
                 return app(environ, start_response)
 
             return _git_stream
 
     def is_vcs_view(self, context, request):
         """
         View predicate that returns true if given backend is supported by
         defined remotes.
         """
         backend = request.matchdict.get('backend')
         return backend in self._remotes
 
     def handle_vcs_exception(self, exception, request):
         _vcs_kind = getattr(exception, '_vcs_kind', '')
         if _vcs_kind == 'repo_locked':
             # Get custom repo-locked status code if present.
             status_code = request.headers.get('X-RC-Locked-Status-Code')
             return HTTPRepoLocked(
                 title=exception.message, status_code=status_code)
 
-        # Re-raise exception if we can not handle it.
-        log.exception(
-            'error occurred handling this request for path: %s', request.path)
+        elif _vcs_kind == 'repo_branch_protected':
+            # Get custom repo-branch-protected status code if present.
+            return HTTPRepoBranchProtected(title=exception.message)
+
+        exc_info = request.exc_info
+        store_exception(id(exc_info), exc_info)
+
+        traceback_info = 'unavailable'
+        if request.exc_info:
+            exc_type, exc_value, exc_tb = request.exc_info
+            traceback_info = ''.join(traceback.format_exception(exc_type, exc_value, exc_tb))
+
+        log.error(
+            'error occurred handling this request for path: %s, \n tb: %s',
+            request.path, traceback_info)
         raise exception
 
 
 class ResponseFilter(object):
 
     def __init__(self, start_response):
         self._start_response = start_response
 
     def __call__(self, status, response_headers, exc_info=None):
         headers = tuple(
             (h, v) for h, v in response_headers
             if not wsgiref.util.is_hop_by_hop(h))
         return self._start_response(status, headers, exc_info)
 
 
 def main(global_config, **settings):
     if MercurialFactory:
         hgpatches.patch_largefiles_capabilities()
         hgpatches.patch_subrepo_type_mapping()
+
     app = HTTPApplication(settings=settings, global_config=global_config)
     return app.wsgi_app()

vcsserver/scm_app.py

@@ -1,229 +1,234 b''
 # RhodeCode VCSServer provides access to different vcs backends via network.
 # Copyright (C) 2014-2018 RhodeCode GmbH
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 
 import os
 import logging
 import itertools
 
 import mercurial
 import mercurial.error
+import mercurial.wireprotoserver
 import mercurial.hgweb.common
 import mercurial.hgweb.hgweb_mod
-import mercurial.hgweb.protocol
 import webob.exc
 
 from vcsserver import pygrack, exceptions, settings, git_lfs
 
 
 log = logging.getLogger(__name__)
 
 
 # propagated from mercurial documentation
 HG_UI_SECTIONS = [
     'alias', 'auth', 'decode/encode', 'defaults', 'diff', 'email', 'extensions',
     'format', 'merge-patterns', 'merge-tools', 'hooks', 'http_proxy', 'smtp',
     'patch', 'paths', 'profiling', 'server', 'trusted', 'ui', 'web',
 ]
 
 
 class HgWeb(mercurial.hgweb.hgweb_mod.hgweb):
     """Extension of hgweb that simplifies some functions."""
 
     def _get_view(self, repo):
         """Views are not supported."""
         return repo
 
     def loadsubweb(self):
         """The result is only used in the templater method which is not used."""
         return None
 
     def run(self):
         """Unused function so raise an exception if accidentally called."""
         raise NotImplementedError
 
     def templater(self, req):
         """Function used in an unreachable code path.
 
         This code is unreachable because we guarantee that the HTTP request,
         corresponds to a Mercurial command. See the is_hg method. So, we are
         never going to get a user-visible url.
         """
         raise NotImplementedError
 
     def archivelist(self, nodeid):
         """Unused function so raise an exception if accidentally called."""
         raise NotImplementedError
 
     def __call__(self, environ, start_response):
         """Run the WSGI application.
 
         This may be called by multiple threads.
         """
-        req = mercurial.hgweb.request.wsgirequest(environ, start_response)
-        gen = self.run_wsgi(req)
+        from mercurial.hgweb import request as requestmod
+        req = requestmod.parserequestfromenv(environ)
+        res = requestmod.wsgiresponse(req, start_response)
+        gen = self.run_wsgi(req, res)
 
         first_chunk = None
 
         try:
             data = gen.next()
-            def first_chunk(): yield data
+
+            def first_chunk():
+                yield data
         except StopIteration:
             pass
 
         if first_chunk:
             return itertools.chain(first_chunk(), gen)
         return gen
 
-    def _runwsgi(self, req, repo):
-        cmd = req.form.get('cmd', [''])[0]
-        if not mercurial.hgweb.protocol.iscmd(cmd):
-            req.respond(
-                mercurial.hgweb.common.ErrorResponse(
-                    mercurial.hgweb.common.HTTP_BAD_REQUEST),
-                mercurial.hgweb.protocol.HGTYPE
-            )
-            return ['']
+    def _runwsgi(self, req, res, repo):
 
-        return super(HgWeb, self)._runwsgi(req, repo)
+        cmd = req.qsparams.get('cmd', '')
+        if not mercurial.wireprotoserver.iscmd(cmd):
+            # NOTE(marcink): for unsupported commands, we return bad request
+            # internally from HG
+            from mercurial.hgweb.common import statusmessage
+            res.status = statusmessage(mercurial.hgweb.common.HTTP_BAD_REQUEST)
+            res.setbodybytes('')
+            return res.sendresponse()
+
+        return super(HgWeb, self)._runwsgi(req, res, repo)
 
 
 def make_hg_ui_from_config(repo_config):
     baseui = mercurial.ui.ui()
 
     # clean the baseui object
     baseui._ocfg = mercurial.config.config()
     baseui._ucfg = mercurial.config.config()
     baseui._tcfg = mercurial.config.config()
 
     for section, option, value in repo_config:
         baseui.setconfig(section, option, value)
 
     # make our hgweb quiet so it doesn't print output
     baseui.setconfig('ui', 'quiet', 'true')
 
     return baseui
 
 
 def update_hg_ui_from_hgrc(baseui, repo_path):
     path = os.path.join(repo_path, '.hg', 'hgrc')
 
     if not os.path.isfile(path):
         log.debug('hgrc file is not present at %s, skipping...', path)
         return
     log.debug('reading hgrc from %s', path)
     cfg = mercurial.config.config()
     cfg.read(path)
     for section in HG_UI_SECTIONS:
         for k, v in cfg.items(section):
             log.debug('settings ui from file: [%s] %s=%s', section, k, v)
             baseui.setconfig(section, k, v)
 
 
 def create_hg_wsgi_app(repo_path, repo_name, config):
     """
     Prepares a WSGI application to handle Mercurial requests.
 
     :param config: is a list of 3-item tuples representing a ConfigObject
         (it is the serialized version of the config object).
     """
     log.debug("Creating Mercurial WSGI application")
 
     baseui = make_hg_ui_from_config(config)
     update_hg_ui_from_hgrc(baseui, repo_path)
 
     try:
         return HgWeb(repo_path, name=repo_name, baseui=baseui)
-    except mercurial.error.RequirementError as exc:
-        raise exceptions.RequirementException(exc)
+    except mercurial.error.RequirementError as e:
+        raise exceptions.RequirementException(e)(e)
 
 
 class GitHandler(object):
     """
     Handler for Git operations like push/pull etc
     """
     def __init__(self, repo_location, repo_name, git_path, update_server_info,
                  extras):
         if not os.path.isdir(repo_location):
             raise OSError(repo_location)
         self.content_path = repo_location
         self.repo_name = repo_name
         self.repo_location = repo_location
         self.extras = extras
         self.git_path = git_path
         self.update_server_info = update_server_info
 
     def __call__(self, environ, start_response):
         app = webob.exc.HTTPNotFound()
         candidate_paths = (
             self.content_path, os.path.join(self.content_path, '.git'))
 
         for content_path in candidate_paths:
             try:
                 app = pygrack.GitRepository(
                     self.repo_name, content_path, self.git_path,
                     self.update_server_info, self.extras)
                 break
             except OSError:
                 continue
 
         return app(environ, start_response)
 
 
 def create_git_wsgi_app(repo_path, repo_name, config):
     """
     Creates a WSGI application to handle Git requests.
 
     :param config: is a dictionary holding the extras.
     """
     git_path = settings.GIT_EXECUTABLE
     update_server_info = config.pop('git_update_server_info')
     app = GitHandler(
         repo_path, repo_name, git_path, update_server_info, config)
 
     return app
 
 
 class GitLFSHandler(object):
     """
     Handler for Git LFS operations
     """
 
     def __init__(self, repo_location, repo_name, git_path, update_server_info,
                  extras):
         if not os.path.isdir(repo_location):
             raise OSError(repo_location)
         self.content_path = repo_location
         self.repo_name = repo_name
         self.repo_location = repo_location
         self.extras = extras
         self.git_path = git_path
         self.update_server_info = update_server_info
 
     def get_app(self, git_lfs_enabled, git_lfs_store_path):
         app = git_lfs.create_app(git_lfs_enabled, git_lfs_store_path)
         return app
 
 
 def create_git_lfs_wsgi_app(repo_path, repo_name, config):
     git_path = settings.GIT_EXECUTABLE
     update_server_info = config.pop('git_update_server_info')
     git_lfs_enabled = config.pop('git_lfs_enabled')
     git_lfs_store_path = config.pop('git_lfs_store_path')
     app = GitLFSHandler(
         repo_path, repo_name, git_path, update_server_info, config)
 
     return app.get_app(git_lfs_enabled, git_lfs_store_path)

vcsserver/svn.py

@@ -1,689 +1,705 b''
 # RhodeCode VCSServer provides access to different vcs backends via network.
 # Copyright (C) 2014-2018 RhodeCode GmbH
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 
 from __future__ import absolute_import
 
 import os
 from urllib2 import URLError
 import logging
 import posixpath as vcspath
 import StringIO
 import urllib
 import traceback
 
 import svn.client
 import svn.core
 import svn.delta
 import svn.diff
 import svn.fs
 import svn.repos
 
 from vcsserver import svn_diff, exceptions, subprocessio, settings
 from vcsserver.base import RepoFactory, raise_from_original
 
 log = logging.getLogger(__name__)
 
 
 # Set of svn compatible version flags.
 # Compare with subversion/svnadmin/svnadmin.c
-svn_compatible_versions = set([
+svn_compatible_versions = {
     'pre-1.4-compatible',
     'pre-1.5-compatible',
     'pre-1.6-compatible',
     'pre-1.8-compatible',
-    'pre-1.9-compatible',
-])
+    'pre-1.9-compatible'
+}
 
 svn_compatible_versions_map = {
     'pre-1.4-compatible': '1.3',
     'pre-1.5-compatible': '1.4',
     'pre-1.6-compatible': '1.5',
     'pre-1.8-compatible': '1.7',
     'pre-1.9-compatible': '1.8',
 }
 
 
 def reraise_safe_exceptions(func):
     """Decorator for converting svn exceptions to something neutral."""
     def wrapper(*args, **kwargs):
         try:
             return func(*args, **kwargs)
         except Exception as e:
             if not hasattr(e, '_vcs_kind'):
-                log.exception("Unhandled exception in hg remote call")
-                raise_from_original(exceptions.UnhandledException)
+                log.exception("Unhandled exception in svn remote call")
+                raise_from_original(exceptions.UnhandledException(e))
             raise
     return wrapper
 
 
 class SubversionFactory(RepoFactory):
+    repo_type = 'svn'
 
     def _create_repo(self, wire, create, compatible_version):
         path = svn.core.svn_path_canonicalize(wire['path'])
         if create:
             fs_config = {'compatible-version': '1.9'}
             if compatible_version:
                 if compatible_version not in svn_compatible_versions:
                     raise Exception('Unknown SVN compatible version "{}"'
                                     .format(compatible_version))
                 fs_config['compatible-version'] = \
                     svn_compatible_versions_map[compatible_version]
 
             log.debug('Create SVN repo with config "%s"', fs_config)
             repo = svn.repos.create(path, "", "", None, fs_config)
         else:
             repo = svn.repos.open(path)
 
         log.debug('Got SVN object: %s', repo)
         return repo
 
     def repo(self, wire, create=False, compatible_version=None):
-        def create_new_repo():
+        """
+        Get a repository instance for the given path.
+
+        Uses internally the low level beaker API since the decorators introduce
+        significant overhead.
+        """
+        region = self._cache_region
+        context = wire.get('context', None)
+        repo_path = wire.get('path', '')
+        context_uid = '{}'.format(context)
+        cache = wire.get('cache', True)
+        cache_on = context and cache
+
+        @region.conditional_cache_on_arguments(condition=cache_on)
+        def create_new_repo(_repo_type, _repo_path, _context_uid, compatible_version_id):
             return self._create_repo(wire, create, compatible_version)
 
-        return self._repo(wire, create_new_repo)
+        return create_new_repo(self.repo_type, repo_path, context_uid,
+                               compatible_version)
 
 
 NODE_TYPE_MAPPING = {
     svn.core.svn_node_file: 'file',
     svn.core.svn_node_dir: 'dir',
 }
 
 
 class SvnRemote(object):
 
     def __init__(self, factory, hg_factory=None):
         self._factory = factory
         # TODO: Remove once we do not use internal Mercurial objects anymore
         # for subversion
         self._hg_factory = hg_factory
 
     @reraise_safe_exceptions
     def discover_svn_version(self):
         try:
             import svn.core
             svn_ver = svn.core.SVN_VERSION
         except ImportError:
             svn_ver = None
         return svn_ver
 
     def check_url(self, url, config_items):
         # this can throw exception if not installed, but we detect this
         from hgsubversion import svnrepo
 
         baseui = self._hg_factory._create_config(config_items)
         # uuid function get's only valid UUID from proper repo, else
         # throws exception
         try:
             svnrepo.svnremoterepo(baseui, url).svn.uuid
         except Exception:
             tb = traceback.format_exc()
             log.debug("Invalid Subversion url: `%s`, tb: %s", url, tb)
             raise URLError(
                 '"%s" is not a valid Subversion source url.' % (url, ))
         return True
 
     def is_path_valid_repository(self, wire, path):
 
         # NOTE(marcink):  short circuit the check for SVN repo
         # the repos.open might be expensive to check, but we have one cheap
         # pre condition that we can use, to check for 'format' file
 
         if not os.path.isfile(os.path.join(path, 'format')):
             return False
 
         try:
             svn.repos.open(path)
         except svn.core.SubversionException:
             tb = traceback.format_exc()
             log.debug("Invalid Subversion path `%s`, tb: %s", path, tb)
             return False
         return True
 
     @reraise_safe_exceptions
     def verify(self, wire,):
         repo_path = wire['path']
         if not self.is_path_valid_repository(wire, repo_path):
             raise Exception(
                 "Path %s is not a valid Subversion repository." % repo_path)
 
         cmd = ['svnadmin', 'info', repo_path]
         stdout, stderr = subprocessio.run_command(cmd)
         return stdout
 
     def lookup(self, wire, revision):
         if revision not in [-1, None, 'HEAD']:
             raise NotImplementedError
         repo = self._factory.repo(wire)
         fs_ptr = svn.repos.fs(repo)
         head = svn.fs.youngest_rev(fs_ptr)
         return head
 
     def lookup_interval(self, wire, start_ts, end_ts):
         repo = self._factory.repo(wire)
         fsobj = svn.repos.fs(repo)
         start_rev = None
         end_rev = None
         if start_ts:
             start_ts_svn = apr_time_t(start_ts)
             start_rev = svn.repos.dated_revision(repo, start_ts_svn) + 1
         else:
             start_rev = 1
         if end_ts:
             end_ts_svn = apr_time_t(end_ts)
             end_rev = svn.repos.dated_revision(repo, end_ts_svn)
         else:
             end_rev = svn.fs.youngest_rev(fsobj)
         return start_rev, end_rev
 
     def revision_properties(self, wire, revision):
         repo = self._factory.repo(wire)
         fs_ptr = svn.repos.fs(repo)
         return svn.fs.revision_proplist(fs_ptr, revision)
 
     def revision_changes(self, wire, revision):
 
         repo = self._factory.repo(wire)
         fsobj = svn.repos.fs(repo)
         rev_root = svn.fs.revision_root(fsobj, revision)
 
         editor = svn.repos.ChangeCollector(fsobj, rev_root)
         editor_ptr, editor_baton = svn.delta.make_editor(editor)
         base_dir = ""
         send_deltas = False
         svn.repos.replay2(
             rev_root, base_dir, svn.core.SVN_INVALID_REVNUM, send_deltas,
             editor_ptr, editor_baton, None)
 
         added = []
         changed = []
         removed = []
 
         # TODO: CHANGE_ACTION_REPLACE: Figure out where it belongs
         for path, change in editor.changes.iteritems():
             # TODO: Decide what to do with directory nodes. Subversion can add
             # empty directories.
 
             if change.item_kind == svn.core.svn_node_dir:
                 continue
             if change.action in [svn.repos.CHANGE_ACTION_ADD]:
                 added.append(path)
             elif change.action in [svn.repos.CHANGE_ACTION_MODIFY,
                                    svn.repos.CHANGE_ACTION_REPLACE]:
                 changed.append(path)
             elif change.action in [svn.repos.CHANGE_ACTION_DELETE]:
                 removed.append(path)
             else:
                 raise NotImplementedError(
                     "Action %s not supported on path %s" % (
                         change.action, path))
 
         changes = {
             'added': added,
             'changed': changed,
             'removed': removed,
         }
         return changes
 
     def node_history(self, wire, path, revision, limit):
         cross_copies = False
         repo = self._factory.repo(wire)
         fsobj = svn.repos.fs(repo)
         rev_root = svn.fs.revision_root(fsobj, revision)
 
         history_revisions = []
         history = svn.fs.node_history(rev_root, path)
         history = svn.fs.history_prev(history, cross_copies)
         while history:
             __, node_revision = svn.fs.history_location(history)
             history_revisions.append(node_revision)
             if limit and len(history_revisions) >= limit:
                 break
             history = svn.fs.history_prev(history, cross_copies)
         return history_revisions
 
     def node_properties(self, wire, path, revision):
         repo = self._factory.repo(wire)
         fsobj = svn.repos.fs(repo)
         rev_root = svn.fs.revision_root(fsobj, revision)
         return svn.fs.node_proplist(rev_root, path)
 
     def file_annotate(self, wire, path, revision):
         abs_path = 'file://' + urllib.pathname2url(
             vcspath.join(wire['path'], path))
         file_uri = svn.core.svn_path_canonicalize(abs_path)
 
         start_rev = svn_opt_revision_value_t(0)
         peg_rev = svn_opt_revision_value_t(revision)
         end_rev = peg_rev
 
         annotations = []
 
         def receiver(line_no, revision, author, date, line, pool):
             annotations.append((line_no, revision, line))
 
         # TODO: Cannot use blame5, missing typemap function in the swig code
         try:
             svn.client.blame2(
                 file_uri, peg_rev, start_rev, end_rev,
                 receiver, svn.client.create_context())
         except svn.core.SubversionException as exc:
             log.exception("Error during blame operation.")
             raise Exception(
                 "Blame not supported or file does not exist at path %s. "
                 "Error %s." % (path, exc))
 
         return annotations
 
     def get_node_type(self, wire, path, rev=None):
         repo = self._factory.repo(wire)
         fs_ptr = svn.repos.fs(repo)
         if rev is None:
             rev = svn.fs.youngest_rev(fs_ptr)
         root = svn.fs.revision_root(fs_ptr, rev)
         node = svn.fs.check_path(root, path)
         return NODE_TYPE_MAPPING.get(node, None)
 
     def get_nodes(self, wire, path, revision=None):
         repo = self._factory.repo(wire)
         fsobj = svn.repos.fs(repo)
         if revision is None:
             revision = svn.fs.youngest_rev(fsobj)
         root = svn.fs.revision_root(fsobj, revision)
         entries = svn.fs.dir_entries(root, path)
         result = []
         for entry_path, entry_info in entries.iteritems():
             result.append(
                 (entry_path, NODE_TYPE_MAPPING.get(entry_info.kind, None)))
         return result
 
     def get_file_content(self, wire, path, rev=None):
         repo = self._factory.repo(wire)
         fsobj = svn.repos.fs(repo)
         if rev is None:
             rev = svn.fs.youngest_revision(fsobj)
         root = svn.fs.revision_root(fsobj, rev)
         content = svn.core.Stream(svn.fs.file_contents(root, path))
         return content.read()
 
     def get_file_size(self, wire, path, revision=None):
         repo = self._factory.repo(wire)
         fsobj = svn.repos.fs(repo)
         if revision is None:
             revision = svn.fs.youngest_revision(fsobj)
         root = svn.fs.revision_root(fsobj, revision)
         size = svn.fs.file_length(root, path)
         return size
 
     def create_repository(self, wire, compatible_version=None):
         log.info('Creating Subversion repository in path "%s"', wire['path'])
         self._factory.repo(wire, create=True,
                            compatible_version=compatible_version)
 
     def import_remote_repository(self, wire, src_url):
         repo_path = wire['path']
         if not self.is_path_valid_repository(wire, repo_path):
             raise Exception(
                 "Path %s is not a valid Subversion repository." % repo_path)
 
         # TODO: johbo: URL checks ?
         import subprocess
         rdump = subprocess.Popen(
             ['svnrdump', 'dump', '--non-interactive', src_url],
             stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         load = subprocess.Popen(
             ['svnadmin', 'load', repo_path], stdin=rdump.stdout)
 
         # TODO: johbo: This can be a very long operation, might be better
         # to track some kind of status and provide an api to check if the
         # import is done.
         rdump.wait()
         load.wait()
 
         if rdump.returncode != 0:
             errors = rdump.stderr.read()
             log.error('svnrdump dump failed: statuscode %s: message: %s',
                       rdump.returncode, errors)
             reason = 'UNKNOWN'
             if 'svnrdump: E230001:' in errors:
                 reason = 'INVALID_CERTIFICATE'
             raise Exception(
                 'Failed to dump the remote repository from %s.' % src_url,
                 reason)
         if load.returncode != 0:
             raise Exception(
                 'Failed to load the dump of remote repository from %s.' %
                 (src_url, ))
 
     def commit(self, wire, message, author, timestamp, updated, removed):
         assert isinstance(message, str)
         assert isinstance(author, str)
 
         repo = self._factory.repo(wire)
         fsobj = svn.repos.fs(repo)
 
         rev = svn.fs.youngest_rev(fsobj)
         txn = svn.repos.fs_begin_txn_for_commit(repo, rev, author, message)
         txn_root = svn.fs.txn_root(txn)
 
         for node in updated:
             TxnNodeProcessor(node, txn_root).update()
         for node in removed:
             TxnNodeProcessor(node, txn_root).remove()
 
         commit_id = svn.repos.fs_commit_txn(repo, txn)
 
         if timestamp:
             apr_time = apr_time_t(timestamp)
             ts_formatted = svn.core.svn_time_to_cstring(apr_time)
             svn.fs.change_rev_prop(fsobj, commit_id, 'svn:date', ts_formatted)
 
         log.debug('Committed revision "%s" to "%s".', commit_id, wire['path'])
         return commit_id
 
     def diff(self, wire, rev1, rev2, path1=None, path2=None,
              ignore_whitespace=False, context=3):
 
         wire.update(cache=False)
         repo = self._factory.repo(wire)
         diff_creator = SvnDiffer(
             repo, rev1, path1, rev2, path2, ignore_whitespace, context)
         try:
             return diff_creator.generate_diff()
         except svn.core.SubversionException as e:
             log.exception(
                 "Error during diff operation operation. "
                 "Path might not exist %s, %s" % (path1, path2))
             return ""
 
     @reraise_safe_exceptions
     def is_large_file(self, wire, path):
         return False
 
     @reraise_safe_exceptions
     def install_hooks(self, wire, force=False):
         from vcsserver.hook_utils import install_svn_hooks
         repo_path = wire['path']
         binary_dir = settings.BINARY_DIR
         executable = None
         if binary_dir:
             executable = os.path.join(binary_dir, 'python')
         return install_svn_hooks(
             repo_path, executable=executable, force_create=force)
 
 
 class SvnDiffer(object):
     """
     Utility to create diffs based on difflib and the Subversion api
     """
 
     binary_content = False
 
     def __init__(
             self, repo, src_rev, src_path, tgt_rev, tgt_path,
             ignore_whitespace, context):
         self.repo = repo
         self.ignore_whitespace = ignore_whitespace
         self.context = context
 
         fsobj = svn.repos.fs(repo)
 
         self.tgt_rev = tgt_rev
         self.tgt_path = tgt_path or ''
         self.tgt_root = svn.fs.revision_root(fsobj, tgt_rev)
         self.tgt_kind = svn.fs.check_path(self.tgt_root, self.tgt_path)
 
         self.src_rev = src_rev
         self.src_path = src_path or self.tgt_path
         self.src_root = svn.fs.revision_root(fsobj, src_rev)
         self.src_kind = svn.fs.check_path(self.src_root, self.src_path)
 
         self._validate()
 
     def _validate(self):
         if (self.tgt_kind != svn.core.svn_node_none and
                 self.src_kind != svn.core.svn_node_none and
                 self.src_kind != self.tgt_kind):
             # TODO: johbo: proper error handling
             raise Exception(
                 "Source and target are not compatible for diff generation. "
                 "Source type: %s, target type: %s" %
                 (self.src_kind, self.tgt_kind))
 
     def generate_diff(self):
         buf = StringIO.StringIO()
         if self.tgt_kind == svn.core.svn_node_dir:
             self._generate_dir_diff(buf)
         else:
             self._generate_file_diff(buf)
         return buf.getvalue()
 
     def _generate_dir_diff(self, buf):
         editor = DiffChangeEditor()
         editor_ptr, editor_baton = svn.delta.make_editor(editor)
         svn.repos.dir_delta2(
             self.src_root,
             self.src_path,
             '',  # src_entry
             self.tgt_root,
             self.tgt_path,
             editor_ptr, editor_baton,
             authorization_callback_allow_all,
             False,  # text_deltas
             svn.core.svn_depth_infinity,  # depth
             False,  # entry_props
             False,  # ignore_ancestry
         )
 
         for path, __, change in sorted(editor.changes):
             self._generate_node_diff(
                 buf, change, path, self.tgt_path, path, self.src_path)
 
     def _generate_file_diff(self, buf):
         change = None
         if self.src_kind == svn.core.svn_node_none:
             change = "add"
         elif self.tgt_kind == svn.core.svn_node_none:
             change = "delete"
         tgt_base, tgt_path = vcspath.split(self.tgt_path)
         src_base, src_path = vcspath.split(self.src_path)
         self._generate_node_diff(
             buf, change, tgt_path, tgt_base, src_path, src_base)
 
     def _generate_node_diff(
             self, buf, change, tgt_path, tgt_base, src_path, src_base):
 
         if self.src_rev == self.tgt_rev and tgt_base == src_base:
             # makes consistent behaviour with git/hg to return empty diff if
             # we compare same revisions
             return
 
         tgt_full_path = vcspath.join(tgt_base, tgt_path)
         src_full_path = vcspath.join(src_base, src_path)
 
         self.binary_content = False
         mime_type = self._get_mime_type(tgt_full_path)
 
         if mime_type and not mime_type.startswith('text'):
             self.binary_content = True
             buf.write("=" * 67 + '\n')
             buf.write("Cannot display: file marked as a binary type.\n")
             buf.write("svn:mime-type = %s\n" % mime_type)
         buf.write("Index: %s\n" % (tgt_path, ))
         buf.write("=" * 67 + '\n')
         buf.write("diff --git a/%(tgt_path)s b/%(tgt_path)s\n" % {
             'tgt_path': tgt_path})
 
         if change == 'add':
             # TODO: johbo: SVN is missing a zero here compared to git
             buf.write("new file mode 10644\n")
 
             #TODO(marcink): intro to binary detection of svn patches
             # if self.binary_content:
             #     buf.write('GIT binary patch\n')
 
             buf.write("--- /dev/null\t(revision 0)\n")
             src_lines = []
         else:
             if change == 'delete':
                 buf.write("deleted file mode 10644\n")
 
             #TODO(marcink): intro to binary detection of svn patches
             # if self.binary_content:
             #     buf.write('GIT binary patch\n')
 
             buf.write("--- a/%s\t(revision %s)\n" % (
                 src_path, self.src_rev))
             src_lines = self._svn_readlines(self.src_root, src_full_path)
 
         if change == 'delete':
             buf.write("+++ /dev/null\t(revision %s)\n" % (self.tgt_rev, ))
             tgt_lines = []
         else:
             buf.write("+++ b/%s\t(revision %s)\n" % (
                 tgt_path, self.tgt_rev))
             tgt_lines = self._svn_readlines(self.tgt_root, tgt_full_path)
 
         if not self.binary_content:
             udiff = svn_diff.unified_diff(
                 src_lines, tgt_lines, context=self.context,
                 ignore_blank_lines=self.ignore_whitespace,
                 ignore_case=False,
                 ignore_space_changes=self.ignore_whitespace)
             buf.writelines(udiff)
 
     def _get_mime_type(self, path):
         try:
             mime_type = svn.fs.node_prop(
                 self.tgt_root, path, svn.core.SVN_PROP_MIME_TYPE)
         except svn.core.SubversionException:
             mime_type = svn.fs.node_prop(
                 self.src_root, path, svn.core.SVN_PROP_MIME_TYPE)
         return mime_type
 
     def _svn_readlines(self, fs_root, node_path):
         if self.binary_content:
             return []
         node_kind = svn.fs.check_path(fs_root, node_path)
         if node_kind not in (
                 svn.core.svn_node_file, svn.core.svn_node_symlink):
             return []
         content = svn.core.Stream(
             svn.fs.file_contents(fs_root, node_path)).read()
         return content.splitlines(True)
 
 
 
 class DiffChangeEditor(svn.delta.Editor):
     """
     Records changes between two given revisions
     """
 
     def __init__(self):
         self.changes = []
 
     def delete_entry(self, path, revision, parent_baton, pool=None):
         self.changes.append((path, None, 'delete'))
 
     def add_file(
             self, path, parent_baton, copyfrom_path, copyfrom_revision,
             file_pool=None):
         self.changes.append((path, 'file', 'add'))
 
     def open_file(self, path, parent_baton, base_revision, file_pool=None):
         self.changes.append((path, 'file', 'change'))
 
 
 def authorization_callback_allow_all(root, path, pool):
     return True
 
 
 class TxnNodeProcessor(object):
     """
     Utility to process the change of one node within a transaction root.
 
     It encapsulates the knowledge of how to add, update or remove
     a node for a given transaction root. The purpose is to support the method
     `SvnRemote.commit`.
     """
 
     def __init__(self, node, txn_root):
         assert isinstance(node['path'], str)
 
         self.node = node
         self.txn_root = txn_root
 
     def update(self):
         self._ensure_parent_dirs()
         self._add_file_if_node_does_not_exist()
         self._update_file_content()
         self._update_file_properties()
 
     def remove(self):
         svn.fs.delete(self.txn_root, self.node['path'])
         # TODO: Clean up directory if empty
 
     def _ensure_parent_dirs(self):
         curdir = vcspath.dirname(self.node['path'])
         dirs_to_create = []
         while not self._svn_path_exists(curdir):
             dirs_to_create.append(curdir)
             curdir = vcspath.dirname(curdir)
 
         for curdir in reversed(dirs_to_create):
             log.debug('Creating missing directory "%s"', curdir)
             svn.fs.make_dir(self.txn_root, curdir)
 
     def _svn_path_exists(self, path):
         path_status = svn.fs.check_path(self.txn_root, path)
         return path_status != svn.core.svn_node_none
 
     def _add_file_if_node_does_not_exist(self):
         kind = svn.fs.check_path(self.txn_root, self.node['path'])
         if kind == svn.core.svn_node_none:
             svn.fs.make_file(self.txn_root, self.node['path'])
 
     def _update_file_content(self):
         assert isinstance(self.node['content'], str)
         handler, baton = svn.fs.apply_textdelta(
             self.txn_root, self.node['path'], None, None)
         svn.delta.svn_txdelta_send_string(self.node['content'], handler, baton)
 
     def _update_file_properties(self):
         properties = self.node.get('properties', {})
         for key, value in properties.iteritems():
             svn.fs.change_node_prop(
                 self.txn_root, self.node['path'], key, value)
 
 
 def apr_time_t(timestamp):
     """
     Convert a Python timestamp into APR timestamp type apr_time_t
     """
     return timestamp * 1E6
 
 
 def svn_opt_revision_value_t(num):
     """
     Put `num` into a `svn_opt_revision_value_t` structure.
     """
     value = svn.core.svn_opt_revision_value_t()
     value.number = num
     revision = svn.core.svn_opt_revision_t()
     revision.kind = svn.core.svn_opt_revision_number
     revision.value = value
     return revision

vcsserver/tests/conftest.py

@@ -1,58 +1,57 b''
 # RhodeCode VCSServer provides access to different vcs backends via network.
 # Copyright (C) 2014-2018 RhodeCode GmbH
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 
 import socket
 
 import pytest
 
 
 def pytest_addoption(parser):
     parser.addoption(
         '--repeat', type=int, default=100,
         help="Number of repetitions in performance tests.")
 
 
 @pytest.fixture(scope='session')
 def repeat(request):
     """
     The number of repetitions is based on this fixture.
 
     Slower calls may divide it by 10 or 100. It is chosen in a way so that the
     tests are not too slow in our default test suite.
     """
     return request.config.getoption('--repeat')
 
 
 @pytest.fixture(scope='session')
 def vcsserver_port(request):
     port = get_available_port()
-    print 'Using vcsserver port %s' % (port, )
+    print('Using vcsserver port %s' % (port, ))
     return port
 
 
 def get_available_port():
     family = socket.AF_INET
     socktype = socket.SOCK_STREAM
     host = '127.0.0.1'
 
     mysocket = socket.socket(family, socktype)
     mysocket.bind((host, 0))
     port = mysocket.getsockname()[1]
     mysocket.close()
     del mysocket
     return port
-

vcsserver/tests/test_git.py

@@ -1,162 +1,165 b''
 # RhodeCode VCSServer provides access to different vcs backends via network.
 # Copyright (C) 2014-2018 RhodeCode GmbH
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 
 import inspect
 
 import pytest
 import dulwich.errors
 from mock import Mock, patch
 
 from vcsserver import git
 
 
 SAMPLE_REFS = {
     'HEAD': 'fd627b9e0dd80b47be81af07c4a98518244ed2f7',
     'refs/tags/v0.1.9': '341d28f0eec5ddf0b6b77871e13c2bbd6bec685c',
     'refs/tags/v0.1.8': '74ebce002c088b8a5ecf40073db09375515ecd68',
     'refs/tags/v0.1.1': 'e6ea6d16e2f26250124a1f4b4fe37a912f9d86a0',
     'refs/tags/v0.1.3': '5a3a8fb005554692b16e21dee62bf02667d8dc3e',
 }
 
 
 @pytest.fixture
 def git_remote():
     """
     A GitRemote instance with a mock factory.
     """
     factory = Mock()
     remote = git.GitRemote(factory)
     return remote
 
 
 def test_discover_git_version(git_remote):
     version = git_remote.discover_git_version()
     assert version
 
 
 class TestGitFetch(object):
     def setup(self):
         self.mock_repo = Mock()
         factory = Mock()
         factory.repo = Mock(return_value=self.mock_repo)
         self.remote_git = git.GitRemote(factory)
 
     def test_fetches_all_when_no_commit_ids_specified(self):
         def side_effect(determine_wants, *args, **kwargs):
             determine_wants(SAMPLE_REFS)
 
         with patch('dulwich.client.LocalGitClient.fetch') as mock_fetch:
             mock_fetch.side_effect = side_effect
             self.remote_git.fetch(wire=None, url='/tmp/', apply_refs=False)
             determine_wants = self.mock_repo.object_store.determine_wants_all
             determine_wants.assert_called_once_with(SAMPLE_REFS)
 
     def test_fetches_specified_commits(self):
         selected_refs = {
             'refs/tags/v0.1.8': '74ebce002c088b8a5ecf40073db09375515ecd68',
             'refs/tags/v0.1.3': '5a3a8fb005554692b16e21dee62bf02667d8dc3e',
         }
 
         def side_effect(determine_wants, *args, **kwargs):
             result = determine_wants(SAMPLE_REFS)
             assert sorted(result) == sorted(selected_refs.values())
             return result
 
         with patch('dulwich.client.LocalGitClient.fetch') as mock_fetch:
             mock_fetch.side_effect = side_effect
             self.remote_git.fetch(
                 wire=None, url='/tmp/', apply_refs=False,
                 refs=selected_refs.keys())
             determine_wants = self.mock_repo.object_store.determine_wants_all
             assert determine_wants.call_count == 0
 
     def test_get_remote_refs(self):
         factory = Mock()
         remote_git = git.GitRemote(factory)
         url = 'http://example.com/test/test.git'
         sample_refs = {
             'refs/tags/v0.1.8': '74ebce002c088b8a5ecf40073db09375515ecd68',
             'refs/tags/v0.1.3': '5a3a8fb005554692b16e21dee62bf02667d8dc3e',
         }
 
         with patch('vcsserver.git.Repo', create=False) as mock_repo:
             mock_repo().get_refs.return_value = sample_refs
             remote_refs = remote_git.get_remote_refs(wire=None, url=url)
             mock_repo().get_refs.assert_called_once_with()
             assert remote_refs == sample_refs
 
     def test_remove_ref(self):
         ref_to_remove = 'refs/tags/v0.1.9'
         self.mock_repo.refs = SAMPLE_REFS.copy()
         self.remote_git.remove_ref(None, ref_to_remove)
         assert ref_to_remove not in self.mock_repo.refs
 
 
 class TestReraiseSafeExceptions(object):
     def test_method_decorated_with_reraise_safe_exceptions(self):
         factory = Mock()
         git_remote = git.GitRemote(factory)
 
         def fake_function():
             return None
 
         decorator = git.reraise_safe_exceptions(fake_function)
 
         methods = inspect.getmembers(git_remote, predicate=inspect.ismethod)
         for method_name, method in methods:
             if not method_name.startswith('_'):
                 assert method.im_func.__code__ == decorator.__code__
 
     @pytest.mark.parametrize('side_effect, expected_type', [
         (dulwich.errors.ChecksumMismatch('0000000', 'deadbeef'), 'lookup'),
         (dulwich.errors.NotCommitError('deadbeef'), 'lookup'),
         (dulwich.errors.MissingCommitError('deadbeef'), 'lookup'),
         (dulwich.errors.ObjectMissing('deadbeef'), 'lookup'),
         (dulwich.errors.HangupException(), 'error'),
         (dulwich.errors.UnexpectedCommandError('test-cmd'), 'error'),
     ])
     def test_safe_exceptions_reraised(self, side_effect, expected_type):
         @git.reraise_safe_exceptions
         def fake_method():
             raise side_effect
 
         with pytest.raises(Exception) as exc_info:
             fake_method()
         assert type(exc_info.value) == Exception
         assert exc_info.value._vcs_kind == expected_type
 
 
 class TestDulwichRepoWrapper(object):
     def test_calls_close_on_delete(self):
         isdir_patcher = patch('dulwich.repo.os.path.isdir', return_value=True)
         with isdir_patcher:
             repo = git.Repo('/tmp/abcde')
         with patch.object(git.DulwichRepo, 'close') as close_mock:
             del repo
         close_mock.assert_called_once_with()
 
 
 class TestGitFactory(object):
     def test_create_repo_returns_dulwich_wrapper(self):
-        factory = git.GitFactory(repo_cache=Mock())
-        wire = {
-            'path': '/tmp/abcde'
-        }
-        isdir_patcher = patch('dulwich.repo.os.path.isdir', return_value=True)
-        with isdir_patcher:
-            result = factory._create_repo(wire, True)
-        assert isinstance(result, git.Repo)
+
+        with patch('vcsserver.lib.rc_cache.region_meta.dogpile_cache_regions') as mock:
+            mock.side_effect = {'repo_objects': ''}
+            factory = git.GitFactory()
+            wire = {
+                'path': '/tmp/abcde'
+            }
+            isdir_patcher = patch('dulwich.repo.os.path.isdir', return_value=True)
+            with isdir_patcher:
+                result = factory._create_repo(wire, True)
+            assert isinstance(result, git.Repo)

vcsserver/tests/test_hg.py

@@ -1,127 +1,127 b''
 # RhodeCode VCSServer provides access to different vcs backends via network.
 # Copyright (C) 2014-2018 RhodeCode GmbH
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 
 import inspect
 import sys
 import traceback
 
 import pytest
 from mercurial.error import LookupError
 from mock import Mock, MagicMock, patch
 
 from vcsserver import exceptions, hg, hgcompat
 
 
 class TestHGLookup(object):
     def setup(self):
         self.mock_repo = MagicMock()
         self.mock_repo.__getitem__.side_effect = LookupError(
             'revision_or_commit_id', 'index', 'message')
         factory = Mock()
         factory.repo = Mock(return_value=self.mock_repo)
         self.remote_hg = hg.HgRemote(factory)
 
     def test_fail_lookup_hg(self):
         with pytest.raises(Exception) as exc_info:
             self.remote_hg.lookup(
                 wire=None, revision='revision_or_commit_id', both=True)
 
         assert exc_info.value._vcs_kind == 'lookup'
         assert 'revision_or_commit_id' in exc_info.value.args
 
 
 class TestDiff(object):
     def test_raising_safe_exception_when_lookup_failed(self):
         repo = Mock()
         factory = Mock()
         factory.repo = Mock(return_value=repo)
         hg_remote = hg.HgRemote(factory)
         with patch('mercurial.patch.diff') as diff_mock:
             diff_mock.side_effect = LookupError(
                 'deadbeef', 'index', 'message')
             with pytest.raises(Exception) as exc_info:
                 hg_remote.diff(
                     wire=None, rev1='deadbeef', rev2='deadbee1',
                     file_filter=None, opt_git=True, opt_ignorews=True,
                     context=3)
             assert type(exc_info.value) == Exception
             assert exc_info.value._vcs_kind == 'lookup'
 
 
 class TestReraiseSafeExceptions(object):
     def test_method_decorated_with_reraise_safe_exceptions(self):
         factory = Mock()
         hg_remote = hg.HgRemote(factory)
         methods = inspect.getmembers(hg_remote, predicate=inspect.ismethod)
         decorator = hg.reraise_safe_exceptions(None)
         for method_name, method in methods:
             if not method_name.startswith('_'):
                 assert method.im_func.__code__ == decorator.__code__
 
     @pytest.mark.parametrize('side_effect, expected_type', [
         (hgcompat.Abort(), 'abort'),
         (hgcompat.InterventionRequired(), 'abort'),
         (hgcompat.RepoLookupError(), 'lookup'),
         (hgcompat.LookupError('deadbeef', 'index', 'message'), 'lookup'),
         (hgcompat.RepoError(), 'error'),
         (hgcompat.RequirementError(), 'requirement'),
     ])
     def test_safe_exceptions_reraised(self, side_effect, expected_type):
         @hg.reraise_safe_exceptions
         def fake_method():
             raise side_effect
 
         with pytest.raises(Exception) as exc_info:
             fake_method()
         assert type(exc_info.value) == Exception
         assert exc_info.value._vcs_kind == expected_type
 
     def test_keeps_original_traceback(self):
         @hg.reraise_safe_exceptions
         def fake_method():
             try:
                 raise hgcompat.Abort()
             except:
                 self.original_traceback = traceback.format_tb(
                     sys.exc_info()[2])
                 raise
 
         try:
             fake_method()
         except Exception:
             new_traceback = traceback.format_tb(sys.exc_info()[2])
 
         new_traceback_tail = new_traceback[-len(self.original_traceback):]
         assert new_traceback_tail == self.original_traceback
 
     def test_maps_unknow_exceptions_to_unhandled(self):
         @hg.reraise_safe_exceptions
         def stub_method():
             raise ValueError('stub')
 
         with pytest.raises(Exception) as exc_info:
             stub_method()
         assert exc_info.value._vcs_kind == 'unhandled'
 
     def test_does_not_map_known_exceptions(self):
         @hg.reraise_safe_exceptions
         def stub_method():
-            raise exceptions.LookupException('stub')
+            raise exceptions.LookupException()('stub')
 
         with pytest.raises(Exception) as exc_info:
             stub_method()
         assert exc_info.value._vcs_kind == 'lookup'

vcsserver/tests/test_hgpatches.py

@@ -1,130 +1,124 b''
 # RhodeCode VCSServer provides access to different vcs backends via network.
 # Copyright (C) 2014-2018 RhodeCode GmbH
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 
 import mock
 import pytest
 
 from vcsserver import hgcompat, hgpatches
 
 
 LARGEFILES_CAPABILITY = 'largefiles=serve'
 
 
 def test_patch_largefiles_capabilities_applies_patch(
         patched_capabilities):
     lfproto = hgcompat.largefiles.proto
     hgpatches.patch_largefiles_capabilities()
-    assert lfproto.capabilities.func_name == '_dynamic_capabilities'
+    assert lfproto._capabilities.func_name == '_dynamic_capabilities'
 
 
 def test_dynamic_capabilities_uses_original_function_if_not_enabled(
-        stub_repo, stub_proto, stub_ui, stub_extensions, patched_capabilities):
+        stub_repo, stub_proto, stub_ui, stub_extensions, patched_capabilities,
+        orig_capabilities):
     dynamic_capabilities = hgpatches._dynamic_capabilities_wrapper(
         hgcompat.largefiles.proto, stub_extensions)
 
-    caps = dynamic_capabilities(stub_repo, stub_proto)
+    caps = dynamic_capabilities(orig_capabilities, stub_repo, stub_proto)
 
     stub_extensions.assert_called_once_with(stub_ui)
     assert LARGEFILES_CAPABILITY not in caps
 
 
-def test_dynamic_capabilities_uses_updated_capabilitiesorig(
-        stub_repo, stub_proto, stub_ui, stub_extensions, patched_capabilities):
-    dynamic_capabilities = hgpatches._dynamic_capabilities_wrapper(
-        hgcompat.largefiles.proto, stub_extensions)
-
-    # This happens when the extension is loaded for the first time, important
-    # to ensure that an updated function is correctly picked up.
-    hgcompat.largefiles.proto.capabilitiesorig = mock.Mock(
-        return_value='REPLACED')
-
-    caps = dynamic_capabilities(stub_repo, stub_proto)
-    assert 'REPLACED' == caps
-
-
 def test_dynamic_capabilities_ignores_updated_capabilities(
-        stub_repo, stub_proto, stub_ui, stub_extensions, patched_capabilities):
+        stub_repo, stub_proto, stub_ui, stub_extensions, patched_capabilities,
+        orig_capabilities):
     stub_extensions.return_value = [('largefiles', mock.Mock())]
     dynamic_capabilities = hgpatches._dynamic_capabilities_wrapper(
         hgcompat.largefiles.proto, stub_extensions)
 
     # This happens when the extension is loaded for the first time, important
     # to ensure that an updated function is correctly picked up.
-    hgcompat.largefiles.proto.capabilities = mock.Mock(
+    hgcompat.largefiles.proto._capabilities = mock.Mock(
         side_effect=Exception('Must not be called'))
 
-    dynamic_capabilities(stub_repo, stub_proto)
+    dynamic_capabilities(orig_capabilities, stub_repo, stub_proto)
 
 
 def test_dynamic_capabilities_uses_largefiles_if_enabled(
-        stub_repo, stub_proto, stub_ui, stub_extensions, patched_capabilities):
+        stub_repo, stub_proto, stub_ui, stub_extensions, patched_capabilities,
+        orig_capabilities):
     stub_extensions.return_value = [('largefiles', mock.Mock())]
 
     dynamic_capabilities = hgpatches._dynamic_capabilities_wrapper(
         hgcompat.largefiles.proto, stub_extensions)
 
-    caps = dynamic_capabilities(stub_repo, stub_proto)
+    caps = dynamic_capabilities(orig_capabilities, stub_repo, stub_proto)
 
     stub_extensions.assert_called_once_with(stub_ui)
     assert LARGEFILES_CAPABILITY in caps
 
 
 def test_hgsubversion_import():
     from hgsubversion import svnrepo
     assert svnrepo
 
 
 @pytest.fixture
 def patched_capabilities(request):
     """
     Patch in `capabilitiesorig` and restore both capability functions.
     """
     lfproto = hgcompat.largefiles.proto
-    orig_capabilities = lfproto.capabilities
-    orig_capabilitiesorig = lfproto.capabilitiesorig
-
-    lfproto.capabilitiesorig = mock.Mock(return_value='ORIG')
+    orig_capabilities = lfproto._capabilities
 
     @request.addfinalizer
     def restore():
-        lfproto.capabilities = orig_capabilities
-        lfproto.capabilitiesorig = orig_capabilitiesorig
+        lfproto._capabilities = orig_capabilities
 
 
 @pytest.fixture
 def stub_repo(stub_ui):
     repo = mock.Mock()
     repo.ui = stub_ui
     return repo
 
 
 @pytest.fixture
 def stub_proto(stub_ui):
     proto = mock.Mock()
     proto.ui = stub_ui
     return proto
 
 
 @pytest.fixture
+def orig_capabilities():
+    from mercurial.wireprotov1server import wireprotocaps
+
+    def _capabilities(repo, proto):
+        return wireprotocaps
+    return _capabilities
+
+
[e-mail]
 def stub_ui():
     return hgcompat.ui.ui()
 
 
 @pytest.fixture
 def stub_extensions():
     extensions = mock.Mock(return_value=tuple())
     return extensions

vcsserver/tests/test_http_performance.py

@@ -1,44 +1,39 b''
 """
 Tests used to profile the HTTP based implementation.
 """
 
 import pytest
 import webtest
 
 from vcsserver.http_main import main
 
 
 @pytest.fixture
 def vcs_app():
     stub_settings = {
         'dev.use_echo_app': 'true',
-        'beaker.cache.regions': 'repo_object',
-        'beaker.cache.repo_object.type': 'memorylru',
-        'beaker.cache.repo_object.max_items': '100',
-        'beaker.cache.repo_object.expire': '300',
-        'beaker.cache.repo_object.enabled': 'true',
         'locale': 'en_US.UTF-8',
     }
     vcs_app = main({}, **stub_settings)
     app = webtest.TestApp(vcs_app)
     return app
 
 
 @pytest.fixture(scope='module')
 def data():
     one_kb = 'x' * 1024
     return one_kb * 1024 * 10
 
 
 def test_http_app_streaming_with_data(data, repeat, vcs_app):
     app = vcs_app
     for x in xrange(repeat / 10):
         response = app.post('/stream/git/', params=data)
         assert response.status_code == 200
 
 
 def test_http_app_streaming_no_data(repeat, vcs_app):
     app = vcs_app
     for x in xrange(repeat / 10):
         response = app.post('/stream/git/')
         assert response.status_code == 200

vcsserver/utils.py

@@ -1,82 +1,89 b''
 # RhodeCode VCSServer provides access to different vcs backends via network.
 # Copyright (C) 2014-2018 RhodeCode GmbH
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 import logging
+import hashlib
 
 log = logging.getLogger(__name__)
 
 
 def safe_int(val, default=None):
     """
     Returns int() of val if val is not convertable to int use default
     instead
 
     :param val:
     :param default:
     """
 
     try:
         val = int(val)
     except (ValueError, TypeError):
         val = default
 
     return val
 
 
 def safe_str(unicode_, to_encoding=['utf8']):
     """
     safe str function. Does few trick to turn unicode_ into string
 
     In case of UnicodeEncodeError, we try to return it with encoding detected
     by chardet library if it fails fallback to string with errors replaced
 
     :param unicode_: unicode to encode
     :rtype: str
     :returns: str object
     """
 
     # if it's not basestr cast to str
     if not isinstance(unicode_, basestring):
         return str(unicode_)
 
     if isinstance(unicode_, str):
         return unicode_
 
     if not isinstance(to_encoding, (list, tuple)):
         to_encoding = [to_encoding]
 
     for enc in to_encoding:
         try:
             return unicode_.encode(enc)
         except UnicodeEncodeError:
             pass
 
     try:
         import chardet
         encoding = chardet.detect(unicode_)['encoding']
         if encoding is None:
             raise UnicodeEncodeError()
 
         return unicode_.encode(encoding)
     except (ImportError, UnicodeEncodeError):
         return unicode_.encode(to_encoding[0], 'replace')
 
 
 class AttributeDict(dict):
     def __getattr__(self, attr):
         return self.get(attr, None)
     __setattr__ = dict.__setitem__
     __delattr__ = dict.__delitem__
+
+
+def sha1(val):
+    return hashlib.sha1(val).hexdigest()
+
+