release: merge back stable branch into default

pkgs/patches/pytest/setuptools.patch

@@ -0,0 +1,12 b''
+diff -rup pytest-4.6.5-orig/setup.py pytest-4.6.5/setup.py
+--- pytest-4.6.5-orig/setup.py	2018-04-10 10:23:04.000000000 +0200
++++  pytest-4.6.5/setup.py	2018-04-10 10:23:34.000000000 +0200
+@@ -24,7 +24,7 @@ INSTALL_REQUIRES = [
+ def main():
+     setup(
+         use_scm_version={"write_to": "src/_pytest/_version.py"},
+-        setup_requires=["setuptools-scm", "setuptools>=40.0"],
++        setup_requires=["setuptools-scm", "setuptools<=42.0"],
+         package_dir={"": "src"},
+         # fmt: off
+         extras_require={
  No newline at end of file

vcsserver/lib/_vendor/__init__.py

@@ -0,0 +1,26 b''
+# RhodeCode VCSServer provides access to different vcs backends via network.
+# Copyright (C) 2014-2020 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
+
+# This package contains non rhodecode licensed packages that are
+# vendored for various reasons
+
+import os
+import sys
+
+vendor_dir = os.path.abspath(os.path.dirname(__file__))
+
+sys.path.append(vendor_dir)

vcsserver/lib/_vendor/statsd/__init__.py

@@ -0,0 +1,46 b''
+from __future__ import absolute_import, division, unicode_literals
+
+import logging
+
+from .stream import TCPStatsClient, UnixSocketStatsClient  # noqa
+from .udp import StatsClient  # noqa
+
+HOST = 'localhost'
+PORT = 8125
+IPV6 = False
+PREFIX = None
+MAXUDPSIZE = 512
+
+log = logging.getLogger('rhodecode.statsd')
+
+
+def statsd_config(config, prefix='statsd.'):
+    _config = {}
+    for key in config.keys():
+        if key.startswith(prefix):
+            _config[key[len(prefix):]] = config[key]
+    return _config
+
+
+def client_from_config(configuration, prefix='statsd.', **kwargs):
+    from pyramid.settings import asbool
+
+    _config = statsd_config(configuration, prefix)
+    statsd_enabled = asbool(_config.pop('enabled', False))
+    if not statsd_enabled:
+        log.debug('statsd client not enabled by statsd.enabled =  flag, skipping...')
+        return
+
+    host = _config.pop('statsd_host', HOST)
+    port = _config.pop('statsd_port', PORT)
+    prefix = _config.pop('statsd_prefix', PREFIX)
+    maxudpsize = _config.pop('statsd_maxudpsize', MAXUDPSIZE)
+    ipv6 = asbool(_config.pop('statsd_ipv6', IPV6))
+    log.debug('configured statsd client %s:%s', host, port)
+
+    return StatsClient(
+        host=host, port=port, prefix=prefix, maxudpsize=maxudpsize, ipv6=ipv6)
+
+
+def get_statsd_client(request):
+    return client_from_config(request.registry.settings)

vcsserver/lib/_vendor/statsd/base.py

@@ -0,0 +1,107 b''
+from __future__ import absolute_import, division, unicode_literals
+
+import random
+from collections import deque
+from datetime import timedelta
+
+from .timer import Timer
+
+
+class StatsClientBase(object):
+    """A Base class for various statsd clients."""
+
+    def close(self):
+        """Used to close and clean up any underlying resources."""
+        raise NotImplementedError()
+
+    def _send(self):
+        raise NotImplementedError()
+
+    def pipeline(self):
+        raise NotImplementedError()
+
+    def timer(self, stat, rate=1):
+        return Timer(self, stat, rate)
+
+    def timing(self, stat, delta, rate=1):
+        """
+        Send new timing information.
+
+        `delta` can be either a number of milliseconds or a timedelta.
+        """
+        if isinstance(delta, timedelta):
+            # Convert timedelta to number of milliseconds.
+            delta = delta.total_seconds() * 1000.
+        self._send_stat(stat, '%0.6f|ms' % delta, rate)
+
+    def incr(self, stat, count=1, rate=1):
+        """Increment a stat by `count`."""
+        self._send_stat(stat, '%s|c' % count, rate)
+
+    def decr(self, stat, count=1, rate=1):
+        """Decrement a stat by `count`."""
+        self.incr(stat, -count, rate)
+
+    def gauge(self, stat, value, rate=1, delta=False):
+        """Set a gauge value."""
+        if value < 0 and not delta:
+            if rate < 1:
+                if random.random() > rate:
+                    return
+            with self.pipeline() as pipe:
+                pipe._send_stat(stat, '0|g', 1)
+                pipe._send_stat(stat, '%s|g' % value, 1)
+        else:
+            prefix = '+' if delta and value >= 0 else ''
+            self._send_stat(stat, '%s%s|g' % (prefix, value), rate)
+
+    def set(self, stat, value, rate=1):
+        """Set a set value."""
+        self._send_stat(stat, '%s|s' % value, rate)
+
+    def _send_stat(self, stat, value, rate):
+        self._after(self._prepare(stat, value, rate))
+
+    def _prepare(self, stat, value, rate):
+        if rate < 1:
+            if random.random() > rate:
+                return
+            value = '%s|@%s' % (value, rate)
+
+        if self._prefix:
+            stat = '%s.%s' % (self._prefix, stat)
+
+        return '%s:%s' % (stat, value)
+
+    def _after(self, data):
+        if data:
+            self._send(data)
+
+
+class PipelineBase(StatsClientBase):
+
+    def __init__(self, client):
+        self._client = client
+        self._prefix = client._prefix
+        self._stats = deque()
+
+    def _send(self):
+        raise NotImplementedError()
+
+    def _after(self, data):
+        if data is not None:
+            self._stats.append(data)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, typ, value, tb):
+        self.send()
+
+    def send(self):
+        if not self._stats:
+            return
+        self._send()
+
+    def pipeline(self):
+        return self.__class__(self)

vcsserver/lib/_vendor/statsd/stream.py

@@ -0,0 +1,75 b''
+from __future__ import absolute_import, division, unicode_literals
+
+import socket
+
+from .base import StatsClientBase, PipelineBase
+
+
+class StreamPipeline(PipelineBase):
+    def _send(self):
+        self._client._after('\n'.join(self._stats))
+        self._stats.clear()
+
+
+class StreamClientBase(StatsClientBase):
+    def connect(self):
+        raise NotImplementedError()
+
+    def close(self):
+        if self._sock and hasattr(self._sock, 'close'):
+            self._sock.close()
+        self._sock = None
+
+    def reconnect(self):
+        self.close()
+        self.connect()
+
+    def pipeline(self):
+        return StreamPipeline(self)
+
+    def _send(self, data):
+        """Send data to statsd."""
+        if not self._sock:
+            self.connect()
+        self._do_send(data)
+
+    def _do_send(self, data):
+        self._sock.sendall(data.encode('ascii') + b'\n')
+
+
+class TCPStatsClient(StreamClientBase):
+    """TCP version of StatsClient."""
+
+    def __init__(self, host='localhost', port=8125, prefix=None,
+                 timeout=None, ipv6=False):
+        """Create a new client."""
+        self._host = host
+        self._port = port
+        self._ipv6 = ipv6
+        self._timeout = timeout
+        self._prefix = prefix
+        self._sock = None
+
+    def connect(self):
+        fam = socket.AF_INET6 if self._ipv6 else socket.AF_INET
+        family, _, _, _, addr = socket.getaddrinfo(
+            self._host, self._port, fam, socket.SOCK_STREAM)[0]
+        self._sock = socket.socket(family, socket.SOCK_STREAM)
+        self._sock.settimeout(self._timeout)
+        self._sock.connect(addr)
+
+
+class UnixSocketStatsClient(StreamClientBase):
+    """Unix domain socket version of StatsClient."""
+
+    def __init__(self, socket_path, prefix=None, timeout=None):
+        """Create a new client."""
+        self._socket_path = socket_path
+        self._timeout = timeout
+        self._prefix = prefix
+        self._sock = None
+
+    def connect(self):
+        self._sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        self._sock.settimeout(self._timeout)
+        self._sock.connect(self._socket_path)

vcsserver/lib/_vendor/statsd/timer.py

@@ -0,0 +1,71 b''
+from __future__ import absolute_import, division, unicode_literals
+
+import functools
+
+# Use timer that's not susceptible to time of day adjustments.
+try:
+    # perf_counter is only present on Py3.3+
+    from time import perf_counter as time_now
+except ImportError:
+    # fall back to using time
+    from time import time as time_now
+
+
+def safe_wraps(wrapper, *args, **kwargs):
+    """Safely wraps partial functions."""
+    while isinstance(wrapper, functools.partial):
+        wrapper = wrapper.func
+    return functools.wraps(wrapper, *args, **kwargs)
+
+
+class Timer(object):
+    """A context manager/decorator for statsd.timing()."""
+
+    def __init__(self, client, stat, rate=1):
+        self.client = client
+        self.stat = stat
+        self.rate = rate
+        self.ms = None
+        self._sent = False
+        self._start_time = None
+
+    def __call__(self, f):
+        """Thread-safe timing function decorator."""
+        @safe_wraps(f)
+        def _wrapped(*args, **kwargs):
+            start_time = time_now()
+            try:
+                return f(*args, **kwargs)
+            finally:
+                elapsed_time_ms = 1000.0 * (time_now() - start_time)
+                self.client.timing(self.stat, elapsed_time_ms, self.rate)
+        return _wrapped
+
+    def __enter__(self):
+        return self.start()
+
+    def __exit__(self, typ, value, tb):
+        self.stop()
+
+    def start(self):
+        self.ms = None
+        self._sent = False
+        self._start_time = time_now()
+        return self
+
+    def stop(self, send=True):
+        if self._start_time is None:
+            raise RuntimeError('Timer has not started.')
+        dt = time_now() - self._start_time
+        self.ms = 1000.0 * dt  # Convert to milliseconds.
+        if send:
+            self.send()
+        return self
+
+    def send(self):
+        if self.ms is None:
+            raise RuntimeError('No data recorded.')
+        if self._sent:
+            raise RuntimeError('Already sent data.')
+        self._sent = True
+        self.client.timing(self.stat, self.ms, self.rate)

vcsserver/lib/_vendor/statsd/udp.py

@@ -0,0 +1,55 b''
+from __future__ import absolute_import, division, unicode_literals
+
+import socket
+
+from .base import StatsClientBase, PipelineBase
+
+
+class Pipeline(PipelineBase):
+
+    def __init__(self, client):
+        super(Pipeline, self).__init__(client)
+        self._maxudpsize = client._maxudpsize
+
+    def _send(self):
+        data = self._stats.popleft()
+        while self._stats:
+            # Use popleft to preserve the order of the stats.
+            stat = self._stats.popleft()
+            if len(stat) + len(data) + 1 >= self._maxudpsize:
+                self._client._after(data)
+                data = stat
+            else:
+                data += '\n' + stat
+        self._client._after(data)
+
+
+class StatsClient(StatsClientBase):
+    """A client for statsd."""
+
+    def __init__(self, host='localhost', port=8125, prefix=None,
+                 maxudpsize=512, ipv6=False):
+        """Create a new client."""
+        fam = socket.AF_INET6 if ipv6 else socket.AF_INET
+        family, _, _, _, addr = socket.getaddrinfo(
+            host, port, fam, socket.SOCK_DGRAM)[0]
+        self._addr = addr
+        self._sock = socket.socket(family, socket.SOCK_DGRAM)
+        self._prefix = prefix
+        self._maxudpsize = maxudpsize
+
+    def _send(self, data):
+        """Send data to statsd."""
+        try:
+            self._sock.sendto(data.encode('ascii'), self._addr)
+        except (socket.error, RuntimeError):
+            # No time for love, Dr. Jones!
+            pass
+
+    def close(self):
+        if self._sock and hasattr(self._sock, 'close'):
+            self._sock.close()
+        self._sock = None
+
+    def pipeline(self):
+        return Pipeline(self)

.hgtags

@@ -1,74 +1,76 b''
 c6fad7d1e61f22b1f4a4863eff207a04c27e9462 v4.0.0
 77b6e243b4cc5b702c15abd6d737798edbac60dc v4.0.1
 a359c072337fdd8e1e71df72cc520b8a9b042f80 v4.1.0
 49aa7ed030a36b7ceba149a21e587cb5d20b4946 v4.1.1
 f38ed1e1a31dce3c170b4d31585ba43471cf0705 v4.1.2
 21269ba7bafd8f0c77e79dd86a31eb9bce7643d2 v4.2.0
 b53930c918c25b2c8f69ceddc6641e511be27fd3 v4.2.1
 6627ff4119723d8b2b60918e8b1aa49e9f055aab v4.3.0
 d38f2c2b861dde6c4178923f7cf15ea58b85aa92 v4.3.1
 1232313f9e6adac5ce5399c2a891dc1e72b79022 v4.4.0
 cbb9f1d329ae5768379cdec55a62ebdd546c4e27 v4.4.1
 24ffe44a27fcd1c5b6936144e176b9f6dd2f3a17 v4.4.2
 beaeeaa440cd17471110d4621b8816506c0dff4a v4.5.0
 668e5c656f61dd94595611844e1106d1361aa6a7 v4.5.1
 ae0640240cb7a77e6dc8c77e64dd80d79732cb5b v4.5.2
 7af06899f426813583fe60449d7517cc49c15b28 v4.6.0
 8f7f4299bf341b43f94dadafa1ea73d6cea2c9ba v4.6.1
 de00a831a0709ffaac57f948738ea927b97223a9 v4.7.0
 57f527e0646d731768fb5e0fe742b12a35bdc63b v4.7.1
 f9b09787da9845e4a105f4bffdc252099902cefb v4.7.2
 0b7c790b726f08385e6ebdf4f257c905787b9244 v4.8.0
 f4123e725b74d0e82fe89982ab8791a66062e2b3 v4.9.0
 940bac044a0fe1ec839759df81399b50141be720 v4.9.1
 582d9ebbe46bdddac4b26eacae36ee5ecabca267 v4.10.0
 12fbd08d0ab57acce9c0bdccee75633cfa08d7f4 v4.10.1
 78352f95021a9d128f5803fdbca7036daef5dabe v4.10.2
 a47ccfb020cda78c8680e3844aaf0b82b1390f3b v4.10.3
 347ae9ae544bba8deb417995285287a3b6be1611 v4.10.4
 9b257ac49841f850434be0d518baca0827e6c8cc v4.10.5
 e8bf26eea118694edc4ffe50c6c5aa91022bc434 v4.10.6
 71fa9274ba59fb982104f0b9b3d0d024c78675f7 v4.11.0
 92471577ef25636e5babe8001d47fc8e51521522 v4.11.1
 0277edbcda5a8d075e1e41a95bcee6dcf21f3f77 v4.11.2
 6c5ecbf0778ef870e5b23d9fad5340135b563356 v4.11.3
 be788a89a939ebd63606220064bd624fa9d5c9c9 v4.11.4
 15c90a04098a373ac761fab07695fd80dde3bcdb v4.11.5
 77aff155b3251cc00394a49f5e8f2c99e33149a7 v4.11.6
 c218a1ce5d370c2e671d42a91684b3fc2c91b81d v4.12.0
 80085fb846cc948195a5c76b579ca34cbc49b59b v4.12.1
 346f04fc8a18df3235defbe6e71bd552c0d46481 v4.12.2
 764fdd752322f3e0c13ea00957f2d548bf4363a7 v4.12.3
 b58038974a5cecbb9c100d32ad2e4c68582f1a78 v4.12.4
 e1d42d92a0fec0c80b56c82f37bc7b5472613706 v4.13.0
 c3ded3ff17e9bb2a47002a808984a7a946f58a1c v4.13.1
 7ff81aa47b1b40cdef9dd5bcdd439f59c269db3d v4.13.2
 628a08e6aaeff2c3f9e0e268e854f870e6778e53 v4.13.3
 941d675f10cfa7d774815bfacfb37085751b7a0d v4.14.0
 75e11d32c0be0a457198f07888e7ef650cfa6888 v4.14.1
 6c6f49fda0191c4641dcd43aa0d4376b8b728d40 v4.15.0
 184dea5e01c36e6474c83d3bb34719cdfec22b0d v4.15.1
 a4dc3669345553582296b2ce1485229a6c6f0522 v4.15.2
 d2a4a1a66f204668841da1cdccfa29083e1ef7a3 v4.16.0
 744cf8f2c8f23051978fc293404bf475cc5a31f6 v4.16.1
 e68aff93ce4ad11fea13420e914f7dfb05c39566 v4.16.2
 647aeff9752dc1aa00796fa280d0d2ce2f511bc9 v4.17.0
 5e0c2990e095bba1dc903cf0e6ef6ac035e0ccf9 v4.17.1
 8a824544d95037d76d99b104b5d2363858101d53 v4.17.2
 ccd806a2d9482f61bd7e8956a02a28eb24a1d46a v4.17.3
 e533ca02ccc205189b7bad9f227a312212772022 v4.17.4
 ba6a6dc9ecd7fd8b1dcd6eb0c4ee0210e897c426 v4.18.0
 17bc818b41bcf6883b9ff0da31f01d8c2a5d0781 v4.18.1
 1e9f12aa01f82c335abc9017efe94ce1c30b52ba v4.18.2
 f4cc6b3c5680bdf4541d7d442fbb7086640fb547 v4.18.3
 5dc0277e4f77bd4cc3042d99625bb5d3ba480c8c v4.19.0
 3a815eeb1b1efa340dda9b81a8da3cf24a7d605b v4.19.1
 8841da3680fba841e5a54ebccd8ca56c078f7553 v4.19.2
 4b0dec7fd80b1ca38e5073e5e562a5a450f73669 v4.19.3
 1485aa75ffe1b1ec48352dce7b7492d92f85e95f v4.20.0
 5b740274011766ef2f73803cc196d081e1e7f1d4 v4.20.1
 5a7835234e2c45e8fb8184c60f548a64b5842af8 v4.21.0
 26af88343015f8b89d5a66f92bc7547c51fcf0df v4.22.0
 cf54e5f700fe5dc50af1a1bdf5197c18cf52105f v4.23.0
 179d989bcfe02c6227f9f6aa9236cbbe1c14c400 v4.23.1
 383aee8b1652affaa26aefe336a89ee366b2b26d v4.23.2
+bc1a8141cc51fc23c455ebc50c6609c810b46f8d v4.24.0
+530a1c03caabc806ea1ef34605f8f67f18c70e55 v4.24.1

configs/development.ini

@@ -1,237 +1,243 b''
 ## -*- coding: utf-8 -*-
 
 ; #################################
 ; RHODECODE VCSSERVER CONFIGURATION
 ; #################################
 
 [server:main]
 ; COMMON HOST/IP CONFIG
 host = 0.0.0.0
 port = 9900
 
 ; ##################################################
 ; WAITRESS WSGI SERVER - Recommended for Development
 ; ##################################################
 
 ; use server type
 use = egg:waitress#main
 
 ; number of worker threads
 threads = 5
 
 ; MAX BODY SIZE 100GB
 max_request_body_size = 107374182400
 
 ; Use poll instead of select, fixes file descriptors limits problems.
 ; May not work on old windows systems.
 asyncore_use_poll = true
 
 
 ; ###########################
 ; GUNICORN APPLICATION SERVER
 ; ###########################
 
 ; run with gunicorn --log-config rhodecode.ini --paste rhodecode.ini
 
 ; Module to use, this setting shouldn't be changed
 #use = egg:gunicorn#main
 
 ; Sets the number of process workers. More workers means more concurrent connections
 ; RhodeCode can handle at the same time. Each additional worker also it increases
 ; memory usage as each has it's own set of caches.
 ; Recommended value is (2 * NUMBER_OF_CPUS + 1), eg 2CPU = 5 workers, but no more
 ; than 8-10 unless for really big deployments .e.g 700-1000 users.
 ; `instance_id = *` must be set in the [app:main] section below (which is the default)
 ; when using more than 1 worker.
 #workers = 2
 
 ; Gunicorn access log level
 #loglevel = info
 
 ; Process name visible in process list
 #proc_name = rhodecode_vcsserver
 
 ; Type of worker class, one of `sync`, `gevent`
 ; 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.
 ; Prevents memory leaks, jitter adds variability so not all workers are restarted at once.
 #max_requests = 1000
 #max_requests_jitter = 30
 
 ; Amount of time a worker can spend with handling a request before it
 ; gets killed and restarted. By default set to 21600 (6hrs)
 ; Examples: 1800 (30min), 3600 (1hr), 7200 (2hr), 43200 (12h)
 #timeout = 21600
 
 ; The maximum size of HTTP request line in bytes.
 ; 0 for unlimited
 #limit_request_line = 0
 
 ; Limit the number of HTTP headers fields in a request.
 ; By default this value is 100 and can't be larger than 32768.
 #limit_request_fields = 32768
 
 ; 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.
 ; Examples: 1800 (30min), 3600 (1hr), 7200 (2hr), 43200 (12h)
 #graceful_timeout = 3600
 
 # The number of seconds to wait for requests on a Keep-Alive connection.
 # Generally set in the 1-5 seconds range.
 #keepalive = 2
 
 ; Maximum memory usage that each worker can use before it will receive a
 ; graceful restart signal 0 = memory monitoring is disabled
 ; Examples: 268435456 (256MB), 536870912 (512MB)
 ; 1073741824 (1GB), 2147483648 (2GB), 4294967296 (4GB)
 #memory_max_usage = 0
 
 ; How often in seconds to check for memory usage for each gunicorn worker
 #memory_usage_check_interval = 60
 
 ; Threshold value for which we don't recycle worker if GarbageCollection
 ; frees up enough resources. Before each restart we try to run GC on worker
 ; in case we get enough free memory after that, restart will not happen.
 #memory_usage_recovery_threshold = 0.8
 
 
 [app:main]
 ; The %(here)s variable will be replaced with the absolute path of parent directory
 ; of this file
 use = egg:rhodecode-vcsserver
 
 
 ; #############
 ; DEBUG OPTIONS
 ; #############
 
 # During development the we want to have the debug toolbar enabled
 pyramid.includes =
     pyramid_debugtoolbar
 
 debugtoolbar.hosts = 0.0.0.0/0
 debugtoolbar.exclude_prefixes =
     /css
     /fonts
     /images
     /js
 
 ; #################
 ; END DEBUG OPTIONS
 ; #################
 
 ; Pyramid default locales, we need this to be set
 pyramid.default_locale_name = en
 
 ; 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
 ; it can also be a path to nix-build output in case of development
 core.binary_dir = ""
 
 ; Custom exception store path, defaults to TMPDIR
 ; This is used to store exception from RhodeCode in shared directory
 #exception_tracker.store_path =
 
 ; #############
 ; DOGPILE CACHE
 ; #############
 
 ; Default cache dir for caches. Putting this into a ramdisk can boost performance.
 ; eg. /tmpfs/data_ramdisk, however this directory might require large amount of space
 cache_dir = %(here)s/data
 
 ; ***************************************
 ; `repo_object` cache, default file based
 ; ***************************************
 
 ; `repo_object` cache settings for vcs methods for repositories
 rc_cache.repo_object.backend = dogpile.cache.rc.file_namespace
 
 ; cache auto-expires after N seconds
 ; Examples: 86400 (1Day), 604800 (7Days), 1209600 (14Days), 2592000 (30days), 7776000 (90Days)
 rc_cache.repo_object.expiration_time = 2592000
 
 ; file cache store path. Defaults to `cache_dir =` value or tempdir if both values are not set
 #rc_cache.repo_object.arguments.filename = /tmp/vcsserver_cache.db
 
 ; ***********************************************************
 ; `repo_object` cache with redis backend
 ; recommended for larger instance, and for better performance
 ; ***********************************************************
 
 ; `repo_object` cache settings for vcs methods for repositories
 #rc_cache.repo_object.backend = dogpile.cache.rc.redis_msgpack
 
 ; cache auto-expires after N seconds
 ; Examples: 86400 (1Day), 604800 (7Days), 1209600 (14Days), 2592000 (30days), 7776000 (90Days)
 #rc_cache.repo_object.expiration_time = 2592000
 
 ; redis_expiration_time needs to be greater then expiration_time
 #rc_cache.repo_object.arguments.redis_expiration_time = 3592000
 
 #rc_cache.repo_object.arguments.host = localhost
 #rc_cache.repo_object.arguments.port = 6379
 #rc_cache.repo_object.arguments.db = 5
 #rc_cache.repo_object.arguments.socket_timeout = 30
 ; more Redis options: https://dogpilecache.sqlalchemy.org/en/latest/api.html#redis-backends
 #rc_cache.repo_object.arguments.distributed_lock = true
 
+; Statsd client config
+#statsd.enabled = false
+#statsd.statsd_host = 0.0.0.0
+#statsd.statsd_port = 8125
+#statsd.statsd_prefix =
+#statsd.statsd_ipv6 = false
 
 ; #####################
 ; 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,200 +1,206 b''
 ## -*- coding: utf-8 -*-
 
 ; #################################
 ; RHODECODE VCSSERVER CONFIGURATION
 ; #################################
 
 [server:main]
 ; COMMON HOST/IP CONFIG
 host = 127.0.0.1
 port = 9900
 
 
 ; ###########################
 ; GUNICORN APPLICATION SERVER
 ; ###########################
 
 ; run with gunicorn --log-config rhodecode.ini --paste rhodecode.ini
 
 ; Module to use, this setting shouldn't be changed
 use = egg:gunicorn#main
 
 ; Sets the number of process workers. More workers means more concurrent connections
 ; RhodeCode can handle at the same time. Each additional worker also it increases
 ; memory usage as each has it's own set of caches.
 ; Recommended value is (2 * NUMBER_OF_CPUS + 1), eg 2CPU = 5 workers, but no more
 ; than 8-10 unless for really big deployments .e.g 700-1000 users.
 ; `instance_id = *` must be set in the [app:main] section below (which is the default)
 ; when using more than 1 worker.
 workers = 2
 
 ; Gunicorn access log level
 loglevel = info
 
 ; Process name visible in process list
 proc_name = rhodecode_vcsserver
 
 ; Type of worker class, one of `sync`, `gevent`
 ; 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.
 ; Prevents memory leaks, jitter adds variability so not all workers are restarted at once.
 max_requests = 1000
 max_requests_jitter = 30
 
 ; Amount of time a worker can spend with handling a request before it
 ; gets killed and restarted. By default set to 21600 (6hrs)
 ; Examples: 1800 (30min), 3600 (1hr), 7200 (2hr), 43200 (12h)
 timeout = 21600
 
 ; The maximum size of HTTP request line in bytes.
 ; 0 for unlimited
 limit_request_line = 0
 
 ; Limit the number of HTTP headers fields in a request.
 ; By default this value is 100 and can't be larger than 32768.
 limit_request_fields = 32768
 
 ; 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.
 ; Examples: 1800 (30min), 3600 (1hr), 7200 (2hr), 43200 (12h)
 graceful_timeout = 3600
 
 # The number of seconds to wait for requests on a Keep-Alive connection.
 # Generally set in the 1-5 seconds range.
 keepalive = 2
 
 ; Maximum memory usage that each worker can use before it will receive a
 ; graceful restart signal 0 = memory monitoring is disabled
 ; Examples: 268435456 (256MB), 536870912 (512MB)
 ; 1073741824 (1GB), 2147483648 (2GB), 4294967296 (4GB)
 memory_max_usage = 0
 
 ; How often in seconds to check for memory usage for each gunicorn worker
 memory_usage_check_interval = 60
 
 ; Threshold value for which we don't recycle worker if GarbageCollection
 ; frees up enough resources. Before each restart we try to run GC on worker
 ; in case we get enough free memory after that, restart will not happen.
 memory_usage_recovery_threshold = 0.8
 
 
 [app:main]
 ; The %(here)s variable will be replaced with the absolute path of parent directory
 ; of this file
 use = egg:rhodecode-vcsserver
 
 ; Pyramid default locales, we need this to be set
 pyramid.default_locale_name = en
 
 ; 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
 ; it can also be a path to nix-build output in case of development
 core.binary_dir = ""
 
 ; Custom exception store path, defaults to TMPDIR
 ; This is used to store exception from RhodeCode in shared directory
 #exception_tracker.store_path =
 
 ; #############
 ; DOGPILE CACHE
 ; #############
 
 ; Default cache dir for caches. Putting this into a ramdisk can boost performance.
 ; eg. /tmpfs/data_ramdisk, however this directory might require large amount of space
 cache_dir = %(here)s/data
 
 ; ***************************************
 ; `repo_object` cache, default file based
 ; ***************************************
 
 ; `repo_object` cache settings for vcs methods for repositories
 rc_cache.repo_object.backend = dogpile.cache.rc.file_namespace
 
 ; cache auto-expires after N seconds
 ; Examples: 86400 (1Day), 604800 (7Days), 1209600 (14Days), 2592000 (30days), 7776000 (90Days)
 rc_cache.repo_object.expiration_time = 2592000
 
 ; file cache store path. Defaults to `cache_dir =` value or tempdir if both values are not set
 #rc_cache.repo_object.arguments.filename = /tmp/vcsserver_cache.db
 
 ; ***********************************************************
 ; `repo_object` cache with redis backend
 ; recommended for larger instance, and for better performance
 ; ***********************************************************
 
 ; `repo_object` cache settings for vcs methods for repositories
 #rc_cache.repo_object.backend = dogpile.cache.rc.redis_msgpack
 
 ; cache auto-expires after N seconds
 ; Examples: 86400 (1Day), 604800 (7Days), 1209600 (14Days), 2592000 (30days), 7776000 (90Days)
 #rc_cache.repo_object.expiration_time = 2592000
 
 ; redis_expiration_time needs to be greater then expiration_time
 #rc_cache.repo_object.arguments.redis_expiration_time = 3592000
 
 #rc_cache.repo_object.arguments.host = localhost
 #rc_cache.repo_object.arguments.port = 6379
 #rc_cache.repo_object.arguments.db = 5
 #rc_cache.repo_object.arguments.socket_timeout = 30
 ; more Redis options: https://dogpilecache.sqlalchemy.org/en/latest/api.html#redis-backends
 #rc_cache.repo_object.arguments.distributed_lock = true
 
+; Statsd client config
+#statsd.enabled = false
+#statsd.statsd_host = 0.0.0.0
+#statsd.statsd_port = 8125
+#statsd.statsd_prefix =
+#statsd.statsd_ipv6 = false
 
 ; #####################
 ; 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 = INFO
 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

pkgs/overlays.nix

@@ -1,71 +1,83 b''
 self: super: {
 
   # bump GIT version
-  git = super.lib.overrideDerivation super.git (oldAttrs: {
-    name = "git-2.27.0";
+  git =
+  let
+    gitWithoutPerl = super.git.override {
+      #perlSupport = false;
+    };
+  in
+   super.lib.overrideDerivation gitWithoutPerl (oldAttrs: {
+
+    name = "git-2.30.0";
     src = self.fetchurl {
-      url = "https://www.kernel.org/pub/software/scm/git/git-2.27.0.tar.xz";
-      sha256 = "1ybk39ylvs32lywq7ra4l2kdr5izc80r9461hwfnw8pssxs9gjkk";
+      url = "https://www.kernel.org/pub/software/scm/git/git-2.30.0.tar.xz";
+      sha256 = "06ad6dylgla34k9am7d5z8y3rryc8ln3ibq5z0d74rcm20hm0wsm";
     };
 
     # patches come from: https://github.com/NixOS/nixpkgs/tree/master/pkgs/applications/version-management/git-and-tools/git
     patches = [
       ./patches/git/docbook2texi.patch
       ./patches/git/git-sh-i18n.patch
       ./patches/git/ssh-path.patch
       ./patches/git/git-send-email-honor-PATH.patch
       ./patches/git/installCheck-path.patch
     ];
 
+    #preInstallCheck = oldAttrs.preInstallCheck + ''
+    #    disable_test t4129-apply-samemode
+    #    disable_test t5324-split-commit-graph
+    #'';
+
   });
 
   libgit2rc = super.lib.overrideDerivation super.libgit2 (oldAttrs: {
     name = "libgit2-0.28.2";
     version = "0.28.2";
 
     src = self.fetchFromGitHub {
         owner = "libgit2";
         repo = "libgit2";
         rev = "v0.28.2";
         sha256 = "0cm8fvs05rj0baigs2133q5a0sm3pa234y8h6hmwhl2bz9xq3k4b";
     };
 
     cmakeFlags = [ "-DTHREADSAFE=ON" "-DUSE_HTTPS=no"];
 
     buildInputs = [
         super.zlib
         super.libssh2
         super.openssl
         super.curl
     ];
 
 
   });
 
   # 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.13.0";
       src = self.fetchurl {
         url = "https://archive.apache.org/dist/subversion/subversion-1.13.0.tar.gz";
         sha256 = "0cb9p7f5hg0l4k32hz8vmvy2r45igchq5sh4m366za5q0c649bfs";
       };
 
       ## use internal lz4/utf8proc because it is stable and shipped with SVN
       configureFlags = oldAttrs.configureFlags ++ [
         " --with-lz4=internal"
         " --with-utf8proc=internal"
       ];
 
   });
 
 
 }

pkgs/python-packages-overrides.nix

@@ -1,72 +1,78 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
 }:
 
 let
   sed = "sed -i";
 
 in
 
 self: super: {
 
   "cffi" = super."cffi".override (attrs: {
     buildInputs = [
       pkgs.libffi
     ];
   });
 
   "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"
     ];
   });
 
   "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
     ];
   });
 
   "mercurial" = super."mercurial".override (attrs: {
     propagatedBuildInputs = [
       # self.python.modules.curses
     ];
   });
 
   "dulwich" = super."dulwich".override (attrs: {
     patches = [
       ./patches/dulwich/handle-dir-refs.patch
     ];
   });
 
   "pygit2" = super."pygit2".override (attrs: {
     propagatedBuildInputs = attrs.propagatedBuildInputs ++ [
       pkgs.libffi
       pkgs.libgit2rc
     ];
   });
 
+  "pytest" = super."pytest".override (attrs: {
+    patches = [
+      ./patches/pytest/setuptools.patch
+    ];
+  });
+
   # Avoid that base packages screw up the build process
   inherit (basePythonPackages)
     setuptools;
 
 }

vcsserver/http_main.py

@@ -1,700 +1,704 b''
 # RhodeCode VCSServer provides access to different vcs backends via network.
 # Copyright (C) 2014-2020 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
 import tempfile
-import resource
 import psutil
 from itertools import chain
 from cStringIO import StringIO
 
 import simplejson as json
 import msgpack
 from pyramid.config import Configurator
 from pyramid.settings import asbool, aslist
 from pyramid.wsgi import wsgiapp
 from pyramid.compat import configparser
 from pyramid.response import Response
 
 from vcsserver.utils import safe_int
 
 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'
 
 import vcsserver
 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, 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
 
 
 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))
     return settings[name]
 
 
 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)
     return settings[name]
 
 
 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)
     return settings[name]
 
 
 def _string_setting(settings, name, default, lower=True, default_when_empty=False):
     value = settings.get(name, default)
 
     if default_when_empty and not value:
         # use default value when value is empty
         value = default
 
     if lower:
         value = value.lower()
     settings[name] = value
     return settings[name]
 
 
 def log_max_fd():
     try:
         maxfd = psutil.Process().rlimit(psutil.RLIMIT_NOFILE)[1]
         log.info('Max file descriptors value: %s', maxfd)
     except Exception:
         pass
 
 
 class VCS(object):
     def __init__(self, locale_conf=None, cache_config=None):
         self.locale = locale_conf
         self.cache_config = cache_config
         self._configure_locale()
 
         log_max_fd()
 
         if GitFactory and GitRemote:
             git_factory = GitFactory()
             self._git_remote = GitRemote(git_factory)
         else:
             log.info("Git client import failed")
 
         if MercurialFactory and HgRemote:
             hg_factory = MercurialFactory()
             self._hg_remote = HgRemote(hg_factory)
         else:
             log.info("Mercurial client import failed")
 
         if SubversionFactory and SvnRemote:
             svn_factory = SubversionFactory()
 
             # hg factory is used for svn url validation
             hg_factory = MercurialFactory()
             self._svn_remote = SvnRemote(svn_factory, hg_factory=hg_factory)
         else:
             log.info("Subversion client import failed")
 
         self._vcsserver = VcsServer()
 
     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)
 
 
 def not_found(request):
     return {'status': '404 NOT FOUND'}
 
 
 class VCSViewPredicate(object):
     def __init__(self, val, config):
         self.remotes = val
 
     def text(self):
         return 'vcs view method = %s' % (self.remotes.keys(),)
 
     phash = text
 
     def __call__(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
 
 
 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')
 
         settings_locale = settings.get('locale', '') or 'en_US.UTF-8'
         vcs = VCS(locale_conf=settings_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(global_config, settings)
+
         self._configure()
 
     def _configure_settings(self, global_config, app_settings):
         """
         Configure the settings module.
         """
         settings_merged = global_config.copy()
         settings_merged.update(app_settings)
 
         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
 
         # Store the settings to make them available to other modules.
         vcsserver.PYRAMID_SETTINGS = settings_merged
         vcsserver.CONFIG = settings_merged
 
     def _sanitize_settings_and_apply_defaults(self, settings):
         temp_store = tempfile.gettempdir()
         default_cache_dir = os.path.join(temp_store, 'rc_cache')
 
         # save default, cache dir, and use it for all backends later.
         default_cache_dir = _string_setting(
             settings,
             'cache_dir',
             default_cache_dir, lower=False, default_when_empty=True)
 
         # ensure we have our dir created
         if not os.path.isdir(default_cache_dir):
             os.makedirs(default_cache_dir, mode=0o755)
 
         # exception store cache
         _string_setting(
             settings,
             'exception_tracker.store_path',
             temp_store, lower=False, default_when_empty=True)
 
         # repo_object cache
         _string_setting(
             settings,
             'rc_cache.repo_object.backend',
             'dogpile.cache.rc.file_namespace', lower=False)
         _int_setting(
             settings,
             'rc_cache.repo_object.expiration_time',
             30 * 24 * 60 * 60)
         _string_setting(
             settings,
             'rc_cache.repo_object.arguments.filename',
             os.path.join(default_cache_dir, 'vcsserver_cache_1'), lower=False)
 
     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')
 
         # rpc methods
         self.config.add_route('vcs', '/{backend}')
 
         # streaming rpc remote methods
         self.config.add_route('vcs_stream', '/{backend}/stream')
 
         # vcs operations clone/push as streaming
         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',
                              vcs_view=self._remotes)
         self.config.add_view(self.vcs_stream_view, route_name='vcs_stream',
                              vcs_view=self._remotes)
 
         self.config.add_view(self.hg_stream(), route_name='stream_hg')
         self.config.add_view(self.git_stream(), route_name='stream_git')
 
         self.config.add_view_predicate('vcs_view', VCSViewPredicate)
 
         self.config.add_notfound_view(not_found, renderer='json')
 
         self.config.add_view(self.handle_vcs_exception, context=Exception)
 
         self.config.add_tween(
             'vcsserver.tweens.request_wrapper.RequestWrapperTween',
         )
         self.config.add_request_method(
             'vcsserver.lib.request_counter.get_request_counter',
             'request_count')
 
+        self.config.add_request_method(
+            'vcsserver.lib._vendor.statsd.get_statsd_client',
+            'statsd', reify=True)
+
     def wsgi_app(self):
         return self.config.make_wsgi_app()
 
     def _vcs_view_params(self, request):
         remote = self._remotes[request.matchdict['backend']]
         payload = msgpack.unpackb(request.body, use_list=True)
         method = payload.get('method')
         params = payload['params']
         wire = params.get('wire')
         args = params.get('args')
         kwargs = params.get('kwargs')
         context_uid = None
 
         if wire:
             try:
                 wire['context'] = context_uid = uuid.UUID(wire['context'])
             except KeyError:
                 pass
             args.insert(0, wire)
         repo_state_uid = wire.get('repo_state_uid') if wire else None
 
         # NOTE(marcink): trading complexity for slight performance
         if log.isEnabledFor(logging.DEBUG):
             no_args_methods = [
 
             ]
             if method in no_args_methods:
                 call_args = ''
             else:
                 call_args = args[1:]
 
             log.debug('method requested:%s with args:%s kwargs:%s context_uid: %s, repo_state_uid:%s',
                       method, call_args, kwargs, context_uid, repo_state_uid)
 
         return payload, remote, method, args, kwargs
 
     def vcs_view(self, request):
 
         payload, remote, method, args, kwargs = self._vcs_view_params(request)
         payload_id = payload.get('id')
 
         try:
             resp = getattr(remote, method)(*args, **kwargs)
         except Exception as e:
             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
             org_exc_tb = ''
             if org_exc:
                 org_exc_name = org_exc.__class__.__name__
                 org_exc_tb = getattr(e, '_org_exc_tb', '')
                 # replace our "faked" exception with our org
                 exc_info[0] = org_exc.__class__
                 exc_info[1] = org_exc
 
             should_store_exc = True
             if org_exc:
                 def get_exc_fqn(_exc_obj):
                     module_name = getattr(org_exc.__class__, '__module__', 'UNKNOWN')
                     return module_name + '.' + org_exc_name
 
                 exc_fqn = get_exc_fqn(org_exc)
 
                 if exc_fqn in ['mercurial.error.RepoLookupError',
                                'vcsserver.exceptions.RefNotFoundException']:
                     should_store_exc = False
 
             if should_store_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_id,
                 'error': {
                     'message': e.message,
                     'traceback': tb_info,
                     'org_exc': org_exc_name,
                     'org_exc_tb': org_exc_tb,
                     'type': type_
                 }
             }
             try:
                 resp['error']['_vcs_kind'] = getattr(e, '_vcs_kind', None)
             except AttributeError:
                 pass
         else:
             resp = {
                 'id': payload_id,
                 'result': resp
             }
 
         return resp
 
     def vcs_stream_view(self, request):
         payload, remote, method, args, kwargs = self._vcs_view_params(request)
         # this method has a stream: marker we remove it here
         method = method.split('stream:')[-1]
         chunk_size = safe_int(payload.get('chunk_size')) or 4096
 
         try:
             resp = getattr(remote, method)(*args, **kwargs)
         except Exception as e:
             raise
 
         def get_chunked_data(method_resp):
             stream = StringIO(method_resp)
             while 1:
                 chunk = stream.read(chunk_size)
                 if not chunk:
                     break
                 yield chunk
 
         response = Response(app_iter=get_chunked_data(resp))
         response.content_type = 'application/octet-stream'
 
         return response
 
     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)
         server_config, app_config = {}, {}
 
         try:
             path = self.global_config['__file__']
             config = configparser.RawConfigParser()
 
             config.read(path)
 
             if config.has_section('server:main'):
                 server_config = dict(config.items('server:main'))
             if config.has_section('app:main'):
                 app_config = dict(config.items('app:main'))
 
         except Exception:
             log.exception('Failed to read .ini file for display')
 
         environ = os.environ.items()
 
         resp = {
             'id': payload.get('id'),
             'result': dict(
                 version=vcsserver.__version__,
                 config=server_config,
                 app_config=app_config,
                 environ=environ,
                 payload=payload,
             )
         }
         return resp
 
     def _msgpack_renderer_factory(self, info):
         def _render(value, system):
             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 msgpack.packb(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 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)
 
         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/tweens/request_wrapper.py

@@ -1,64 +1,70 b''
 # RhodeCode VCSServer provides access to different vcs backends via network.
 # Copyright (C) 2014-2020 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 time
 import logging
 
 import vcsserver
 from vcsserver.utils import safe_str
 
 
 log = logging.getLogger(__name__)
 
 
 def get_access_path(request):
     environ = request.environ
     return environ.get('PATH_INFO')
 
 
 def get_user_agent(environ):
     return environ.get('HTTP_USER_AGENT')
 
 
 class RequestWrapperTween(object):
     def __init__(self, handler, registry):
         self.handler = handler
         self.registry = registry
 
         # one-time configuration code goes here
 
     def __call__(self, request):
         start = time.time()
+        log.debug('Starting request time measurement')
         try:
             response = self.handler(request)
         finally:
-            end = time.time()
-            total = end - start
             count = request.request_count()
             _ver_ = vcsserver.__version__
+            statsd = request.statsd
+            total = time.time() - start
+            if statsd:
+                statsd.timing('vcsserver.req.timing', total)
+                statsd.incr('vcsserver.req.count')
             log.info(
                 'Req[%4s] IP: %s %s Request to %s time: %.4fs [%s], VCSServer %s',
                 count, '127.0.0.1', request.environ.get('REQUEST_METHOD'),
-                safe_str(get_access_path(request)), total, get_user_agent(request.environ), _ver_)
+                safe_str(get_access_path(request)), total,
+                get_user_agent(request.environ), _ver_
+            )
 
         return response
 
 
 def includeme(config):
     config.add_tween(
         'vcsserver.tweens.request_wrapper.RequestWrapperTween',
     )