subprocess: Change all imports from `subprocess` -> `subprocess32`

rhodecode/lib/vcs/__init__.py

@@ -1,300 +1,300 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2014-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Various version Control System version lib (vcs) management abstraction layer
 for Python. Build with server client architecture.
 """
 
 
 VERSION = (0, 5, 0, 'dev')
 
 __version__ = '.'.join((str(each) for each in VERSION[:4]))
 
 __all__ = [
     'get_version', 'get_vcs_instance', 'get_backend',
     'VCSError', 'RepositoryError', 'CommitError'
     ]
 
 import atexit
 import logging
-import subprocess
+import subprocess32
 import time
 import urlparse
 from cStringIO import StringIO
 
 import Pyro4
 from Pyro4.errors import CommunicationError
 
 from rhodecode.lib.vcs.conf import settings
 from rhodecode.lib.vcs.backends import get_vcs_instance, get_backend
 from rhodecode.lib.vcs.exceptions import (
     VCSError, RepositoryError, CommitError, VCSCommunicationError)
 
 log = logging.getLogger(__name__)
 
 # The pycurl library directly accesses C API functions and is not patched by
 # gevent. This will potentially lead to deadlocks due to incompatibility to
 # gevent. Therefore we check if gevent is active and import a gevent compatible
 # wrapper in that case.
 try:
     from gevent import monkey
     if monkey.is_module_patched('__builtin__'):
         import geventcurl as pycurl
         log.debug('Using gevent comapatible pycurl: %s', pycurl)
     else:
         import pycurl
 except ImportError:
     import pycurl
 
 
 def get_version():
     """
     Returns shorter version (digit parts only) as string.
     """
     return '.'.join((str(each) for each in VERSION[:3]))
 
 
 def connect_pyro4(server_and_port):
     from rhodecode.lib.vcs import connection, client
     from rhodecode.lib.middleware.utils import scm_app
 
     git_remote = client.RequestScopeProxyFactory(
         settings.pyro_remote(settings.PYRO_GIT, server_and_port))
     hg_remote = client.RequestScopeProxyFactory(
         settings.pyro_remote(settings.PYRO_HG, server_and_port))
     svn_remote = client.RequestScopeProxyFactory(
         settings.pyro_remote(settings.PYRO_SVN, server_and_port))
 
     connection.Git = client.RepoMaker(proxy_factory=git_remote)
     connection.Hg = client.RepoMaker(proxy_factory=hg_remote)
     connection.Svn = client.RepoMaker(proxy_factory=svn_remote)
 
     scm_app.GIT_REMOTE_WSGI = Pyro4.Proxy(
         settings.pyro_remote(
             settings.PYRO_GIT_REMOTE_WSGI, server_and_port))
     scm_app.HG_REMOTE_WSGI = Pyro4.Proxy(
         settings.pyro_remote(
             settings.PYRO_HG_REMOTE_WSGI, server_and_port))
 
     @atexit.register
     def free_connection_resources():
         connection.Git = None
         connection.Hg = None
         connection.Svn = None
 
 
 def connect_http(server_and_port):
     from rhodecode.lib.vcs import connection, client_http
     from rhodecode.lib.middleware.utils import scm_app
 
     session_factory = client_http.ThreadlocalSessionFactory()
 
     connection.Git = client_http.RepoMaker(
         server_and_port, '/git', session_factory)
     connection.Hg = client_http.RepoMaker(
         server_and_port, '/hg', session_factory)
     connection.Svn = client_http.RepoMaker(
         server_and_port, '/svn', session_factory)
 
     scm_app.HG_REMOTE_WSGI = client_http.VcsHttpProxy(
         server_and_port, '/proxy/hg')
     scm_app.GIT_REMOTE_WSGI = client_http.VcsHttpProxy(
         server_and_port, '/proxy/git')
 
     @atexit.register
     def free_connection_resources():
         connection.Git = None
         connection.Hg = None
         connection.Svn = None
 
 
 def connect_vcs(server_and_port, protocol):
     """
     Initializes the connection to the vcs server.
 
     :param server_and_port: str, e.g. "localhost:9900"
     :param protocol: str, "pyro4" or "http"
     """
     if protocol == 'pyro4':
         connect_pyro4(server_and_port)
     elif protocol == 'http':
         connect_http(server_and_port)
     else:
         raise Exception('Invalid vcs server protocol "{}"'.format(protocol))
 
 
 # TODO: johbo: This function should be moved into our test suite, there is
 # no reason to support starting the vcsserver in Enterprise itself.
 def start_vcs_server(server_and_port, protocol, log_level=None):
     """
     Starts the vcs server in a subprocess.
     """
     log.info('Starting VCSServer as a sub process with %s protocol', protocol)
     if protocol == 'http':
         return _start_http_vcs_server(server_and_port, log_level)
     elif protocol == 'pyro4':
         return _start_pyro4_vcs_server(server_and_port, log_level)
     else:
         raise Exception('Invalid vcs server protocol "{}"'.format(protocol))
 
 
 def _start_pyro4_vcs_server(server_and_port, log_level=None):
     _try_to_shutdown_running_server(server_and_port, protocol='pyro4')
     host, port = server_and_port.rsplit(":", 1)
     host = host.strip('[]')
     args = [
         'vcsserver', '--port', port, '--host', host, '--locale', 'en_US.UTF-8',
         '--threadpool', '32']
     if log_level:
         args += ['--log-level', log_level]
-    proc = subprocess.Popen(args)
+    proc = subprocess32.Popen(args)
 
     def cleanup_server_process():
         proc.kill()
     atexit.register(cleanup_server_process)
 
     server = create_vcsserver_proxy(server_and_port, protocol='pyro4')
     _wait_until_vcs_server_is_reachable(server)
 
 
 def _start_http_vcs_server(server_and_port, log_level=None):
     # TODO: mikhail: shutdown if an http server already runs
 
     host, port = server_and_port.rsplit(":", 1)
     args = [
         'pserve', 'rhodecode/tests/vcsserver_http.ini',
         'http_port=%s' % (port, ), 'http_host=%s' % (host, )]
-    proc = subprocess.Popen(args)
+    proc = subprocess32.Popen(args)
 
     def cleanup_server_process():
         proc.kill()
     atexit.register(cleanup_server_process)
 
     server = create_vcsserver_proxy(server_and_port, protocol='http')
     _wait_until_vcs_server_is_reachable(server)
 
 
 def _wait_until_vcs_server_is_reachable(server, timeout=40):
     begin = time.time()
     while (time.time() - begin) < timeout:
         try:
             server.ping()
             return
         except (VCSCommunicationError, CommunicationError, pycurl.error):
             log.debug('VCSServer not started yet, retry to connect.')
         time.sleep(0.5)
     raise Exception(
         'Starting the VCSServer failed or took more than {} '
         'seconds.'.format(timeout))
 
 
 def _try_to_shutdown_running_server(server_and_port, protocol):
     server = create_vcsserver_proxy(server_and_port, protocol)
     try:
         server.shutdown()
     except (CommunicationError, pycurl.error):
         return
 
     # TODO: Not sure why this is important, but without it the following start
     # of the server fails.
     server = create_vcsserver_proxy(server_and_port, protocol)
     server.ping()
 
 
 def create_vcsserver_proxy(server_and_port, protocol):
     if protocol == 'pyro4':
         return _create_vcsserver_proxy_pyro4(server_and_port)
     elif protocol == 'http':
         return _create_vcsserver_proxy_http(server_and_port)
     else:
         raise Exception('Invalid vcs server protocol "{}"'.format(protocol))
 
 
 def _create_vcsserver_proxy_pyro4(server_and_port):
     server = Pyro4.Proxy(
         settings.pyro_remote(settings.PYRO_VCSSERVER, server_and_port))
     return server
 
 
 def _create_vcsserver_proxy_http(server_and_port):
     from rhodecode.lib.vcs import client_http
 
     session = _create_http_rpc_session()
     url = urlparse.urljoin('http://%s' % server_and_port, '/server')
     return client_http.RemoteObject(url, session)
 
 
 class CurlSession(object):
     """
     Modeled so that it provides a subset of the requests interface.
 
     This has been created so that it does only provide a minimal API for our
     needs. The parts which it provides are based on the API of the library
     `requests` which allows us to easily benchmark against it.
 
     Please have a look at the class :class:`requests.Session` when you extend
     it.
     """
 
     def __init__(self):
         curl = pycurl.Curl()
         # TODO: johbo: I did test with 7.19 of libcurl. This version has
         # trouble with 100 - continue being set in the expect header. This
         # can lead to massive performance drops, switching it off here.
         curl.setopt(curl.HTTPHEADER, ["Expect:"])
         curl.setopt(curl.TCP_NODELAY, True)
         curl.setopt(curl.PROTOCOLS, curl.PROTO_HTTP)
         self._curl = curl
 
     def post(self, url, data, allow_redirects=False):
         response_buffer = StringIO()
 
         curl = self._curl
         curl.setopt(curl.URL, url)
         curl.setopt(curl.POST, True)
         curl.setopt(curl.POSTFIELDS, data)
         curl.setopt(curl.FOLLOWLOCATION, allow_redirects)
         curl.setopt(curl.WRITEDATA, response_buffer)
         curl.perform()
 
         return CurlResponse(response_buffer)
 
 
 class CurlResponse(object):
     """
     The response of a request, modeled after the requests API.
 
     This class provides a subset of the response interface known from the
     library `requests`. It is intentionally kept similar, so that we can use
     `requests` as a drop in replacement for benchmarking purposes.
     """
 
     def __init__(self, response_buffer):
         self._response_buffer = response_buffer
 
     @property
     def content(self):
         return self._response_buffer.getvalue()
 
 
 def _create_http_rpc_session():
     session = CurlSession()
     return session

rhodecode/rcserver.py

@@ -1,1025 +1,1025 b''
 # (c) 2005 Ian Bicking and contributors; written for Paste
 # (http://pythonpaste.org) Licensed under the MIT license:
 # http://www.opensource.org/licenses/mit-license.php
 #
 # For discussion of daemonizing:
 # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/278731
 #
 # Code taken also from QP: http://www.mems-exchange.org/software/qp/ From
 # lib/site.py
 
 import atexit
 import errno
 import fnmatch
 import logging
 import optparse
 import os
 import re
-import subprocess
+import subprocess32
 import sys
 import textwrap
 import threading
 import time
 import traceback
 
 from logging.config import fileConfig
 import ConfigParser as configparser
 from paste.deploy import loadserver
 from paste.deploy import loadapp
 
 import rhodecode
 from rhodecode.lib.compat import kill
 
 
 def make_web_build_callback(filename):
-    p = subprocess.Popen('make web-build', shell=True,
-                         stdout=subprocess.PIPE,
-                         stderr=subprocess.PIPE,
+    p = subprocess32.Popen('make web-build', shell=True,
+                         stdout=subprocess32.PIPE,
+                         stderr=subprocess32.PIPE,
                          cwd=os.path.dirname(os.path.dirname(__file__)))
     stdout, stderr = p.communicate()
     stdout = ''.join(stdout)
     stderr = ''.join(stderr)
     if stdout:
         print stdout
     if stderr:
         print ('%s %s %s' % ('-' * 20, 'ERRORS', '-' * 20))
         print stderr
 
 
 MAXFD = 1024
 HERE = os.path.dirname(os.path.abspath(__file__))
 SERVER_RUNNING_FILE = None
 
 
 # watch those extra files for changes, server gets restarted if file changes
 GLOBAL_EXTRA_FILES = {
     'rhodecode/public/css/*.less': make_web_build_callback,
     'rhodecode/public/js/src/**/*.js': make_web_build_callback,
 }
 
 
 
 ## HOOKS - inspired by gunicorn #
 
 def when_ready(server):
     """
     Called just after the server is started.
     """
 
     def _remove_server_running_file():
         if os.path.isfile(SERVER_RUNNING_FILE):
             os.remove(SERVER_RUNNING_FILE)
 
     if SERVER_RUNNING_FILE:
         with open(SERVER_RUNNING_FILE, 'wb') as f:
             f.write(str(os.getpid()))
         # register cleanup of that file when server exits
         atexit.register(_remove_server_running_file)
 
 
 def setup_logging(config_uri, fileConfig=fileConfig,
                   configparser=configparser):
     """
     Set up logging via the logging module's fileConfig function with the
     filename specified via ``config_uri`` (a string in the form
     ``filename#sectionname``).
 
     ConfigParser defaults are specified for the special ``__file__``
     and ``here`` variables, similar to PasteDeploy config loading.
     """
     path, _ = _getpathsec(config_uri, None)
     parser = configparser.ConfigParser()
     parser.read([path])
     if parser.has_section('loggers'):
         config_file = os.path.abspath(path)
         return fileConfig(
             config_file,
             {'__file__': config_file, 'here': os.path.dirname(config_file)}
             )
 
 
 def set_rhodecode_is_test(config_uri):
     """If is_test is defined in the config file sets rhodecode.is_test."""
     path, _ = _getpathsec(config_uri, None)
     parser = configparser.ConfigParser()
     parser.read(path)
     rhodecode.is_test = (
         parser.has_option('app:main', 'is_test') and
         parser.getboolean('app:main', 'is_test'))
 
 
 def _getpathsec(config_uri, name):
     if '#' in config_uri:
         path, section = config_uri.split('#', 1)
     else:
         path, section = config_uri, 'main'
     if name:
         section = name
     return path, section
 
 
 def parse_vars(args):
     """
     Given variables like ``['a=b', 'c=d']`` turns it into ``{'a':
     'b', 'c': 'd'}``
     """
     result = {}
     for arg in args:
         if '=' not in arg:
             raise ValueError(
                 'Variable assignment %r invalid (no "=")'
                 % arg)
         name, value = arg.split('=', 1)
         result[name] = value
     return result
 
 
 def _match_pattern(filename):
     for pattern in GLOBAL_EXTRA_FILES:
         if fnmatch.fnmatch(filename, pattern):
             return pattern
     return False
 
 
 def generate_extra_file_list():
 
     extra_list = []
     for root, dirs, files in os.walk(HERE, topdown=True):
         for fname in files:
             stripped_src = os.path.join(
                 'rhodecode', os.path.relpath(os.path.join(root, fname), HERE))
 
             if _match_pattern(stripped_src):
                 extra_list.append(stripped_src)
 
     return extra_list
 
 
 def run_callback_for_pattern(filename):
     pattern = _match_pattern(filename)
     if pattern:
         _file_callback = GLOBAL_EXTRA_FILES.get(pattern)
         if callable(_file_callback):
             _file_callback(filename)
 
 
 class DaemonizeException(Exception):
     pass
 
 
 class RcServerCommand(object):
 
     usage = '%prog config_uri [start|stop|restart|status] [var=value]'
     description = """\
     This command serves a web application that uses a PasteDeploy
     configuration file for the server and application.
 
     If start/stop/restart is given, then --daemon is implied, and it will
     start (normal operation), stop (--stop-daemon), or do both.
 
     You can also include variable assignments like 'http_port=8080'
     and then use %(http_port)s in your config files.
     """
     default_verbosity = 1
 
     parser = optparse.OptionParser(
         usage,
         description=textwrap.dedent(description)
         )
     parser.add_option(
         '-n', '--app-name',
         dest='app_name',
         metavar='NAME',
         help="Load the named application (default main)")
     parser.add_option(
         '-s', '--server',
         dest='server',
         metavar='SERVER_TYPE',
         help="Use the named server.")
     parser.add_option(
         '--server-name',
         dest='server_name',
         metavar='SECTION_NAME',
         help=("Use the named server as defined in the configuration file "
               "(default: main)"))
     parser.add_option(
         '--with-vcsserver',
         dest='vcs_server',
         action='store_true',
         help=("Start the vcsserver instance together with the RhodeCode server"))
     if hasattr(os, 'fork'):
         parser.add_option(
             '--daemon',
             dest="daemon",
             action="store_true",
             help="Run in daemon (background) mode")
     parser.add_option(
         '--pid-file',
         dest='pid_file',
         metavar='FILENAME',
         help=("Save PID to file (default to pyramid.pid if running in "
               "daemon mode)"))
     parser.add_option(
         '--running-file',
         dest='running_file',
         metavar='RUNNING_FILE',
         help="Create a running file after the server is initalized with "
              "stored PID of process")
     parser.add_option(
         '--log-file',
         dest='log_file',
         metavar='LOG_FILE',
         help="Save output to the given log file (redirects stdout)")
     parser.add_option(
         '--reload',
         dest='reload',
         action='store_true',
         help="Use auto-restart file monitor")
     parser.add_option(
         '--reload-interval',
         dest='reload_interval',
         default=1,
         help=("Seconds between checking files (low number can cause "
               "significant CPU usage)"))
     parser.add_option(
         '--monitor-restart',
         dest='monitor_restart',
         action='store_true',
         help="Auto-restart server if it dies")
     parser.add_option(
         '--status',
         action='store_true',
         dest='show_status',
         help="Show the status of the (presumably daemonized) server")
     parser.add_option(
         '-v', '--verbose',
         default=default_verbosity,
         dest='verbose',
         action='count',
         help="Set verbose level (default "+str(default_verbosity)+")")
     parser.add_option(
         '-q', '--quiet',
         action='store_const',
         const=0,
         dest='verbose',
         help="Suppress verbose output")
 
     if hasattr(os, 'setuid'):
         # I don't think these are available on Windows
         parser.add_option(
             '--user',
             dest='set_user',
             metavar="USERNAME",
             help="Set the user (usually only possible when run as root)")
         parser.add_option(
             '--group',
             dest='set_group',
             metavar="GROUP",
             help="Set the group (usually only possible when run as root)")
 
     parser.add_option(
         '--stop-daemon',
         dest='stop_daemon',
         action='store_true',
         help=('Stop a daemonized server (given a PID file, or default '
               'pyramid.pid file)'))
 
     _scheme_re = re.compile(r'^[a-z][a-z]+:', re.I)
 
     _reloader_environ_key = 'PYTHON_RELOADER_SHOULD_RUN'
     _monitor_environ_key = 'PASTE_MONITOR_SHOULD_RUN'
 
     possible_subcommands = ('start', 'stop', 'restart', 'status')
 
     def __init__(self, argv, quiet=False):
         self.options, self.args = self.parser.parse_args(argv[1:])
         if quiet:
             self.options.verbose = 0
 
     def out(self, msg): # pragma: no cover
         if self.options.verbose > 0:
             print(msg)
 
     def get_options(self):
         if (len(self.args) > 1
             and self.args[1] in self.possible_subcommands):
             restvars = self.args[2:]
         else:
             restvars = self.args[1:]
 
         return parse_vars(restvars)
 
     def run(self):  # pragma: no cover
         if self.options.stop_daemon:
             return self.stop_daemon()
 
         if not hasattr(self.options, 'set_user'):
             # Windows case:
             self.options.set_user = self.options.set_group = None
 
         # @@: Is this the right stage to set the user at?
         self.change_user_group(
             self.options.set_user, self.options.set_group)
 
         if not self.args:
             self.out('Please provide configuration file as first argument, '
                      'most likely it should be production.ini')
             return 2
         app_spec = self.args[0]
 
         if (len(self.args) > 1
             and self.args[1] in self.possible_subcommands):
             cmd = self.args[1]
         else:
             cmd = None
 
         if self.options.reload:
             if os.environ.get(self._reloader_environ_key):
                 if self.options.verbose > 1:
                     self.out('Running reloading file monitor')
 
                 install_reloader(int(self.options.reload_interval),
                                  [app_spec] + generate_extra_file_list())
                 # if self.requires_config_file:
                 #     watch_file(self.args[0])
             else:
                 return self.restart_with_reloader()
 
         if cmd not in (None, 'start', 'stop', 'restart', 'status'):
             self.out(
                 'Error: must give start|stop|restart (not %s)' % cmd)
             return 2
 
         if cmd == 'status' or self.options.show_status:
             return self.show_status()
 
         if cmd == 'restart' or cmd == 'stop':
             result = self.stop_daemon()
             if result:
                 if cmd == 'restart':
                     self.out("Could not stop daemon; aborting")
                 else:
                     self.out("Could not stop daemon")
                 return result
             if cmd == 'stop':
                 return result
             self.options.daemon = True
 
         if cmd == 'start':
             self.options.daemon = True
 
         app_name = self.options.app_name
 
         vars = self.get_options()
 
         if self.options.vcs_server:
             vars['vcs.start_server'] = 'true'
 
         if self.options.running_file:
             global SERVER_RUNNING_FILE
             SERVER_RUNNING_FILE = self.options.running_file
 
         if not self._scheme_re.search(app_spec):
             app_spec = 'config:' + app_spec
         server_name = self.options.server_name
         if self.options.server:
             server_spec = 'egg:pyramid'
             assert server_name is None
             server_name = self.options.server
         else:
             server_spec = app_spec
         base = os.getcwd()
 
         if getattr(self.options, 'daemon', False):
             if not self.options.pid_file:
                 self.options.pid_file = 'pyramid.pid'
             if not self.options.log_file:
                 self.options.log_file = 'pyramid.log'
 
         # Ensure the log file is writeable
         if self.options.log_file:
             try:
                 writeable_log_file = open(self.options.log_file, 'a')
             except IOError as ioe:
                 msg = 'Error: Unable to write to log file: %s' % ioe
                 raise ValueError(msg)
             writeable_log_file.close()
 
         # Ensure the pid file is writeable
         if self.options.pid_file:
             try:
                 writeable_pid_file = open(self.options.pid_file, 'a')
             except IOError as ioe:
                 msg = 'Error: Unable to write to pid file: %s' % ioe
                 raise ValueError(msg)
             writeable_pid_file.close()
 
 
         if getattr(self.options, 'daemon', False):
             try:
                 self.daemonize()
             except DaemonizeException as ex:
                 if self.options.verbose > 0:
                     self.out(str(ex))
                 return 2
 
         if (self.options.monitor_restart
             and not os.environ.get(self._monitor_environ_key)):
             return self.restart_with_monitor()
 
         if self.options.pid_file:
             self.record_pid(self.options.pid_file)
 
         if self.options.log_file:
             stdout_log = LazyWriter(self.options.log_file, 'a')
             sys.stdout = stdout_log
             sys.stderr = stdout_log
             logging.basicConfig(stream=stdout_log)
 
         log_fn = app_spec
         if log_fn.startswith('config:'):
             log_fn = app_spec[len('config:'):]
         elif log_fn.startswith('egg:'):
             log_fn = None
         if log_fn:
             log_fn = os.path.join(base, log_fn)
             setup_logging(log_fn)
             set_rhodecode_is_test(log_fn)
 
         server = self.loadserver(server_spec, name=server_name,
                                  relative_to=base, global_conf=vars)
         # starting hooks
         app = self.loadapp(app_spec, name=app_name, relative_to=base,
                            global_conf=vars)
 
         if self.options.verbose > 0:
             if hasattr(os, 'getpid'):
                 msg = 'Starting %s in PID %i.' % (__name__, os.getpid())
             else:
                 msg = 'Starting %s.' % (__name__,)
             self.out(msg)
             if SERVER_RUNNING_FILE:
                 self.out('PID file written as %s' % (SERVER_RUNNING_FILE, ))
             elif not self.options.pid_file:
                 self.out('No PID file written by default.')
 
         try:
             when_ready(server)
             server(app)
         except (SystemExit, KeyboardInterrupt) as e:
             if self.options.verbose > 1:
                 raise
             if str(e):
                 msg = ' ' + str(e)
             else:
                 msg = ''
             self.out('Exiting%s (-v to see traceback)' % msg)
 
 
     def loadapp(self, app_spec, name, relative_to, **kw):  # pragma: no cover
         return loadapp(app_spec, name=name, relative_to=relative_to, **kw)
 
     def loadserver(self, server_spec, name, relative_to, **kw):  # pragma:no cover
         return loadserver(
             server_spec, name=name, relative_to=relative_to, **kw)
 
     def quote_first_command_arg(self, arg): # pragma: no cover
         """
         There's a bug in Windows when running an executable that's
         located inside a path with a space in it.  This method handles
         that case, or on non-Windows systems or an executable with no
         spaces, it just leaves well enough alone.
         """
         if sys.platform != 'win32' or ' ' not in arg:
             # Problem does not apply:
             return arg
         try:
             import win32api
         except ImportError:
             raise ValueError(
                 "The executable %r contains a space, and in order to "
                 "handle this issue you must have the win32api module "
                 "installed" % arg)
         arg = win32api.GetShortPathName(arg)
         return arg
 
     def daemonize(self):  # pragma: no cover
         pid = live_pidfile(self.options.pid_file)
         if pid:
             raise DaemonizeException(
                 "Daemon is already running (PID: %s from PID file %s)"
                 % (pid, self.options.pid_file))
 
         if self.options.verbose > 0:
             self.out('Entering daemon mode')
         pid = os.fork()
         if pid:
             # The forked process also has a handle on resources, so we
             # *don't* want proper termination of the process, we just
             # want to exit quick (which os._exit() does)
             os._exit(0)
         # Make this the session leader
         os.setsid()
         # Fork again for good measure!
         pid = os.fork()
         if pid:
             os._exit(0)
 
         # @@: Should we set the umask and cwd now?
 
         import resource  # Resource usage information.
         maxfd = resource.getrlimit(resource.RLIMIT_NOFILE)[1]
         if maxfd == resource.RLIM_INFINITY:
             maxfd = MAXFD
         # Iterate through and close all file descriptors.
         for fd in range(0, maxfd):
             try:
                 os.close(fd)
             except OSError:  # ERROR, fd wasn't open to begin with (ignored)
                 pass
 
         if hasattr(os, "devnull"):
             REDIRECT_TO = os.devnull
         else:
             REDIRECT_TO = "/dev/null"
         os.open(REDIRECT_TO, os.O_RDWR)  # standard input (0)
         # Duplicate standard input to standard output and standard error.
         os.dup2(0, 1)  # standard output (1)
         os.dup2(0, 2)  # standard error (2)
 
     def _remove_pid_file(self, written_pid, filename, verbosity):
         current_pid = os.getpid()
         if written_pid != current_pid:
             # A forked process must be exiting, not the process that
             # wrote the PID file
             return
         if not os.path.exists(filename):
             return
         with open(filename) as f:
             content = f.read().strip()
         try:
             pid_in_file = int(content)
         except ValueError:
             pass
         else:
             if pid_in_file != current_pid:
                 msg = "PID file %s contains %s, not expected PID %s"
                 self.out(msg % (filename, pid_in_file, current_pid))
                 return
         if verbosity > 0:
             self.out("Removing PID file %s" % filename)
         try:
             os.unlink(filename)
             return
         except OSError as e:
             # Record, but don't give traceback
             self.out("Cannot remove PID file: (%s)" % e)
         # well, at least lets not leave the invalid PID around...
         try:
             with open(filename, 'w') as f:
                 f.write('')
         except OSError as e:
             self.out('Stale PID left in file: %s (%s)' % (filename, e))
         else:
             self.out('Stale PID removed')
 
     def record_pid(self, pid_file):
         pid = os.getpid()
         if self.options.verbose > 1:
             self.out('Writing PID %s to %s' % (pid, pid_file))
         with open(pid_file, 'w') as f:
             f.write(str(pid))
         atexit.register(self._remove_pid_file, pid, pid_file, self.options.verbose)
 
     def stop_daemon(self):  # pragma: no cover
         pid_file = self.options.pid_file or 'pyramid.pid'
         if not os.path.exists(pid_file):
             self.out('No PID file exists in %s' % pid_file)
             return 1
         pid = read_pidfile(pid_file)
         if not pid:
             self.out("Not a valid PID file in %s" % pid_file)
             return 1
         pid = live_pidfile(pid_file)
         if not pid:
             self.out("PID in %s is not valid (deleting)" % pid_file)
             try:
                 os.unlink(pid_file)
             except (OSError, IOError) as e:
                 self.out("Could not delete: %s" % e)
                 return 2
             return 1
         for j in range(10):
             if not live_pidfile(pid_file):
                 break
             import signal
             kill(pid, signal.SIGTERM)
             time.sleep(1)
         else:
             self.out("failed to kill web process %s" % pid)
             return 3
         if os.path.exists(pid_file):
             os.unlink(pid_file)
         return 0
 
     def show_status(self):  # pragma: no cover
         pid_file = self.options.pid_file or 'pyramid.pid'
         if not os.path.exists(pid_file):
             self.out('No PID file %s' % pid_file)
             return 1
         pid = read_pidfile(pid_file)
         if not pid:
             self.out('No PID in file %s' % pid_file)
             return 1
         pid = live_pidfile(pid_file)
         if not pid:
             self.out('PID %s in %s is not running' % (pid, pid_file))
             return 1
         self.out('Server running in PID %s' % pid)
         return 0
 
     def restart_with_reloader(self):  # pragma: no cover
         self.restart_with_monitor(reloader=True)
 
     def restart_with_monitor(self, reloader=False):  # pragma: no cover
         if self.options.verbose > 0:
             if reloader:
                 self.out('Starting subprocess with file monitor')
             else:
                 self.out('Starting subprocess with monitor parent')
         while 1:
             args = [self.quote_first_command_arg(sys.executable)] + sys.argv
             new_environ = os.environ.copy()
             if reloader:
                 new_environ[self._reloader_environ_key] = 'true'
             else:
                 new_environ[self._monitor_environ_key] = 'true'
             proc = None
             try:
                 try:
                     _turn_sigterm_into_systemexit()
-                    proc = subprocess.Popen(args, env=new_environ)
+                    proc = subprocess32.Popen(args, env=new_environ)
                     exit_code = proc.wait()
                     proc = None
                 except KeyboardInterrupt:
                     self.out('^C caught in monitor process')
                     if self.options.verbose > 1:
                         raise
                     return 1
             finally:
                 if proc is not None:
                     import signal
                     try:
                         kill(proc.pid, signal.SIGTERM)
                     except (OSError, IOError):
                         pass
 
             if reloader:
                 # Reloader always exits with code 3; but if we are
                 # a monitor, any exit code will restart
                 if exit_code != 3:
                     return exit_code
             if self.options.verbose > 0:
                 self.out('%s %s %s' % ('-' * 20, 'Restarting', '-' * 20))
 
     def change_user_group(self, user, group):  # pragma: no cover
         if not user and not group:
             return
         import pwd
         import grp
         uid = gid = None
         if group:
             try:
                 gid = int(group)
                 group = grp.getgrgid(gid).gr_name
             except ValueError:
                 try:
                     entry = grp.getgrnam(group)
                 except KeyError:
                     raise ValueError(
                         "Bad group: %r; no such group exists" % group)
                 gid = entry.gr_gid
         try:
             uid = int(user)
             user = pwd.getpwuid(uid).pw_name
         except ValueError:
             try:
                 entry = pwd.getpwnam(user)
             except KeyError:
                 raise ValueError(
                     "Bad username: %r; no such user exists" % user)
             if not gid:
                 gid = entry.pw_gid
             uid = entry.pw_uid
         if self.options.verbose > 0:
             self.out('Changing user to %s:%s (%s:%s)' % (
                 user, group or '(unknown)', uid, gid))
         if gid:
             os.setgid(gid)
         if uid:
             os.setuid(uid)
 
 
 class LazyWriter(object):
 
     """
     File-like object that opens a file lazily when it is first written
     to.
     """
 
     def __init__(self, filename, mode='w'):
         self.filename = filename
         self.fileobj = None
         self.lock = threading.Lock()
         self.mode = mode
 
     def open(self):
         if self.fileobj is None:
             with self.lock:
                 self.fileobj = open(self.filename, self.mode)
         return self.fileobj
 
     def close(self):
         fileobj = self.fileobj
         if fileobj is not None:
             fileobj.close()
 
     def __del__(self):
         self.close()
 
     def write(self, text):
         fileobj = self.open()
         fileobj.write(text)
         fileobj.flush()
 
     def writelines(self, text):
         fileobj = self.open()
         fileobj.writelines(text)
         fileobj.flush()
 
     def flush(self):
         self.open().flush()
 
 
 def live_pidfile(pidfile):  # pragma: no cover
     """
     (pidfile:str) -> int | None
     Returns an int found in the named file, if there is one,
     and if there is a running process with that process id.
     Return None if no such process exists.
     """
     pid = read_pidfile(pidfile)
     if pid:
         try:
             kill(int(pid), 0)
             return pid
         except OSError as e:
             if e.errno == errno.EPERM:
                 return pid
     return None
 
 
 def read_pidfile(filename):
     if os.path.exists(filename):
         try:
             with open(filename) as f:
                 content = f.read()
             return int(content.strip())
         except (ValueError, IOError):
             return None
     else:
         return None
 
 
 def ensure_port_cleanup(
     bound_addresses, maxtries=30, sleeptime=2):  # pragma: no cover
     """
     This makes sure any open ports are closed.
 
     Does this by connecting to them until they give connection
     refused.  Servers should call like::
 
         ensure_port_cleanup([80, 443])
     """
     atexit.register(_cleanup_ports, bound_addresses, maxtries=maxtries,
                     sleeptime=sleeptime)
 
 
 def _cleanup_ports(
     bound_addresses, maxtries=30, sleeptime=2):  # pragma: no cover
     # Wait for the server to bind to the port.
     import socket
     import errno
     for bound_address in bound_addresses:
         for attempt in range(maxtries):
             sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             try:
                 sock.connect(bound_address)
             except socket.error as e:
                 if e.args[0] != errno.ECONNREFUSED:
                     raise
                 break
             else:
                 time.sleep(sleeptime)
         else:
             raise SystemExit('Timeout waiting for port.')
         sock.close()
 
 
 def _turn_sigterm_into_systemexit():  # pragma: no cover
     """
     Attempts to turn a SIGTERM exception into a SystemExit exception.
     """
     try:
         import signal
     except ImportError:
         return
     def handle_term(signo, frame):
         raise SystemExit
     signal.signal(signal.SIGTERM, handle_term)
 
 
 def install_reloader(poll_interval=1, extra_files=None):  # pragma: no cover
     """
     Install the reloading monitor.
 
     On some platforms server threads may not terminate when the main
     thread does, causing ports to remain open/locked.  The
     ``raise_keyboard_interrupt`` option creates a unignorable signal
     which causes the whole application to shut-down (rudely).
     """
     mon = Monitor(poll_interval=poll_interval)
     if extra_files is None:
         extra_files = []
     mon.extra_files.extend(extra_files)
     t = threading.Thread(target=mon.periodic_reload)
     t.setDaemon(True)
     t.start()
 
 
 class classinstancemethod(object):
     """
     Acts like a class method when called from a class, like an
     instance method when called by an instance.  The method should
     take two arguments, 'self' and 'cls'; one of these will be None
     depending on how the method was called.
     """
 
     def __init__(self, func):
         self.func = func
         self.__doc__ = func.__doc__
 
     def __get__(self, obj, type=None):
         return _methodwrapper(self.func, obj=obj, type=type)
 
 
 class _methodwrapper(object):
 
     def __init__(self, func, obj, type):
         self.func = func
         self.obj = obj
         self.type = type
 
     def __call__(self, *args, **kw):
         assert not 'self' in kw and not 'cls' in kw, (
             "You cannot use 'self' or 'cls' arguments to a "
             "classinstancemethod")
         return self.func(*((self.obj, self.type) + args), **kw)
 
 
 class Monitor(object): # pragma: no cover
     """
     A file monitor and server restarter.
 
     Use this like:
 
     ..code-block:: Python
 
         install_reloader()
 
     Then make sure your server is installed with a shell script like::
 
         err=3
         while test "$err" -eq 3 ; do
             python server.py
             err="$?"
         done
 
     or is run from this .bat file (if you use Windows)::
 
         @echo off
         :repeat
             python server.py
         if %errorlevel% == 3 goto repeat
 
     or run a monitoring process in Python (``pserve --reload`` does
     this).
 
     Use the ``watch_file(filename)`` function to cause a reload/restart for
     other non-Python files (e.g., configuration files).  If you have
     a dynamic set of files that grows over time you can use something like::
 
         def watch_config_files():
             return CONFIG_FILE_CACHE.keys()
         add_file_callback(watch_config_files)
 
     Then every time the reloader polls files it will call
     ``watch_config_files`` and check all the filenames it returns.
     """
     instances = []
     global_extra_files = []
     global_file_callbacks = []
 
     def __init__(self, poll_interval):
         self.module_mtimes = {}
         self.keep_running = True
         self.poll_interval = poll_interval
         self.extra_files = list(self.global_extra_files)
         self.instances.append(self)
         self.file_callbacks = list(self.global_file_callbacks)
 
     def _exit(self):
         # use os._exit() here and not sys.exit() since within a
         # thread sys.exit() just closes the given thread and
         # won't kill the process; note os._exit does not call
         # any atexit callbacks, nor does it do finally blocks,
         # flush open files, etc.  In otherwords, it is rude.
         os._exit(3)
 
     def periodic_reload(self):
         while True:
             if not self.check_reload():
                 self._exit()
                 break
             time.sleep(self.poll_interval)
 
     def check_reload(self):
         filenames = list(self.extra_files)
         for file_callback in self.file_callbacks:
             try:
                 filenames.extend(file_callback())
             except:
                 print(
                     "Error calling reloader callback %r:" % file_callback)
                 traceback.print_exc()
         for module in list(sys.modules.values()):
             try:
                 filename = module.__file__
             except (AttributeError, ImportError):
                 continue
             if filename is not None:
                 filenames.append(filename)
 
         for filename in filenames:
             try:
                 stat = os.stat(filename)
                 if stat:
                     mtime = stat.st_mtime
                 else:
                     mtime = 0
             except (OSError, IOError):
                 continue
             if filename.endswith('.pyc') and os.path.exists(filename[:-1]):
                 mtime = max(os.stat(filename[:-1]).st_mtime, mtime)
             if not filename in self.module_mtimes:
                 self.module_mtimes[filename] = mtime
             elif self.module_mtimes[filename] < mtime:
                 print("%s changed; reloading..." % filename)
                 run_callback_for_pattern(filename)
                 return False
         return True
 
     def watch_file(self, cls, filename):
         """Watch the named file for changes"""
         filename = os.path.abspath(filename)
         if self is None:
             for instance in cls.instances:
                 instance.watch_file(filename)
             cls.global_extra_files.append(filename)
         else:
             self.extra_files.append(filename)
 
     watch_file = classinstancemethod(watch_file)
 
     def add_file_callback(self, cls, callback):
         """Add a callback -- a function that takes no parameters -- that will
         return a list of filenames to watch for changes."""
         if self is None:
             for instance in cls.instances:
                 instance.add_file_callback(callback)
             cls.global_file_callbacks.append(callback)
         else:
             self.file_callbacks.append(callback)
 
     add_file_callback = classinstancemethod(add_file_callback)
 
 watch_file = Monitor.watch_file
 add_file_callback = Monitor.add_file_callback
 
 
 def main(argv=sys.argv, quiet=False):
     command = RcServerCommand(argv, quiet=quiet)
     return command.run()
 
 if __name__ == '__main__':  # pragma: no cover
     sys.exit(main() or 0)

rhodecode/tests/database/conftest.py

@@ -1,273 +1,273 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
-from subprocess import Popen, PIPE
+from subprocess32 import Popen, PIPE
 import os
 import shutil
 import sys
 import tempfile
 
 import pytest
 from sqlalchemy.engine import url
 
 from rhodecode.tests.fixture import TestINI
 
 
 def _get_dbs_from_metafunc(metafunc):
     if hasattr(metafunc.function, 'dbs'):
         # Supported backends by this test function, created from
         # pytest.mark.dbs
         backends = metafunc.function.dbs.args
     else:
         backends = metafunc.config.getoption('--dbs')
     return backends
 
 
 def pytest_generate_tests(metafunc):
     # Support test generation based on --dbs parameter
     if 'db_backend' in metafunc.fixturenames:
         requested_backends = set(metafunc.config.getoption('--dbs'))
         backends = _get_dbs_from_metafunc(metafunc)
         backends = requested_backends.intersection(backends)
         # TODO: johbo: Disabling a backend did not work out with
         # parametrization, find better way to achieve this.
         if not backends:
             metafunc.function._skip = True
         metafunc.parametrize('db_backend_name', backends)
 
 
 def pytest_collection_modifyitems(session, config, items):
     remaining = [
         i for i in items if not getattr(i.obj, '_skip', False)]
     items[:] = remaining
 
 
 @pytest.fixture
 def db_backend(
         request, db_backend_name, pylons_config, tmpdir_factory):
     basetemp = tmpdir_factory.getbasetemp().strpath
     klass = _get_backend(db_backend_name)
 
     option_name = '--{}-connection-string'.format(db_backend_name)
     connection_string = request.config.getoption(option_name) or None
 
     return klass(
         config_file=pylons_config, basetemp=basetemp,
         connection_string=connection_string)
 
 
 def _get_backend(backend_type):
     return {
         'sqlite': SQLiteDBBackend,
         'postgres': PostgresDBBackend,
         'mysql': MySQLDBBackend,
         '': EmptyDBBackend
     }[backend_type]
 
 
 class DBBackend(object):
     _store = os.path.dirname(os.path.abspath(__file__))
     _type = None
     _base_ini_config = [{'app:main': {'vcs.start_server': 'false'}}]
     _db_url = [{'app:main': {'sqlalchemy.db1.url': ''}}]
     _base_db_name = 'rhodecode_test_db_backend'
 
     def __init__(
             self, config_file, db_name=None, basetemp=None,
             connection_string=None):
         self.fixture_store = os.path.join(self._store, self._type)
         self.db_name = db_name or self._base_db_name
         self._base_ini_file = config_file
         self.stderr = ''
         self.stdout = ''
         self._basetemp = basetemp or tempfile.gettempdir()
         self._repos_location = os.path.join(self._basetemp, 'rc_test_repos')
         self.connection_string = connection_string
 
     @property
     def connection_string(self):
         return self._connection_string
 
     @connection_string.setter
     def connection_string(self, new_connection_string):
         if not new_connection_string:
             new_connection_string = self.get_default_connection_string()
         else:
             new_connection_string = new_connection_string.format(
                 db_name=self.db_name)
         url_parts = url.make_url(new_connection_string)
         self._connection_string = new_connection_string
         self.user = url_parts.username
         self.password = url_parts.password
         self.host = url_parts.host
 
     def get_default_connection_string(self):
         raise NotImplementedError('default connection_string is required.')
 
     def execute(self, cmd, env=None, *args):
         """
         Runs command on the system with given ``args``.
         """
 
         command = cmd + ' ' + ' '.join(args)
         sys.stdout.write(command)
 
         # Tell Python to use UTF-8 encoding out stdout
         _env = os.environ.copy()
         _env['PYTHONIOENCODING'] = 'UTF-8'
         if env:
             _env.update(env)
         self.p = Popen(command, shell=True, stdout=PIPE, stderr=PIPE, env=_env)
         self.stdout, self.stderr = self.p.communicate()
         sys.stdout.write('COMMAND:'+command+'\n')
         sys.stdout.write(self.stdout)
         return self.stdout, self.stderr
 
     def assert_returncode_success(self):
         assert self.p.returncode == 0, self.stderr
 
     def setup_rhodecode_db(self, ini_params=None, env=None):
         if not ini_params:
             ini_params = self._base_ini_config
 
         ini_params.extend(self._db_url)
         with TestINI(self._base_ini_file, ini_params,
                      self._type, destroy=True) as _ini_file:
             if not os.path.isdir(self._repos_location):
                 os.makedirs(self._repos_location)
             self.execute(
                 "paster setup-rhodecode {0} --user=marcink "
                 "--email=[e-mail] --password={1} "
                 "--repos={2} --force-yes".format(
                     _ini_file, 'qweqwe', self._repos_location), env=env)
 
     def upgrade_database(self, ini_params=None):
         if not ini_params:
             ini_params = self._base_ini_config
         ini_params.extend(self._db_url)
 
         test_ini = TestINI(
             self._base_ini_file, ini_params, self._type, destroy=True)
         with test_ini as ini_file:
             if not os.path.isdir(self._repos_location):
                 os.makedirs(self._repos_location)
             self.execute(
                 "paster upgrade-db {} --force-yes".format(ini_file))
 
     def setup_db(self):
         raise NotImplementedError
 
     def teardown_db(self):
         raise NotImplementedError
 
     def import_dump(self, dumpname):
         raise NotImplementedError
 
 
 class EmptyDBBackend(DBBackend):
     _type = ''
 
     def setup_db(self):
         pass
 
     def teardown_db(self):
         pass
 
     def import_dump(self, dumpname):
         pass
 
     def assert_returncode_success(self):
         assert True
 
 
 class SQLiteDBBackend(DBBackend):
     _type = 'sqlite'
 
     def get_default_connection_string(self):
         return 'sqlite:///{}/{}.sqlite'.format(self._basetemp, self.db_name)
 
     def setup_db(self):
         # dump schema for tests
         # cp -v $TEST_DB_NAME
         self._db_url = [{'app:main': {
             'sqlalchemy.db1.url': self.connection_string}}]
 
     def import_dump(self, dumpname):
         dump = os.path.join(self.fixture_store, dumpname)
         shutil.copy(
             dump,
             os.path.join(self._basetemp, '{0.db_name}.sqlite'.format(self)))
 
     def teardown_db(self):
         self.execute("rm -rf {}.sqlite".format(
             os.path.join(self._basetemp, self.db_name)))
 
 
 class MySQLDBBackend(DBBackend):
     _type = 'mysql'
 
     def get_default_connection_string(self):
         return 'mysql://root:qweqwe@127.0.0.1/{}'.format(self.db_name)
 
     def setup_db(self):
         # dump schema for tests
         # mysqldump -uroot -pqweqwe $TEST_DB_NAME
         self._db_url = [{'app:main': {
             'sqlalchemy.db1.url': self.connection_string}}]
         self.execute("mysql -v -u{} -p{} -e 'create database '{}';'".format(
             self.user, self.password, self.db_name))
 
     def import_dump(self, dumpname):
         dump = os.path.join(self.fixture_store, dumpname)
         self.execute("mysql -u{} -p{} {} < {}".format(
             self.user, self.password, self.db_name, dump))
 
     def teardown_db(self):
         self.execute("mysql -v -u{} -p{} -e 'drop database '{}';'".format(
             self.user, self.password, self.db_name))
 
 
 class PostgresDBBackend(DBBackend):
     _type = 'postgres'
 
     def get_default_connection_string(self):
         return 'postgresql://postgres:qweqwe@localhost/{}'.format(self.db_name)
 
     def setup_db(self):
         # dump schema for tests
         # pg_dump -U postgres -h localhost $TEST_DB_NAME
         self._db_url = [{'app:main': {
             'sqlalchemy.db1.url':
                 self.connection_string}}]
         self.execute("PGPASSWORD={} psql -U {} -h localhost "
                      "-c 'create database '{}';'".format(
                          self.password, self.user, self.db_name))
 
     def teardown_db(self):
         self.execute("PGPASSWORD={} psql -U {} -h localhost "
                      "-c 'drop database if exists '{}';'".format(
                          self.password, self.user, self.db_name))
 
     def import_dump(self, dumpname):
         dump = os.path.join(self.fixture_store, dumpname)
         self.execute(
             "PGPASSWORD={} psql -U {} -h localhost -d {} -1 "
             "-f {}".format(
                 self.password, self.user, self.db_name, dump))

rhodecode/tests/lib/middleware/utils/test_scm_app_http_chunking.py

@@ -1,136 +1,136 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Checking the chunked data transfer via HTTP
 """
 
 import os
 import time
-import subprocess
+import subprocess32
 
 import pytest
 import requests
 
 from rhodecode.lib.middleware.utils import scm_app_http
 from rhodecode.tests.utils import wait_for_url
 
 
 def test_does_chunked_end_to_end_transfer(scm_app):
     response = requests.post(scm_app, data='', stream=True)
     assert response.headers['Transfer-Encoding'] == 'chunked'
     times = [time.time() for chunk in response.raw.read_chunked()]
     assert times[1] - times[0] > 0.1, "Chunks arrived at the same time"
 
 
 @pytest.fixture
 def echo_app_chunking(request, available_port_factory):
     """
     Run the EchoApp via Waitress in a subprocess.
 
     Return the URL endpoint to reach the app.
     """
     port = available_port_factory()
     command = (
         'waitress-serve --send-bytes 1 --port {port} --call '
         'rhodecode.tests.lib.middleware.utils.test_scm_app_http_chunking'
         ':create_echo_app')
     command = command.format(port=port)
-    proc = subprocess.Popen(command.split(' '), bufsize=0)
+    proc = subprocess32.Popen(command.split(' '), bufsize=0)
     echo_app_url = 'http://localhost:' + str(port)
 
     @request.addfinalizer
     def stop_echo_app():
         proc.kill()
 
     return echo_app_url
 
 
 @pytest.fixture
 def scm_app(request, available_port_factory, echo_app_chunking):
     """
     Run the scm_app in Waitress.
 
     Returns the URL endpoint where this app can be reached.
     """
     port = available_port_factory()
     command = (
         'waitress-serve --send-bytes 1 --port {port} --call '
         'rhodecode.tests.lib.middleware.utils.test_scm_app_http_chunking'
         ':create_scm_app')
     command = command.format(port=port)
     env = os.environ.copy()
     env["RC_ECHO_URL"] = echo_app_chunking
-    proc = subprocess.Popen(command.split(' '), bufsize=0, env=env)
+    proc = subprocess32.Popen(command.split(' '), bufsize=0, env=env)
     scm_app_url = 'http://localhost:' + str(port)
     wait_for_url(scm_app_url)
 
     @request.addfinalizer
     def stop_echo_app():
         proc.kill()
 
     return scm_app_url
 
 
 class EchoApp(object):
     """
     Stub WSGI application which returns a chunked response to every request.
     """
 
     def __init__(self, repo_path, repo_name, config):
         self._repo_path = repo_path
 
     def __call__(self, environ, start_response):
         environ['wsgi.input'].read()
         status = '200 OK'
         headers = []
         start_response(status, headers)
         return result_generator()
 
 
 def result_generator():
     """
     Simulate chunked results.
 
     The intended usage is to simulate a chunked response as we would get it
     out of a vcs operation during a call to "hg clone".
     """
     yield 'waiting 2 seconds'
     # Wait long enough so that the first chunk can go out
     time.sleep(2)
     yield 'final chunk'
     # Another small wait, otherwise they go together
     time.sleep(0.1)
 
 
 def create_echo_app():
     """
     Create EchoApp filled with stub data.
     """
     return EchoApp('stub_path', 'repo_name', {})
 
 
 def create_scm_app():
     """
     Create a scm_app hooked up to speak to EchoApp.
     """
     echo_app_url = os.environ["RC_ECHO_URL"]
     return scm_app_http.VcsHttpProxy(
         echo_app_url, 'stub_path', 'stub_name', None)

rhodecode/tests/load/http_performance.py

@@ -1,463 +1,463 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Module to test the performance of pull, push and clone operations.
 
 It works by replaying a group of commits to the repo.
 """
 
 import argparse
 import collections
 import ConfigParser
 import functools
 import itertools
 import os
 import pprint
 import shutil
-import subprocess
+import subprocess32
 import sys
 import time
 
 import api
 
 
 def mean(container):
     """Return the mean of the container."""
     if not container:
         return -1.0
     return sum(container) / len(container)
 
 
 def keep_cwd(f):
     """Decorator that keeps track of the starting working directory."""
     @functools.wraps(f)
     def wrapped_f(*args, **kwargs):
         cur_dir = os.getcwd()
         try:
             return f(*args, **kwargs)
         finally:
             os.chdir(cur_dir)
 
     return wrapped_f
 
 
 def timed(f):
     """Decorator that returns the time it took to execute the function."""
     @functools.wraps(f)
     def wrapped_f(*args, **kwargs):
         start_time = time.time()
         try:
             f(*args, **kwargs)
         finally:
             return time.time() - start_time
 
     return wrapped_f
 
 
 def execute(*popenargs, **kwargs):
     """Extension of subprocess.check_output to support writing to stdin."""
     input = kwargs.pop('stdin', None)
     stdin = None
     if input:
-        stdin = subprocess.PIPE
+        stdin = subprocess32.PIPE
     #if 'stderr' not in kwargs:
-    #    kwargs['stderr'] = subprocess.PIPE
+    #    kwargs['stderr'] = subprocess32.PIPE
     if 'stdout' in kwargs:
         raise ValueError('stdout argument not allowed, it will be overridden.')
-    process = subprocess.Popen(stdin=stdin, stdout=subprocess.PIPE,
+    process = subprocess32.Popen(stdin=stdin, stdout=subprocess32.PIPE,
                                *popenargs, **kwargs)
     output, error = process.communicate(input=input)
     retcode = process.poll()
     if retcode:
         cmd = kwargs.get("args")
         if cmd is None:
             cmd = popenargs[0]
         print cmd, output, error
-        raise subprocess.CalledProcessError(retcode, cmd, output=output)
+        raise subprocess32.CalledProcessError(retcode, cmd, output=output)
     return output
 
 
 def get_repo_name(repo_url):
     """Extract the repo name from its url."""
     repo_url = repo_url.rstrip('/')
     return repo_url.split('/')[-1].split('.')[0]
 
 
 class TestPerformanceBase(object):
     def __init__(self, base_dir, repo_url, n_commits, max_commits,
                  skip_commits):
         self.repo_url = repo_url
         self.repo_name = get_repo_name(self.repo_url)
         self.upstream_repo_name = '%s_upstream' % self.repo_name
         self.base_dir = os.path.abspath(base_dir)
         self.n_commits = n_commits
         self.max_commits = max_commits
         self.skip_commits = skip_commits
         self.push_times = []
         self.pull_times = []
         self.empty_pull_times = []
         self.clone_time = -1.0
         self.last_commit = None
 
         self.cloned_repo = ''
         self.pull_repo = ''
         self.orig_repo = ''
 
     def run(self):
         try:
             self.test()
         except Exception as error:
             print error
         finally:
             self.cleanup()
 
             print 'Clone time     :', self.clone_time
             print 'Push time      :', mean(self.push_times)
             print 'Pull time      :', mean(self.pull_times)
             print 'Empty pull time:', mean(self.empty_pull_times)
 
             return {
                 'clone': self.clone_time,
                 'push': mean(self.push_times),
                 'pull': mean(self.pull_times),
                 'empty_pull': mean(self.empty_pull_times),
             }
 
     @keep_cwd
     def test(self):
         os.chdir(self.base_dir)
 
         self.orig_repo = os.path.join(self.base_dir, self.repo_name)
         if not os.path.exists(self.orig_repo):
             self.clone_repo(self.repo_url, default_only=True)
 
         upstream_url = self.create_repo(self.upstream_repo_name, self.repo_type)
 
         self.add_remote(self.orig_repo, upstream_url)
 
         self.pull_repo = os.path.join(self.base_dir, '%s_pull' % self.repo_name)
         self.clone_repo(upstream_url, self.pull_repo)
 
         commits = self.get_commits(self.orig_repo)
         self.last_commit = commits[-1]
         if self.skip_commits:
             self.push(
                 self.orig_repo, commits[self.skip_commits - 1], 'upstream')
         commits = commits[self.skip_commits:self.max_commits]
 
         print 'Working with %d commits' % len(commits)
         for i in xrange(self.n_commits - 1, len(commits), self.n_commits):
             commit = commits[i]
             print 'Processing commit %s (%d)' % (commit, i + 1)
             self.push_times.append(
                 self.push(self.orig_repo, commit, 'upstream'))
             self.check_remote_last_commit_is(commit, upstream_url)
 
             self.pull_times.append(self.pull(self.pull_repo))
             self.check_local_last_commit_is(commit, self.pull_repo)
 
             self.empty_pull_times.append(self.pull(self.pull_repo))
 
         self.cloned_repo = os.path.join(self.base_dir,
                                         '%s_clone' % self.repo_name)
         self.clone_time = self.clone_repo(upstream_url, self.cloned_repo)
 
     def cleanup(self):
         try:
             self.delete_repo(self.upstream_repo_name)
         except api.ApiError:
             # Continue in case we could not delete the repo. Maybe we did not
             # create it in the first place.
             pass
 
         shutil.rmtree(self.pull_repo, ignore_errors=True)
         shutil.rmtree(self.cloned_repo, ignore_errors=True)
 
         if os.path.exists(self.orig_repo):
             self.remove_remote(self.orig_repo)
 
 
 class RhodeCodeMixin(object):
     """Mixin providing the methods to create and delete repos in RhodeCode."""
     def __init__(self, api_key):
         self.api = api.RCApi(api_key=api_key)
 
     def create_repo(self, repo_name, repo_type):
         return self.api.create_repo(repo_name, repo_type,
                                     'Repo for perfomance testing')
 
     def delete_repo(self, repo_name):
         return self.api.delete_repo(repo_name)
 
 
 class GitMixin(object):
     """Mixin providing the git operations."""
     @timed
     def clone_repo(self, repo_url, destination=None, default_only=False):
         args = ['git', 'clone']
         if default_only:
             args.extend(['--branch', 'master', '--single-branch'])
         args.append(repo_url)
         if destination:
             args.append(destination)
         execute(args)
 
     @keep_cwd
     def add_remote(self, repo, remote_url, remote_name='upstream'):
         self.remove_remote(repo, remote_name)
         os.chdir(repo)
         execute(['git', 'remote', 'add', remote_name, remote_url])
 
     @keep_cwd
     def remove_remote(self, repo, remote_name='upstream'):
         os.chdir(repo)
         remotes = execute(['git', 'remote']).split('\n')
         if remote_name in remotes:
             execute(['git', 'remote', 'remove', remote_name])
 
     @keep_cwd
     def get_commits(self, repo, branch='master'):
         os.chdir(repo)
         commits_list = execute(
             ['git', 'log', '--first-parent', branch, '--pretty=%H'])
         return commits_list.strip().split('\n')[::-1]
 
     @timed
     def push(self, repo, commit, remote_name=None):
         os.chdir(repo)
         try:
             execute(['git', 'reset', '--soft', commit])
             args = ['git', 'push']
             if remote_name:
                 args.append(remote_name)
             execute(args)
         finally:
             execute(['git', 'reset', '--soft', 'HEAD@{1}'])
 
     @timed
     def pull(self, repo):
         os.chdir(repo)
         execute(['git', 'pull'])
 
     def _remote_last_commit(self, repo_url):
         output = execute(['git', 'ls-remote', repo_url, 'HEAD'])
         return output.split()[0]
 
     def check_remote_last_commit_is(self, commit, repo_url):
         last_remote_commit = self._remote_last_commit(repo_url)
         if last_remote_commit != commit:
             raise Exception('Push did not work, expected commit %s but got %s' %
                             (commit, last_remote_commit))
 
     @keep_cwd
     def _local_last_commit(self, repo):
         os.chdir(repo)
         return execute(['git', 'rev-parse', 'HEAD']).strip()
 
     def check_local_last_commit_is(self, commit, repo):
         last_local_commit = self._local_last_commit(repo)
         if last_local_commit != commit:
             raise Exception('Pull did not work, expected commit %s but got %s' %
                             (commit, last_local_commit))
 
 
 class HgMixin(object):
     """Mixin providing the mercurial operations."""
     @timed
     def clone_repo(self, repo_url, destination=None, default_only=False):
         args = ['hg', 'clone']
         if default_only:
             args.extend(['--branch', 'default'])
         args.append(repo_url)
         if destination:
             args.append(destination)
         execute(args)
 
     @keep_cwd
     def add_remote(self, repo, remote_url, remote_name='upstream'):
         self.remove_remote(repo, remote_name)
         os.chdir(repo)
         hgrc = ConfigParser.RawConfigParser()
         hgrc.read('.hg/hgrc')
         hgrc.set('paths', remote_name, remote_url)
         with open('.hg/hgrc', 'w') as f:
             hgrc.write(f)
 
     @keep_cwd
     def remove_remote(self, repo, remote_name='upstream'):
         os.chdir(repo)
         hgrc = ConfigParser.RawConfigParser()
         hgrc.read('.hg/hgrc')
         hgrc.remove_option('paths', remote_name)
         with open('.hg/hgrc', 'w') as f:
             hgrc.write(f)
 
     @keep_cwd
     def get_commits(self, repo, branch='default'):
         os.chdir(repo)
         # See http://stackoverflow.com/questions/15376649/is-there-a-mercurial-equivalent-to-git-log-first-parent
         commits_list = execute(['hg', 'log', '--branch', branch, '--template',
                                 '{node}\n', '--follow-first'])
         return commits_list.strip().split('\n')[::-1]
 
     @timed
     def push(self, repo, commit, remote_name=None):
         os.chdir(repo)
         args = ['hg', 'push', '--rev', commit, '--new-branch']
         if remote_name:
             args.append(remote_name)
         execute(args)
 
     @timed
     def pull(self, repo):
         os.chdir(repo)
         execute(['hg', '--config', 'alias.pull=pull', 'pull', '-u'])
 
     def _remote_last_commit(self, repo_url):
         return execute(['hg', 'identify', repo_url])[:12]
 
     def check_remote_last_commit_is(self, commit, repo_url):
         last_remote_commit = self._remote_last_commit(repo_url)
         if not commit.startswith(last_remote_commit):
             raise Exception('Push did not work, expected commit %s but got %s' %
                             (commit, last_remote_commit))
 
     @keep_cwd
     def _local_last_commit(self, repo):
         os.chdir(repo)
         return execute(['hg', 'identify'])[:12]
 
     def check_local_last_commit_is(self, commit, repo):
         last_local_commit = self._local_last_commit(repo)
         if not commit.startswith(last_local_commit):
             raise Exception('Pull did not work, expected commit %s but got %s' %
                             (commit, last_local_commit))
 
 
 class GitTestPerformance(GitMixin, RhodeCodeMixin, TestPerformanceBase):
     def __init__(self, base_dir, repo_url, n_commits, max_commits, skip_commits,
                  api_key):
         TestPerformanceBase.__init__(self, base_dir, repo_url, n_commits,
                                      max_commits, skip_commits)
         RhodeCodeMixin.__init__(self, api_key)
         self.repo_type = 'git'
 
 
 class HgTestPerformance(HgMixin, RhodeCodeMixin, TestPerformanceBase):
     def __init__(self, base_dir, repo_url, n_commits, max_commits, skip_commits,
                  api_key):
         TestPerformanceBase.__init__(self, base_dir, repo_url, n_commits,
                                      max_commits, skip_commits)
         RhodeCodeMixin.__init__(self, api_key)
         self.repo_type = 'hg'
 
 
 def get_test(base_dir, repo_url, repo_type, step, max_commits, skip_commits,
              api_key):
     max_commits = min(10 * step,
                       int((max_commits - skip_commits) / step) * step)
     max_commits += skip_commits
     if repo_type == 'git':
         return GitTestPerformance(
             base_dir, repo_url, step, max_commits, skip_commits, api_key)
     elif repo_type == 'hg':
         return HgTestPerformance(
             base_dir, repo_url, step, max_commits, skip_commits, api_key)
 
 
 def main(argv):
     parser = argparse.ArgumentParser(
         description='Performance tests for push/pull/clone for git and ' +
                     'mercurial repos.')
     parser.add_argument(
         '--tests', dest='tests', action='store', required=False, default='all',
         help='The tests to run. Default: all. But could be any comma ' +
              'separated list with python, hg, kernel or git')
     parser.add_argument(
         '--sizes', dest='sizes', action='store', required=False,
         default='1,10,100,1000,2500',
         help='The sizes to use. Default: 1,10,100,1000,2500')
     parser.add_argument(
         '--dir', dest='dir', action='store', required=True,
         help='The dir where to store the repos')
     parser.add_argument(
         '--api-key', dest='api_key', action='store', required=True,
         help='The api key of RhodeCode')
     options = parser.parse_args(argv[1:])
     print options
 
     test_config = {
         'python': {
             'url': 'https://hg.python.org/cpython/',
             'limit': 23322,
             'type': 'hg',
             # Do not time the first commit, as it is HUGE!
             'skip': 1,
         },
         'hg': {
             'url': 'http://selenic.com/hg',
             'limit': 14396,
             'type': 'hg',
         },
         'kernel': {
             'url': 'https://github.com/torvalds/linux.git',
             'limit': 46271,
             'type': 'git',
         },
         'git': {
             'url': 'https://github.com/git/git.git',
             'limit': 13525,
             'type': 'git',
         }
 
     }
 
     test_names = options.tests.split(',')
     if test_names == ['all']:
         test_names = test_config.keys()
     if not set(test_names) <= set(test_config.keys()):
         print ('Invalid tests: only %s are valid but specified %s' %
                (test_config.keys(), test_names))
         return 1
 
     sizes = options.sizes.split(',')
     sizes = map(int, sizes)
 
     base_dir = options.dir
     api_key = options.api_key
     results = collections.defaultdict(dict)
     for test_name, size in itertools.product(test_names, sizes):
         test = get_test(base_dir,
                         test_config[test_name]['url'],
                         test_config[test_name]['type'],
                         size,
                         test_config[test_name]['limit'],
                         test_config[test_name].get('skip', 0),
                         api_key)
         print '*' * 80
         print 'Running performance test: %s with size %d' % (test_name, size)
         print '*' * 80
         results[test_name][size] = test.run()
     pprint.pprint(dict(results))
 
 
 if __name__ == '__main__':
     sys.exit(main(sys.argv))

rhodecode/tests/load/profile.py

@@ -1,155 +1,155 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 This is a standalone script which will start VCS and RC.
 
 Performance numbers will be written on each interval to:
     vcs_profileX.csv
     rc_profileX.csv
 
 To stop the script by press Ctrl-C
 """
 
 import datetime
 import os
 import psutil
-import subprocess
+import subprocess32
 import sys
 import time
 import traceback
 import urllib
 
 PROFILING_INTERVAL = 5
 RC_WEBSITE = "http://localhost:5001/"
 
 
 def get_file(prefix):
     out_file = None
     for i in xrange(100):
         file_path = "%s_profile%.3d.csv" % (prefix, i)
         if os.path.exists(file_path):
             continue
         out_file = open(file_path, "w")
         out_file.write("Time; CPU %; Memory (MB); Total FDs; Dulwich FDs; Threads\n")
         break
     return out_file
 
 
 def dump_system():
     print "System Overview..."
     print "\nCPU Count: %d (%d real)" % \
           (psutil.cpu_count(), psutil.cpu_count(logical=False))
     print "\nDisk:"
     print psutil.disk_usage(os.sep)
     print "\nMemory:"
     print psutil.virtual_memory()
     print "\nMemory (swap):"
     print psutil.swap_memory()
 
 
 def count_dulwich_fds(proc):
-    p = subprocess.Popen(["lsof", "-p", proc.pid], stdout=subprocess.PIPE)
+    p = subprocess32.Popen(["lsof", "-p", proc.pid], stdout=subprocess32.PIPE)
     out, err = p.communicate()
 
     count = 0
     for line in out.splitlines():
         content = line.split()
         # http://git-scm.com/book/en/Git-Internals-Packfiles
         if content[-1].endswith(".idx"):
             count += 1
 
     return count
 
 def dump_process(pid, out_file):
     now = datetime.datetime.now()
     cpu = pid.cpu_percent()
     mem = pid.memory_info()
     fds = pid.num_fds()
     dulwich_fds = count_dulwich_fds(pid)
     threads = pid.num_threads()
 
     content = [now.strftime('%m/%d/%y %H:%M:%S'),
                cpu,
                "%.2f" % (mem[0]/1024.0/1024.0),
                fds, dulwich_fds, threads]
     out_file.write("; ".join([str(item) for item in content]))
     out_file.write("\n")
 
 
 # Open output files
 vcs_out = get_file("vcs")
 if vcs_out is None:
     print "Unable to enumerate output file for VCS"
     sys.exit(1)
 rc_out = get_file("rc")
 if rc_out is None:
     print "Unable to enumerate output file for RC"
     sys.exit(1)
 
 # Show system information
 dump_system()
 
 print "\nStarting VCS..."
 vcs = psutil.Popen(["vcsserver"])
 time.sleep(1)
 if not vcs.is_running():
     print "VCS - Failed to start"
     sys.exit(1)
 print "VCS - Ok"
 
 print "\nStarting RhodeCode..."
 rc = psutil.Popen("RC_VCSSERVER_TEST_DISABLE=1 paster serve test.ini",
-                  shell=True, stdin=subprocess.PIPE)
+                  shell=True, stdin=subprocess32.PIPE)
 time.sleep(1)
 if not rc.is_running():
     print "RC - Failed to start"
     vcs.terminate()
     sys.exit(1)
 
 # Send command to create the databases
 rc.stdin.write("y\n")
 
 # Verify that the website is up
 time.sleep(4)
 try:
     urllib.urlopen(RC_WEBSITE)
 except IOError:
     print "RC - Website not started"
     vcs.terminate()
     sys.exit(1)
 print "RC - Ok"
 
 print "\nProfiling...\n%s\n" % ("-"*80)
 while True:
     try:
         dump_process(vcs, vcs_out)
         dump_process(rc, rc_out)
         time.sleep(PROFILING_INTERVAL)
     except Exception:
         print traceback.format_exc()
         break
 
 # Finalize the profiling
 vcs_out.close()
 rc_out.close()
 
 vcs.terminate()
 rc.terminate()

rhodecode/tests/load/vcs_performance.py

@@ -1,305 +1,305 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 VCS Performance measurement tool
 
 Usage:
 
 - Check that required vcs keys can be found in ~/.hgrc and ~/.netrc
 
 - Start a local instance of RhodeCode Enterprise
 
 - Launch the script:
 
     TMPDIR=/tmp python vcs_performance.py \
         --host=http://vm:5000 \
         --api-key=55c4a33688577da24183dcac5fde4dddfdbf18dc \
         --commits=10 --repositories=100 --log-level=info
 """
 
 import argparse
 import functools
 import logging
 import os
 import shutil
-import subprocess
+import subprocess32
 import tempfile
 import time
 from itertools import chain
 
 from api import RCApi, ApiError
 
 
 log = logging.getLogger(__name__)
 
 
 def timed(f):
     """Decorator that returns the time it took to execute the function."""
     @functools.wraps(f)
     def wrapped_f(*args, **kwargs):
         start_time = time.time()
         try:
             f(*args, **kwargs)
         finally:
             return time.time() - start_time
 
     return wrapped_f
 
 
 def mean(container):
     """Return the mean of the container."""
     if not container:
         return -1.0
     return sum(container) / len(container)
 
 
 class Config(object):
     args = None
 
     def __init__(self):
         parser = argparse.ArgumentParser(description='Runs VCS load tests')
         parser.add_argument(
             '--host', dest='host', action='store', required=True,
             help='RhodeCode Enterprise host')
         parser.add_argument(
             '--api-key', dest='api_key', action='store', required=True,
             help='API Key')
         parser.add_argument(
             '--file-size', dest='file_size', action='store', required=False,
             default=1, type=int, help='File size in MB')
         parser.add_argument(
             '--repositories', dest='repositories', action='store',
             required=False, default=1, type=int,
             help='Number of repositories')
         parser.add_argument(
             '--commits', dest='commits', action='store', required=False,
             default=1, type=int, help='Number of commits')
         parser.add_argument(
             '--log-level', dest='log_level', action='store', required=False,
             default='error', help='Logging level')
         self.args = parser.parse_args()
 
     def __getattr__(self, attr):
         return getattr(self.args, attr)
 
 
 class Repository(object):
     FILE_NAME_TEMPLATE = "test_{:09d}.bin"
 
     def __init__(self, name, base_path, api):
         self.name = name
         self.path = os.path.join(base_path, name)
         self.api = api
 
     def create(self):
         self._create_filesystem_repo(self.path)
         try:
             self.url = self.api.create_repo(
                 self.name, self.TYPE, 'Performance tests')
         except ApiError as e:
             log.error('api: {}'.format(e))
 
     def delete(self):
         self._delete_filesystem_repo()
         try:
             self.api.delete_repo(self.name)
         except ApiError as e:
             log.error('api: {}'.format(e))
 
     def create_commits(self, number, file_size):
         for i in xrange(number):
             file_name = self.FILE_NAME_TEMPLATE.format(i)
             log.debug("Create commit {}".format(file_name))
             self._create_file(file_name, file_size)
             self._create_commit(file_name)
 
     @timed
     def push(self):
         raise NotImplementedError()
 
     @timed
     def clone(self, destination_path):
         raise NotImplementedError()
 
     @timed
     def pull(self):
         raise NotImplementedError()
 
     def _run(self, *args):
         command = [self.BASE_COMMAND] + list(args)
-        process = subprocess.Popen(
-            command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        process = subprocess32.Popen(
+            command, stdout=subprocess32.PIPE, stderr=subprocess32.PIPE)
         return process.communicate()
 
     def _create_file(self, name, size):
         file_name = os.path.join(self.path, name)
         with open(file_name, 'wb') as f:
             f.write(os.urandom(1024))
 
     def _delete_filesystem_repo(self):
         shutil.rmtree(self.path)
 
     def _create_filesystem_repo(self, path):
         raise NotImplementedError()
 
     def _create_commit(self, file_name):
         raise NotImplementedError()
 
 
 class GitRepository(Repository):
     TYPE = 'git'
     BASE_COMMAND = 'git'
 
     @timed
     def push(self):
         os.chdir(self.path)
         self._run('push', '--set-upstream', self.url, 'master')
 
     @timed
     def clone(self, destination_path):
         self._run('clone', self.url, os.path.join(destination_path, self.name))
 
     @timed
     def pull(self, destination_path):
         path = os.path.join(destination_path, self.name)
         self._create_filesystem_repo(path)
         os.chdir(path)
         self._run('remote', 'add', 'origin', self.url)
         self._run('pull', 'origin', 'master')
 
     def _create_filesystem_repo(self, path):
         self._run('init', path)
 
     def _create_commit(self, file_name):
         os.chdir(self.path)
         self._run('add', file_name)
         self._run('commit', file_name, '-m', '"Add {}"'.format(file_name))
 
 
 class HgRepository(Repository):
     TYPE = 'hg'
     BASE_COMMAND = 'hg'
 
     @timed
     def push(self):
         os.chdir(self.path)
         self._run('push', self.url)
 
     @timed
     def clone(self, destination_path):
         self._run('clone', self.url, os.path.join(destination_path, self.name))
 
     @timed
     def pull(self, destination_path):
         path = os.path.join(destination_path, self.name)
         self._create_filesystem_repo(path)
         os.chdir(path)
         self._run('pull', '-r', 'tip', self.url)
 
     def _create_filesystem_repo(self, path):
         self._run('init', path)
 
     def _create_commit(self, file_name):
         os.chdir(self.path)
         self._run('add', file_name)
         self._run('commit', file_name, '-m', '"Add {}"'.format(file_name))
 
 
 class Benchmark(object):
     REPO_CLASSES = {
         'git': GitRepository,
         'hg': HgRepository
     }
     REPO_NAME = '{}_performance_{:03d}'
 
     def __init__(self, config):
         self.api = RCApi(api_key=config.api_key, rc_endpoint=config.host)
         self.source_path = tempfile.mkdtemp(suffix='vcsperformance')
 
         self.config = config
         self.git_repos = []
         self.hg_repos = []
 
         self._set_log_level()
 
     def start(self):
         self._create_repos()
         repos = {
             'git': self.git_repos,
             'hg': self.hg_repos
         }
 
         clone_destination_path = tempfile.mkdtemp(suffix='clone')
         pull_destination_path = tempfile.mkdtemp(suffix='pull')
         operations = [
             ('push', ),
             ('clone', clone_destination_path),
             ('pull', pull_destination_path)
         ]
 
         for operation in operations:
             for type_ in repos:
                 times = self._measure(repos[type_], *operation)
                 print("Mean {} {} time: {:.3f} sec.".format(
                     type_, operation[0], mean(times)))
 
     def cleanup(self):
         log.info("Cleaning up...")
         for repo in chain(self.git_repos, self.hg_repos):
             repo.delete()
 
     def _measure(self, repos, operation, *args):
         times = []
         for repo in repos:
             method = getattr(repo, operation)
             times.append(method(*args))
         return times
 
     def _create_repos(self):
         log.info("Creating repositories...")
         for i in xrange(self.config.repositories):
             self.git_repos.append(self._create_repo('git', i))
             self.hg_repos.append(self._create_repo('hg', i))
 
     def _create_repo(self, type_, id_):
         RepoClass = self.REPO_CLASSES[type_]
         repo = RepoClass(
             self.REPO_NAME.format(type_, id_), self.source_path, self.api)
         repo.create()
         repo.create_commits(self.config.commits, self.config.file_size)
         return repo
 
     def _set_log_level(self):
         try:
             log_level = getattr(logging, config.log_level.upper())
         except:
             log_level = logging.ERROR
         handler = logging.StreamHandler()
         log.addHandler(handler)
         log.setLevel(log_level)
 
 if __name__ == '__main__':
     config = Config()
     benchmark = Benchmark(config)
     try:
         benchmark.start()
     finally:
         benchmark.cleanup()

rhodecode/tests/other/vcs_operations/__init__.py

@@ -1,147 +1,147 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Base for test suite for making push/pull operations.
 
 .. important::
 
    You must have git >= 1.8.5 for tests to work fine. With 68b939b git started
    to redirect things to stderr instead of stdout.
 """
 
 from os.path import join as jn
-from subprocess import Popen, PIPE
+from subprocess32 import Popen, PIPE
 import logging
 import os
 import tempfile
 
 from rhodecode.tests import GIT_REPO, HG_REPO
 
 DEBUG = True
 RC_LOG = os.path.join(tempfile.gettempdir(), 'rc.log')
 REPO_GROUP = 'a_repo_group'
 HG_REPO_WITH_GROUP = '%s/%s' % (REPO_GROUP, HG_REPO)
 GIT_REPO_WITH_GROUP = '%s/%s' % (REPO_GROUP, GIT_REPO)
 
 log = logging.getLogger(__name__)
 
 
 class Command(object):
 
     def __init__(self, cwd):
         self.cwd = cwd
         self.process = None
 
     def execute(self, cmd, *args):
         """
         Runs command on the system with given ``args``.
         """
 
         command = cmd + ' ' + ' '.join(args)
         if DEBUG:
             log.debug('*** CMD %s ***' % (command,))
 
         env = dict(os.environ)
         # Delete coverage variables, as they make the test fail for Mercurial
         for key in env.keys():
             if key.startswith('COV_CORE_'):
                 del env[key]
 
         self.process = Popen(command, shell=True, stdout=PIPE, stderr=PIPE,
                              cwd=self.cwd, env=env)
         stdout, stderr = self.process.communicate()
         if DEBUG:
             log.debug('STDOUT:%s' % (stdout,))
             log.debug('STDERR:%s' % (stderr,))
         return stdout, stderr
 
     def assert_returncode_success(self):
         assert self.process.returncode == 0
 
 
 def _add_files_and_push(vcs, dest, clone_url=None, **kwargs):
     """
     Generate some files, add it to DEST repo and push back
     vcs is git or hg and defines what VCS we want to make those files for
     """
     # commit some stuff into this repo
     cwd = path = jn(dest)
     added_file = jn(path, '%ssetup.py' % tempfile._RandomNameSequence().next())
     Command(cwd).execute('touch %s' % added_file)
     Command(cwd).execute('%s add %s' % (vcs, added_file))
     author_str = 'Marcin Kuźminski <[e-mail]>'
 
     git_ident = "git config user.name {} && git config user.email {}".format(
             'Marcin Kuźminski', '[e-mail]')
 
     for i in xrange(kwargs.get('files_no', 3)):
         cmd = """echo 'added_line%s' >> %s""" % (i, added_file)
         Command(cwd).execute(cmd)
         if vcs == 'hg':
             cmd = """hg commit -m 'commited new %s' -u '%s' %s """ % (
                 i, author_str, added_file
             )
         elif vcs == 'git':
             cmd = """%s && git commit -m 'commited new %s' %s""" % (
                 git_ident, i, added_file)
         Command(cwd).execute(cmd)
 
     # PUSH it back
     stdout = stderr = None
     if vcs == 'hg':
         stdout, stderr = Command(cwd).execute(
             'hg push --verbose', clone_url)
     elif vcs == 'git':
         stdout, stderr = Command(cwd).execute(
             """%s && git push --verbose %s master""" % (
                 git_ident, clone_url))
 
     return stdout, stderr
 
 
 def _check_proper_git_push(
         stdout, stderr, branch='master', should_set_default_branch=False):
     # Note: Git is writing most information to stderr intentionally
     assert 'fatal' not in stderr
     assert 'rejected' not in stderr
     assert 'Pushing to' in stderr
     assert '%s -> %s' % (branch, branch) in stderr
 
     if should_set_default_branch:
         assert "Setting default branch to %s" % branch in stderr
     else:
         assert "Setting default branch" not in stderr
 
 
 def _check_proper_clone(stdout, stderr, vcs):
     if vcs == 'hg':
         assert 'requesting all changes' in stdout
         assert 'adding changesets' in stdout
         assert 'adding manifests' in stdout
         assert 'adding file changes' in stdout
 
         assert stderr == ''
 
     if vcs == 'git':
         assert '' == stdout
         assert 'Cloning into' in stderr
         assert 'abort:' not in stderr
         assert 'fatal:' not in stderr

rhodecode/tests/other/vcs_operations/conftest.py

@@ -1,257 +1,257 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 py.test config for test suite for making push/pull operations.
 
 .. important::
 
    You must have git >= 1.8.5 for tests to work fine. With 68b939b git started
    to redirect things to stderr instead of stdout.
 """
 
 import ConfigParser
 import os
-import subprocess
+import subprocess32
 import tempfile
 import textwrap
 import pytest
 
 import rhodecode
 from rhodecode.model.db import Repository
 from rhodecode.model.meta import Session
 from rhodecode.model.settings import SettingsModel
 from rhodecode.tests import (
     GIT_REPO, HG_REPO, TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS,)
 from rhodecode.tests.fixture import Fixture
 from rhodecode.tests.utils import (
     set_anonymous_access, is_url_reachable, wait_for_url)
 
 RC_LOG = os.path.join(tempfile.gettempdir(), 'rc.log')
 REPO_GROUP = 'a_repo_group'
 HG_REPO_WITH_GROUP = '%s/%s' % (REPO_GROUP, HG_REPO)
 GIT_REPO_WITH_GROUP = '%s/%s' % (REPO_GROUP, GIT_REPO)
 
 
 def assert_no_running_instance(url):
     if is_url_reachable(url):
         print("Hint: Usually this means another instance of Enterprise "
               "is running in the background.")
         pytest.fail(
             "Port is not free at %s, cannot start web interface" % url)
 
 
 def get_host_url(pylons_config):
     """Construct the host url using the port in the test configuration."""
     config = ConfigParser.ConfigParser()
     config.read(pylons_config)
 
     return '127.0.0.1:%s' % config.get('server:main', 'port')
 
 
 class RcWebServer(object):
     """
     Represents a running RCE web server used as a test fixture.
     """
     def __init__(self, pylons_config):
         self.pylons_config = pylons_config
 
     def repo_clone_url(self, repo_name, **kwargs):
         params = {
             'user': TEST_USER_ADMIN_LOGIN,
             'passwd': TEST_USER_ADMIN_PASS,
             'host': get_host_url(self.pylons_config),
             'cloned_repo': repo_name,
         }
         params.update(**kwargs)
         _url = 'http://%(user)s:%(passwd)s@%(host)s/%(cloned_repo)s' % params
         return _url
 
 
 @pytest.fixture(scope="module")
 def rcextensions(request, pylonsapp, tmpdir_factory):
     """
     Installs a testing rcextensions pack to ensure they work as expected.
     """
     init_content = textwrap.dedent("""
         # Forward import the example rcextensions to make it
         # active for our tests.
         from rhodecode.tests.other.example_rcextensions import *
     """)
 
     # Note: rcextensions are looked up based on the path of the ini file
     root_path = tmpdir_factory.getbasetemp()
     rcextensions_path = root_path.join('rcextensions')
     init_path = rcextensions_path.join('__init__.py')
 
     if rcextensions_path.check():
         pytest.fail(
             "Path for rcextensions already exists, please clean up before "
             "test run this path: %s" % (rcextensions_path, ))
         return
 
     request.addfinalizer(rcextensions_path.remove)
     init_path.write_binary(init_content, ensure=True)
 
 
 @pytest.fixture(scope="module")
 def repos(request, pylonsapp):
     """Create a copy of each test repo in a repo group."""
     fixture = Fixture()
     repo_group = fixture.create_repo_group(REPO_GROUP)
     repo_group_id = repo_group.group_id
     fixture.create_fork(HG_REPO, HG_REPO,
                         repo_name_full=HG_REPO_WITH_GROUP,
                         repo_group=repo_group_id)
     fixture.create_fork(GIT_REPO, GIT_REPO,
                         repo_name_full=GIT_REPO_WITH_GROUP,
                         repo_group=repo_group_id)
 
     @request.addfinalizer
     def cleanup():
         fixture.destroy_repo(HG_REPO_WITH_GROUP)
         fixture.destroy_repo(GIT_REPO_WITH_GROUP)
         fixture.destroy_repo_group(repo_group_id)
 
 
 @pytest.fixture(scope="module")
 def rc_web_server_config(pylons_config):
     """
     Configuration file used for the fixture `rc_web_server`.
     """
     return pylons_config
 
 
 @pytest.fixture(scope="module")
 def rc_web_server(
         request, pylonsapp, rc_web_server_config, repos, rcextensions):
     """
     Run the web server as a subprocess.
 
     Since we have already a running vcsserver, this is not spawned again.
     """
     env = os.environ.copy()
     env['RC_NO_TMP_PATH'] = '1'
 
     server_out = open(RC_LOG, 'w')
 
     # TODO: Would be great to capture the output and err of the subprocess
     # and make it available in a section of the py.test report in case of an
     # error.
 
     host_url = 'http://' + get_host_url(rc_web_server_config)
     assert_no_running_instance(host_url)
     command = ['rcserver', rc_web_server_config]
 
     print('Starting rcserver: {}'.format(host_url))
     print('Command: {}'.format(command))
     print('Logfile: {}'.format(RC_LOG))
 
-    proc = subprocess.Popen(
+    proc = subprocess32.Popen(
         command, bufsize=0, env=env, stdout=server_out, stderr=server_out)
 
     wait_for_url(host_url, timeout=30)
 
     @request.addfinalizer
     def stop_web_server():
         # TODO: Find out how to integrate with the reporting of py.test to
         # make this information available.
         print "\nServer log file written to %s" % (RC_LOG, )
         proc.kill()
         server_out.close()
 
     return RcWebServer(rc_web_server_config)
 
 
 @pytest.fixture(scope='class', autouse=True)
 def disable_anonymous_user_access(pylonsapp):
     set_anonymous_access(False)
 
 
 @pytest.fixture
 def disable_locking(pylonsapp):
     r = Repository.get_by_repo_name(GIT_REPO)
     Repository.unlock(r)
     r.enable_locking = False
     Session().add(r)
     Session().commit()
 
     r = Repository.get_by_repo_name(HG_REPO)
     Repository.unlock(r)
     r.enable_locking = False
     Session().add(r)
     Session().commit()
 
 
 @pytest.fixture
 def enable_auth_plugins(request, pylonsapp, csrf_token):
     """
     Return a factory object that when called, allows to control which
     authentication plugins are enabled.
     """
     def _enable_plugins(plugins_list, override=None):
         override = override or {}
         params = {
             'auth_plugins': ','.join(plugins_list),
             'csrf_token': csrf_token,
         }
 
         for module in plugins_list:
             plugin = rhodecode.authentication.base.loadplugin(module)
             plugin_name = plugin.name
             enabled_plugin = 'auth_%s_enabled' % plugin_name
             cache_ttl = 'auth_%s_cache_ttl' % plugin_name
 
             # default params that are needed for each plugin,
             # `enabled` and `cache_ttl`
             params.update({
                 enabled_plugin: True,
                 cache_ttl: 0
             })
             if override.get:
                 params.update(override.get(module, {}))
 
             validated_params = params
             for k, v in validated_params.items():
                 setting = SettingsModel().create_or_update_setting(k, v)
                 Session().add(setting)
             Session().commit()
 
     def cleanup():
         _enable_plugins(['egg:rhodecode-enterprise-ce#rhodecode'])
 
     request.addfinalizer(cleanup)
 
     return _enable_plugins
 
 
 @pytest.fixture
 def fs_repo_only(request, rhodecode_fixtures):
     def fs_repo_fabric(repo_name, repo_type):
         rhodecode_fixtures.create_repo(repo_name, repo_type=repo_type)
         rhodecode_fixtures.destroy_repo(repo_name, fs_remove=False)
 
         def cleanup():
             rhodecode_fixtures.destroy_repo(repo_name, fs_remove=True)
             rhodecode_fixtures.destroy_repo_on_filesystem(repo_name)
 
         request.addfinalizer(cleanup)
 
     return fs_repo_fabric

rhodecode/tests/plugin.py

@@ -1,1791 +1,1791 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import collections
 import datetime
 import hashlib
 import os
 import re
 import pprint
 import shutil
 import socket
-import subprocess
+import subprocess32
 import time
 import uuid
 
 import mock
 import pyramid.testing
 import pytest
 import colander
 import requests
 from webtest.app import TestApp
 
 import rhodecode
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import ChangesetCommentsModel
 from rhodecode.model.db import (
     PullRequest, Repository, RhodeCodeSetting, ChangesetStatus, RepoGroup,
-    UserGroup, RepoRhodeCodeUi, RepoRhodeCodeSetting, RhodeCodeUi, Integration)
+    UserGroup, RepoRhodeCodeUi, RepoRhodeCodeSetting, RhodeCodeUi)
 from rhodecode.model.meta import Session
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.user import UserModel
 from rhodecode.model.settings import VcsSettingsModel
 from rhodecode.model.user_group import UserGroupModel
 from rhodecode.model.integration import IntegrationModel
 from rhodecode.integrations import integration_type_registry
 from rhodecode.integrations.types.base import IntegrationTypeBase
 from rhodecode.lib.utils import repo2db_mapper
 from rhodecode.lib.vcs import create_vcsserver_proxy
 from rhodecode.lib.vcs.backends import get_backend
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.tests import (
     login_user_session, get_new_dir, utils, TESTS_TMP_PATH,
     TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR2_LOGIN,
     TEST_USER_REGULAR_PASS)
 from rhodecode.tests.fixture import Fixture
 
 
 def _split_comma(value):
     return value.split(',')
 
 
 def pytest_addoption(parser):
     parser.addoption(
         '--keep-tmp-path', action='store_true',
         help="Keep the test temporary directories")
     parser.addoption(
         '--backends', action='store', type=_split_comma,
         default=['git', 'hg', 'svn'],
         help="Select which backends to test for backend specific tests.")
     parser.addoption(
         '--dbs', action='store', type=_split_comma,
         default=['sqlite'],
         help="Select which database to test for database specific tests. "
              "Possible options are sqlite,postgres,mysql")
     parser.addoption(
         '--appenlight', '--ae', action='store_true',
         help="Track statistics in appenlight.")
     parser.addoption(
         '--appenlight-api-key', '--ae-key',
         help="API key for Appenlight.")
     parser.addoption(
         '--appenlight-url', '--ae-url',
         default="https://ae.rhodecode.com",
         help="Appenlight service URL, defaults to https://ae.rhodecode.com")
     parser.addoption(
         '--sqlite-connection-string', action='store',
         default='', help="Connection string for the dbs tests with SQLite")
     parser.addoption(
         '--postgres-connection-string', action='store',
         default='', help="Connection string for the dbs tests with Postgres")
     parser.addoption(
         '--mysql-connection-string', action='store',
         default='', help="Connection string for the dbs tests with MySQL")
     parser.addoption(
         '--repeat', type=int, default=100,
         help="Number of repetitions in performance tests.")
 
 
 def pytest_configure(config):
     # Appy the kombu patch early on, needed for test discovery on Python 2.7.11
     from rhodecode.config import patches
     patches.kombu_1_5_1_python_2_7_11()
 
 
 def pytest_collection_modifyitems(session, config, items):
     # nottest marked, compare nose, used for transition from nose to pytest
     remaining = [
         i for i in items if getattr(i.obj, '__test__', True)]
     items[:] = remaining
 
 
 def pytest_generate_tests(metafunc):
     # Support test generation based on --backend parameter
     if 'backend_alias' in metafunc.fixturenames:
         backends = get_backends_from_metafunc(metafunc)
         scope = None
         if not backends:
             pytest.skip("Not enabled for any of selected backends")
         metafunc.parametrize('backend_alias', backends, scope=scope)
     elif hasattr(metafunc.function, 'backends'):
         backends = get_backends_from_metafunc(metafunc)
         if not backends:
             pytest.skip("Not enabled for any of selected backends")
 
 
 def get_backends_from_metafunc(metafunc):
     requested_backends = set(metafunc.config.getoption('--backends'))
     if hasattr(metafunc.function, 'backends'):
         # Supported backends by this test function, created from
         # pytest.mark.backends
         backends = metafunc.function.backends.args
     elif hasattr(metafunc.cls, 'backend_alias'):
         # Support class attribute "backend_alias", this is mainly
         # for legacy reasons for tests not yet using pytest.mark.backends
         backends = [metafunc.cls.backend_alias]
     else:
         backends = metafunc.config.getoption('--backends')
     return requested_backends.intersection(backends)
 
 
 @pytest.fixture(scope='session', autouse=True)
 def activate_example_rcextensions(request):
     """
     Patch in an example rcextensions module which verifies passed in kwargs.
     """
     from rhodecode.tests.other import example_rcextensions
 
     old_extensions = rhodecode.EXTENSIONS
     rhodecode.EXTENSIONS = example_rcextensions
 
     @request.addfinalizer
     def cleanup():
         rhodecode.EXTENSIONS = old_extensions
 
 
 @pytest.fixture
 def capture_rcextensions():
     """
     Returns the recorded calls to entry points in rcextensions.
     """
     calls = rhodecode.EXTENSIONS.calls
     calls.clear()
     # Note: At this moment, it is still the empty dict, but that will
     # be filled during the test run and since it is a reference this
     # is enough to make it work.
     return calls
 
 
 @pytest.fixture(scope='session')
 def http_environ_session():
     """
     Allow to use "http_environ" in session scope.
     """
     return http_environ(
         http_host_stub=http_host_stub())
 
 
 @pytest.fixture
 def http_host_stub():
     """
     Value of HTTP_HOST in the test run.
     """
     return 'test.example.com:80'
 
 
 @pytest.fixture
 def http_environ(http_host_stub):
     """
     HTTP extra environ keys.
 
     User by the test application and as well for setting up the pylons
     environment. In the case of the fixture "app" it should be possible
     to override this for a specific test case.
     """
     return {
         'SERVER_NAME': http_host_stub.split(':')[0],
         'SERVER_PORT': http_host_stub.split(':')[1],
         'HTTP_HOST': http_host_stub,
     }
 
 
 @pytest.fixture(scope='function')
 def app(request, pylonsapp, http_environ):
     app = TestApp(
         pylonsapp,
         extra_environ=http_environ)
     if request.cls:
         request.cls.app = app
     return app
 
 
 @pytest.fixture(scope='session')
 def app_settings(pylonsapp, pylons_config):
     """
     Settings dictionary used to create the app.
 
     Parses the ini file and passes the result through the sanitize and apply
     defaults mechanism in `rhodecode.config.middleware`.
     """
     from paste.deploy.loadwsgi import loadcontext, APP
     from rhodecode.config.middleware import (
         sanitize_settings_and_apply_defaults)
     context = loadcontext(APP, 'config:' + pylons_config)
     settings = sanitize_settings_and_apply_defaults(context.config())
     return settings
 
 
 @pytest.fixture(scope='session')
 def db(app_settings):
     """
     Initializes the database connection.
 
     It uses the same settings which are used to create the ``pylonsapp`` or
     ``app`` fixtures.
     """
     from rhodecode.config.utils import initialize_database
     initialize_database(app_settings)
 
 
 LoginData = collections.namedtuple('LoginData', ('csrf_token', 'user'))
 
 
 def _autologin_user(app, *args):
     session = login_user_session(app, *args)
     csrf_token = rhodecode.lib.auth.get_csrf_token(session)
     return LoginData(csrf_token, session['rhodecode_user'])
 
 
 @pytest.fixture
 def autologin_user(app):
     """
     Utility fixture which makes sure that the admin user is logged in
     """
     return _autologin_user(app)
 
 
 @pytest.fixture
 def autologin_regular_user(app):
     """
     Utility fixture which makes sure that the regular user is logged in
     """
     return _autologin_user(
         app, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
 
 
 @pytest.fixture(scope='function')
 def csrf_token(request, autologin_user):
     return autologin_user.csrf_token
 
 
 @pytest.fixture(scope='function')
 def xhr_header(request):
     return {'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'}
 
 
 @pytest.fixture
 def real_crypto_backend(monkeypatch):
     """
     Switch the production crypto backend on for this test.
 
     During the test run the crypto backend is replaced with a faster
     implementation based on the MD5 algorithm.
     """
     monkeypatch.setattr(rhodecode, 'is_test', False)
 
 
 @pytest.fixture(scope='class')
 def index_location(request, pylonsapp):
     index_location = pylonsapp.config['app_conf']['search.location']
     if request.cls:
         request.cls.index_location = index_location
     return index_location
 
 
 @pytest.fixture(scope='session', autouse=True)
 def tests_tmp_path(request):
     """
     Create temporary directory to be used during the test session.
     """
     if not os.path.exists(TESTS_TMP_PATH):
         os.makedirs(TESTS_TMP_PATH)
 
     if not request.config.getoption('--keep-tmp-path'):
         @request.addfinalizer
         def remove_tmp_path():
             shutil.rmtree(TESTS_TMP_PATH)
 
     return TESTS_TMP_PATH
 
 
 @pytest.fixture(scope='session', autouse=True)
 def patch_pyro_request_scope_proxy_factory(request):
     """
     Patch the pyro proxy factory to always use the same dummy request object
     when under test. This will return the same pyro proxy on every call.
     """
     dummy_request = pyramid.testing.DummyRequest()
 
     def mocked_call(self, request=None):
         return self.getProxy(request=dummy_request)
 
     patcher = mock.patch(
         'rhodecode.lib.vcs.client.RequestScopeProxyFactory.__call__',
         new=mocked_call)
     patcher.start()
 
     @request.addfinalizer
     def undo_patching():
         patcher.stop()
 
 
 @pytest.fixture
 def test_repo_group(request):
     """
     Create a temporary repository group, and destroy it after
     usage automatically
     """
     fixture = Fixture()
     repogroupid = 'test_repo_group_%s' % int(time.time())
     repo_group = fixture.create_repo_group(repogroupid)
 
     def _cleanup():
         fixture.destroy_repo_group(repogroupid)
 
     request.addfinalizer(_cleanup)
     return repo_group
 
 
 @pytest.fixture
 def test_user_group(request):
     """
     Create a temporary user group, and destroy it after
     usage automatically
     """
     fixture = Fixture()
     usergroupid = 'test_user_group_%s' % int(time.time())
     user_group = fixture.create_user_group(usergroupid)
 
     def _cleanup():
         fixture.destroy_user_group(user_group)
 
     request.addfinalizer(_cleanup)
     return user_group
 
 
 @pytest.fixture(scope='session')
 def test_repo(request):
     container = TestRepoContainer()
     request.addfinalizer(container._cleanup)
     return container
 
 
 class TestRepoContainer(object):
     """
     Container for test repositories which are used read only.
 
     Repositories will be created on demand and re-used during the lifetime
     of this object.
 
     Usage to get the svn test repository "minimal"::
 
        test_repo = TestContainer()
        repo = test_repo('minimal', 'svn')
 
     """
 
     dump_extractors = {
         'git': utils.extract_git_repo_from_dump,
         'hg': utils.extract_hg_repo_from_dump,
         'svn': utils.extract_svn_repo_from_dump,
     }
 
     def __init__(self):
         self._cleanup_repos = []
         self._fixture = Fixture()
         self._repos = {}
 
     def __call__(self, dump_name, backend_alias):
         key = (dump_name, backend_alias)
         if key not in self._repos:
             repo = self._create_repo(dump_name, backend_alias)
             self._repos[key] = repo.repo_id
         return Repository.get(self._repos[key])
 
     def _create_repo(self, dump_name, backend_alias):
         repo_name = '%s-%s' % (backend_alias, dump_name)
         backend_class = get_backend(backend_alias)
         dump_extractor = self.dump_extractors[backend_alias]
         repo_path = dump_extractor(dump_name, repo_name)
         vcs_repo = backend_class(repo_path)
         repo2db_mapper({repo_name: vcs_repo})
         repo = RepoModel().get_by_repo_name(repo_name)
         self._cleanup_repos.append(repo_name)
         return repo
 
     def _cleanup(self):
         for repo_name in reversed(self._cleanup_repos):
             self._fixture.destroy_repo(repo_name)
 
 
 @pytest.fixture
 def backend(request, backend_alias, pylonsapp, test_repo):
     """
     Parametrized fixture which represents a single backend implementation.
 
     It respects the option `--backends` to focus the test run on specific
     backend implementations.
 
     It also supports `pytest.mark.xfail_backends` to mark tests as failing
     for specific backends. This is intended as a utility for incremental
     development of a new backend implementation.
     """
     if backend_alias not in request.config.getoption('--backends'):
         pytest.skip("Backend %s not selected." % (backend_alias, ))
 
     utils.check_xfail_backends(request.node, backend_alias)
     utils.check_skip_backends(request.node, backend_alias)
 
     repo_name = 'vcs_test_%s' % (backend_alias, )
     backend = Backend(
         alias=backend_alias,
         repo_name=repo_name,
         test_name=request.node.name,
         test_repo_container=test_repo)
     request.addfinalizer(backend.cleanup)
     return backend
 
 
 @pytest.fixture
 def backend_git(request, pylonsapp, test_repo):
     return backend(request, 'git', pylonsapp, test_repo)
 
 
 @pytest.fixture
 def backend_hg(request, pylonsapp, test_repo):
     return backend(request, 'hg', pylonsapp, test_repo)
 
 
 @pytest.fixture
 def backend_svn(request, pylonsapp, test_repo):
     return backend(request, 'svn', pylonsapp, test_repo)
 
 
 @pytest.fixture
 def backend_random(backend_git):
     """
     Use this to express that your tests need "a backend.
 
     A few of our tests need a backend, so that we can run the code. This
     fixture is intended to be used for such cases. It will pick one of the
     backends and run the tests.
 
     The fixture `backend` would run the test multiple times for each
     available backend which is a pure waste of time if the test is
     independent of the backend type.
     """
     # TODO: johbo: Change this to pick a random backend
     return backend_git
 
 
 @pytest.fixture
 def backend_stub(backend_git):
     """
     Use this to express that your tests need a backend stub
 
     TODO: mikhail: Implement a real stub logic instead of returning
     a git backend
     """
     return backend_git
 
 
 @pytest.fixture
 def repo_stub(backend_stub):
     """
     Use this to express that your tests need a repository stub
     """
     return backend_stub.create_repo()
 
 
 class Backend(object):
     """
     Represents the test configuration for one supported backend
 
     Provides easy access to different test repositories based on
     `__getitem__`. Such repositories will only be created once per test
     session.
     """
 
     invalid_repo_name = re.compile(r'[^0-9a-zA-Z]+')
     _master_repo = None
     _commit_ids = {}
 
     def __init__(self, alias, repo_name, test_name, test_repo_container):
         self.alias = alias
         self.repo_name = repo_name
         self._cleanup_repos = []
         self._test_name = test_name
         self._test_repo_container = test_repo_container
         # TODO: johbo: Used as a delegate interim. Not yet sure if Backend or
         # Fixture will survive in the end.
         self._fixture = Fixture()
 
     def __getitem__(self, key):
         return self._test_repo_container(key, self.alias)
 
     @property
     def repo(self):
         """
         Returns the "current" repository. This is the vcs_test repo or the
         last repo which has been created with `create_repo`.
         """
         from rhodecode.model.db import Repository
         return Repository.get_by_repo_name(self.repo_name)
 
     @property
     def default_branch_name(self):
         VcsRepository = get_backend(self.alias)
         return VcsRepository.DEFAULT_BRANCH_NAME
 
     @property
     def default_head_id(self):
         """
         Returns the default head id of the underlying backend.
 
         This will be the default branch name in case the backend does have a
         default branch. In the other cases it will point to a valid head
         which can serve as the base to create a new commit on top of it.
         """
         vcsrepo = self.repo.scm_instance()
         head_id = (
             vcsrepo.DEFAULT_BRANCH_NAME or
             vcsrepo.commit_ids[-1])
         return head_id
 
     @property
     def commit_ids(self):
         """
         Returns the list of commits for the last created repository
         """
         return self._commit_ids
 
     def create_master_repo(self, commits):
         """
         Create a repository and remember it as a template.
 
         This allows to easily create derived repositories to construct
         more complex scenarios for diff, compare and pull requests.
 
         Returns a commit map which maps from commit message to raw_id.
         """
         self._master_repo = self.create_repo(commits=commits)
         return self._commit_ids
 
     def create_repo(
             self, commits=None, number_of_commits=0, heads=None,
             name_suffix=u'', **kwargs):
         """
         Create a repository and record it for later cleanup.
 
         :param commits: Optional. A sequence of dict instances.
            Will add a commit per entry to the new repository.
         :param number_of_commits: Optional. If set to a number, this number of
            commits will be added to the new repository.
         :param heads: Optional. Can be set to a sequence of of commit
            names which shall be pulled in from the master repository.
 
         """
         self.repo_name = self._next_repo_name() + name_suffix
         repo = self._fixture.create_repo(
             self.repo_name, repo_type=self.alias, **kwargs)
         self._cleanup_repos.append(repo.repo_name)
 
         commits = commits or [
             {'message': 'Commit %s of %s' % (x, self.repo_name)}
             for x in xrange(number_of_commits)]
         self._add_commits_to_repo(repo.scm_instance(), commits)
         if heads:
             self.pull_heads(repo, heads)
 
         return repo
 
     def pull_heads(self, repo, heads):
         """
         Make sure that repo contains all commits mentioned in `heads`
         """
         vcsmaster = self._master_repo.scm_instance()
         vcsrepo = repo.scm_instance()
         vcsrepo.config.clear_section('hooks')
         commit_ids = [self._commit_ids[h] for h in heads]
         vcsrepo.pull(vcsmaster.path, commit_ids=commit_ids)
 
     def create_fork(self):
         repo_to_fork = self.repo_name
         self.repo_name = self._next_repo_name()
         repo = self._fixture.create_fork(repo_to_fork, self.repo_name)
         self._cleanup_repos.append(self.repo_name)
         return repo
 
     def new_repo_name(self, suffix=u''):
         self.repo_name = self._next_repo_name() + suffix
         self._cleanup_repos.append(self.repo_name)
         return self.repo_name
 
     def _next_repo_name(self):
         return u"%s_%s" % (
             self.invalid_repo_name.sub(u'_', self._test_name),
             len(self._cleanup_repos))
 
     def ensure_file(self, filename, content='Test content\n'):
         assert self._cleanup_repos, "Avoid writing into vcs_test repos"
         commits = [
             {'added': [
                 FileNode(filename, content=content),
             ]},
         ]
         self._add_commits_to_repo(self.repo.scm_instance(), commits)
 
     def enable_downloads(self):
         repo = self.repo
         repo.enable_downloads = True
         Session().add(repo)
         Session().commit()
 
     def cleanup(self):
         for repo_name in reversed(self._cleanup_repos):
             self._fixture.destroy_repo(repo_name)
 
     def _add_commits_to_repo(self, repo, commits):
         commit_ids = _add_commits_to_repo(repo, commits)
         if not commit_ids:
             return
         self._commit_ids = commit_ids
 
         # Creating refs for Git to allow fetching them from remote repository
         if self.alias == 'git':
             refs = {}
             for message in self._commit_ids:
                 # TODO: mikhail: do more special chars replacements
                 ref_name = 'refs/test-refs/{}'.format(
                     message.replace(' ', ''))
                 refs[ref_name] = self._commit_ids[message]
             self._create_refs(repo, refs)
 
     def _create_refs(self, repo, refs):
         for ref_name in refs:
             repo.set_refs(ref_name, refs[ref_name])
 
 
 @pytest.fixture
 def vcsbackend(request, backend_alias, tests_tmp_path, pylonsapp, test_repo):
     """
     Parametrized fixture which represents a single vcs backend implementation.
 
     See the fixture `backend` for more details. This one implements the same
     concept, but on vcs level. So it does not provide model instances etc.
 
     Parameters are generated dynamically, see :func:`pytest_generate_tests`
     for how this works.
     """
     if backend_alias not in request.config.getoption('--backends'):
         pytest.skip("Backend %s not selected." % (backend_alias, ))
 
     utils.check_xfail_backends(request.node, backend_alias)
     utils.check_skip_backends(request.node, backend_alias)
 
     repo_name = 'vcs_test_%s' % (backend_alias, )
     repo_path = os.path.join(tests_tmp_path, repo_name)
     backend = VcsBackend(
         alias=backend_alias,
         repo_path=repo_path,
         test_name=request.node.name,
         test_repo_container=test_repo)
     request.addfinalizer(backend.cleanup)
     return backend
 
 
 @pytest.fixture
 def vcsbackend_git(request, tests_tmp_path, pylonsapp, test_repo):
     return vcsbackend(request, 'git', tests_tmp_path, pylonsapp, test_repo)
 
 
 @pytest.fixture
 def vcsbackend_hg(request, tests_tmp_path, pylonsapp, test_repo):
     return vcsbackend(request, 'hg', tests_tmp_path, pylonsapp, test_repo)
 
 
 @pytest.fixture
 def vcsbackend_svn(request, tests_tmp_path, pylonsapp, test_repo):
     return vcsbackend(request, 'svn', tests_tmp_path, pylonsapp, test_repo)
 
 
 @pytest.fixture
 def vcsbackend_random(vcsbackend_git):
     """
     Use this to express that your tests need "a vcsbackend".
 
     The fixture `vcsbackend` would run the test multiple times for each
     available vcs backend which is a pure waste of time if the test is
     independent of the vcs backend type.
     """
     # TODO: johbo: Change this to pick a random backend
     return vcsbackend_git
 
 
 @pytest.fixture
 def vcsbackend_stub(vcsbackend_git):
     """
     Use this to express that your test just needs a stub of a vcsbackend.
 
     Plan is to eventually implement an in-memory stub to speed tests up.
     """
     return vcsbackend_git
 
 
 class VcsBackend(object):
     """
     Represents the test configuration for one supported vcs backend.
     """
 
     invalid_repo_name = re.compile(r'[^0-9a-zA-Z]+')
 
     def __init__(self, alias, repo_path, test_name, test_repo_container):
         self.alias = alias
         self._repo_path = repo_path
         self._cleanup_repos = []
         self._test_name = test_name
         self._test_repo_container = test_repo_container
 
     def __getitem__(self, key):
         return self._test_repo_container(key, self.alias).scm_instance()
 
     @property
     def repo(self):
         """
         Returns the "current" repository. This is the vcs_test repo of the last
         repo which has been created.
         """
         Repository = get_backend(self.alias)
         return Repository(self._repo_path)
 
     @property
     def backend(self):
         """
         Returns the backend implementation class.
         """
         return get_backend(self.alias)
 
     def create_repo(self, commits=None, number_of_commits=0, _clone_repo=None):
         repo_name = self._next_repo_name()
         self._repo_path = get_new_dir(repo_name)
         repo_class = get_backend(self.alias)
         src_url = None
         if _clone_repo:
             src_url = _clone_repo.path
         repo = repo_class(self._repo_path, create=True, src_url=src_url)
         self._cleanup_repos.append(repo)
 
         commits = commits or [
             {'message': 'Commit %s of %s' % (x, repo_name)}
             for x in xrange(number_of_commits)]
         _add_commits_to_repo(repo, commits)
         return repo
 
     def clone_repo(self, repo):
         return self.create_repo(_clone_repo=repo)
 
     def cleanup(self):
         for repo in self._cleanup_repos:
             shutil.rmtree(repo.path)
 
     def new_repo_path(self):
         repo_name = self._next_repo_name()
         self._repo_path = get_new_dir(repo_name)
         return self._repo_path
 
     def _next_repo_name(self):
         return "%s_%s" % (
             self.invalid_repo_name.sub('_', self._test_name),
             len(self._cleanup_repos))
 
     def add_file(self, repo, filename, content='Test content\n'):
         imc = repo.in_memory_commit
         imc.add(FileNode(filename, content=content))
         imc.commit(
             message=u'Automatic commit from vcsbackend fixture',
             author=u'Automatic')
 
     def ensure_file(self, filename, content='Test content\n'):
         assert self._cleanup_repos, "Avoid writing into vcs_test repos"
         self.add_file(self.repo, filename, content)
 
 
 def _add_commits_to_repo(vcs_repo, commits):
     commit_ids = {}
     if not commits:
         return commit_ids
 
     imc = vcs_repo.in_memory_commit
     commit = None
 
     for idx, commit in enumerate(commits):
         message = unicode(commit.get('message', 'Commit %s' % idx))
 
         for node in commit.get('added', []):
             imc.add(FileNode(node.path, content=node.content))
         for node in commit.get('changed', []):
             imc.change(FileNode(node.path, content=node.content))
         for node in commit.get('removed', []):
             imc.remove(FileNode(node.path))
 
         parents = [
             vcs_repo.get_commit(commit_id=commit_ids[p])
             for p in commit.get('parents', [])]
 
         operations = ('added', 'changed', 'removed')
         if not any((commit.get(o) for o in operations)):
             imc.add(FileNode('file_%s' % idx, content=message))
 
         commit = imc.commit(
             message=message,
             author=unicode(commit.get('author', 'Automatic')),
             date=commit.get('date'),
             branch=commit.get('branch'),
             parents=parents)
 
         commit_ids[commit.message] = commit.raw_id
 
     return commit_ids
 
 
 @pytest.fixture
 def reposerver(request):
     """
     Allows to serve a backend repository
     """
 
     repo_server = RepoServer()
     request.addfinalizer(repo_server.cleanup)
     return repo_server
 
 
 class RepoServer(object):
     """
     Utility to serve a local repository for the duration of a test case.
 
     Supports only Subversion so far.
     """
 
     url = None
 
     def __init__(self):
         self._cleanup_servers = []
 
     def serve(self, vcsrepo):
         if vcsrepo.alias != 'svn':
             raise TypeError("Backend %s not supported" % vcsrepo.alias)
 
-        proc = subprocess.Popen(
+        proc = subprocess32.Popen(
             ['svnserve', '-d', '--foreground', '--listen-host', 'localhost',
              '--root', vcsrepo.path])
         self._cleanup_servers.append(proc)
         self.url = 'svn://localhost'
 
     def cleanup(self):
         for proc in self._cleanup_servers:
             proc.terminate()
 
 
 @pytest.fixture
 def pr_util(backend, request):
     """
     Utility for tests of models and for functional tests around pull requests.
 
     It gives an instance of :class:`PRTestUtility` which provides various
     utility methods around one pull request.
 
     This fixture uses `backend` and inherits its parameterization.
     """
 
     util = PRTestUtility(backend)
 
     @request.addfinalizer
     def cleanup():
         util.cleanup()
 
     return util
 
 
 class PRTestUtility(object):
 
     pull_request = None
     pull_request_id = None
     mergeable_patcher = None
     mergeable_mock = None
     notification_patcher = None
 
     def __init__(self, backend):
         self.backend = backend
 
     def create_pull_request(
             self, commits=None, target_head=None, source_head=None,
             revisions=None, approved=False, author=None, mergeable=False,
             enable_notifications=True, name_suffix=u'', reviewers=None,
             title=u"Test", description=u"Description"):
         self.set_mergeable(mergeable)
         if not enable_notifications:
             # mock notification side effect
             self.notification_patcher = mock.patch(
                 'rhodecode.model.notification.NotificationModel.create')
             self.notification_patcher.start()
 
         if not self.pull_request:
             if not commits:
                 commits = [
                     {'message': 'c1'},
                     {'message': 'c2'},
                     {'message': 'c3'},
                 ]
                 target_head = 'c1'
                 source_head = 'c2'
                 revisions = ['c2']
 
             self.commit_ids = self.backend.create_master_repo(commits)
             self.target_repository = self.backend.create_repo(
                 heads=[target_head], name_suffix=name_suffix)
             self.source_repository = self.backend.create_repo(
                 heads=[source_head], name_suffix=name_suffix)
             self.author = author or UserModel().get_by_username(
                 TEST_USER_ADMIN_LOGIN)
 
             model = PullRequestModel()
             self.create_parameters = {
                 'created_by': self.author,
                 'source_repo': self.source_repository.repo_name,
                 'source_ref': self._default_branch_reference(source_head),
                 'target_repo': self.target_repository.repo_name,
                 'target_ref': self._default_branch_reference(target_head),
                 'revisions': [self.commit_ids[r] for r in revisions],
                 'reviewers': reviewers or self._get_reviewers(),
                 'title': title,
                 'description': description,
             }
             self.pull_request = model.create(**self.create_parameters)
             assert model.get_versions(self.pull_request) == []
 
             self.pull_request_id = self.pull_request.pull_request_id
 
             if approved:
                 self.approve()
 
             Session().add(self.pull_request)
             Session().commit()
 
         return self.pull_request
 
     def approve(self):
         self.create_status_votes(
             ChangesetStatus.STATUS_APPROVED,
             *self.pull_request.reviewers)
 
     def close(self):
         PullRequestModel().close_pull_request(self.pull_request, self.author)
 
     def _default_branch_reference(self, commit_message):
         reference = '%s:%s:%s' % (
             'branch',
             self.backend.default_branch_name,
             self.commit_ids[commit_message])
         return reference
 
     def _get_reviewers(self):
         model = UserModel()
         return [
             model.get_by_username(TEST_USER_REGULAR_LOGIN),
             model.get_by_username(TEST_USER_REGULAR2_LOGIN),
         ]
 
     def update_source_repository(self, head=None):
         heads = [head or 'c3']
         self.backend.pull_heads(self.source_repository, heads=heads)
 
     def add_one_commit(self, head=None):
         self.update_source_repository(head=head)
         old_commit_ids = set(self.pull_request.revisions)
         PullRequestModel().update_commits(self.pull_request)
         commit_ids = set(self.pull_request.revisions)
         new_commit_ids = commit_ids - old_commit_ids
         assert len(new_commit_ids) == 1
         return new_commit_ids.pop()
 
     def remove_one_commit(self):
         assert len(self.pull_request.revisions) == 2
         source_vcs = self.source_repository.scm_instance()
         removed_commit_id = source_vcs.commit_ids[-1]
 
         # TODO: johbo: Git and Mercurial have an inconsistent vcs api here,
         # remove the if once that's sorted out.
         if self.backend.alias == "git":
             kwargs = {'branch_name': self.backend.default_branch_name}
         else:
             kwargs = {}
         source_vcs.strip(removed_commit_id, **kwargs)
 
         PullRequestModel().update_commits(self.pull_request)
         assert len(self.pull_request.revisions) == 1
         return removed_commit_id
 
     def create_comment(self, linked_to=None):
         comment = ChangesetCommentsModel().create(
             text=u"Test comment",
             repo=self.target_repository.repo_name,
             user=self.author,
             pull_request=self.pull_request)
         assert comment.pull_request_version_id is None
 
         if linked_to:
             PullRequestModel()._link_comments_to_version(linked_to)
 
         return comment
 
     def create_inline_comment(
             self, linked_to=None, line_no=u'n1', file_path='file_1'):
         comment = ChangesetCommentsModel().create(
             text=u"Test comment",
             repo=self.target_repository.repo_name,
             user=self.author,
             line_no=line_no,
             f_path=file_path,
             pull_request=self.pull_request)
         assert comment.pull_request_version_id is None
 
         if linked_to:
             PullRequestModel()._link_comments_to_version(linked_to)
 
         return comment
 
     def create_version_of_pull_request(self):
         pull_request = self.create_pull_request()
         version = PullRequestModel()._create_version_from_snapshot(
             pull_request)
         return version
 
     def create_status_votes(self, status, *reviewers):
         for reviewer in reviewers:
             ChangesetStatusModel().set_status(
                 repo=self.pull_request.target_repo,
                 status=status,
                 user=reviewer.user_id,
                 pull_request=self.pull_request)
 
     def set_mergeable(self, value):
         if not self.mergeable_patcher:
             self.mergeable_patcher = mock.patch.object(
                 VcsSettingsModel, 'get_general_settings')
             self.mergeable_mock = self.mergeable_patcher.start()
         self.mergeable_mock.return_value = {
             'rhodecode_pr_merge_enabled': value}
 
     def cleanup(self):
         # In case the source repository is already cleaned up, the pull
         # request will already be deleted.
         pull_request = PullRequest().get(self.pull_request_id)
         if pull_request:
             PullRequestModel().delete(pull_request)
             Session().commit()
 
         if self.notification_patcher:
             self.notification_patcher.stop()
 
         if self.mergeable_patcher:
             self.mergeable_patcher.stop()
 
 
 @pytest.fixture
 def user_admin(pylonsapp):
     """
     Provides the default admin test user as an instance of `db.User`.
     """
     user = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
     return user
 
 
 @pytest.fixture
 def user_regular(pylonsapp):
     """
     Provides the default regular test user as an instance of `db.User`.
     """
     user = UserModel().get_by_username(TEST_USER_REGULAR_LOGIN)
     return user
 
 
 @pytest.fixture
 def user_util(request, pylonsapp):
     """
     Provides a wired instance of `UserUtility` with integrated cleanup.
     """
     utility = UserUtility(test_name=request.node.name)
     request.addfinalizer(utility.cleanup)
     return utility
 
 
 # TODO: johbo: Split this up into utilities per domain or something similar
 class UserUtility(object):
 
     def __init__(self, test_name="test"):
         self._test_name = test_name
         self.fixture = Fixture()
         self.repo_group_ids = []
         self.user_ids = []
         self.user_group_ids = []
         self.user_repo_permission_ids = []
         self.user_group_repo_permission_ids = []
         self.user_repo_group_permission_ids = []
         self.user_group_repo_group_permission_ids = []
         self.user_user_group_permission_ids = []
         self.user_group_user_group_permission_ids = []
         self.user_permissions = []
 
     def create_repo_group(
             self, owner=TEST_USER_ADMIN_LOGIN, auto_cleanup=True):
         group_name = "{prefix}_repogroup_{count}".format(
             prefix=self._test_name,
             count=len(self.repo_group_ids))
         repo_group = self.fixture.create_repo_group(
             group_name, cur_user=owner)
         if auto_cleanup:
             self.repo_group_ids.append(repo_group.group_id)
         return repo_group
 
     def create_user(self, auto_cleanup=True, **kwargs):
         user_name = "{prefix}_user_{count}".format(
             prefix=self._test_name,
             count=len(self.user_ids))
         user = self.fixture.create_user(user_name, **kwargs)
         if auto_cleanup:
             self.user_ids.append(user.user_id)
         return user
 
     def create_user_with_group(self):
         user = self.create_user()
         user_group = self.create_user_group(members=[user])
         return user, user_group
 
     def create_user_group(self, members=None, auto_cleanup=True, **kwargs):
         group_name = "{prefix}_usergroup_{count}".format(
             prefix=self._test_name,
             count=len(self.user_group_ids))
         user_group = self.fixture.create_user_group(group_name, **kwargs)
         if auto_cleanup:
             self.user_group_ids.append(user_group.users_group_id)
         if members:
             for user in members:
                 UserGroupModel().add_user_to_group(user_group, user)
         return user_group
 
     def grant_user_permission(self, user_name, permission_name):
         self._inherit_default_user_permissions(user_name, False)
         self.user_permissions.append((user_name, permission_name))
 
     def grant_user_permission_to_repo_group(
             self, repo_group, user, permission_name):
         permission = RepoGroupModel().grant_user_permission(
             repo_group, user, permission_name)
         self.user_repo_group_permission_ids.append(
             (repo_group.group_id, user.user_id))
         return permission
 
     def grant_user_group_permission_to_repo_group(
             self, repo_group, user_group, permission_name):
         permission = RepoGroupModel().grant_user_group_permission(
             repo_group, user_group, permission_name)
         self.user_group_repo_group_permission_ids.append(
             (repo_group.group_id, user_group.users_group_id))
         return permission
 
     def grant_user_permission_to_repo(
             self, repo, user, permission_name):
         permission = RepoModel().grant_user_permission(
             repo, user, permission_name)
         self.user_repo_permission_ids.append(
             (repo.repo_id, user.user_id))
         return permission
 
     def grant_user_group_permission_to_repo(
             self, repo, user_group, permission_name):
         permission = RepoModel().grant_user_group_permission(
             repo, user_group, permission_name)
         self.user_group_repo_permission_ids.append(
             (repo.repo_id, user_group.users_group_id))
         return permission
 
     def grant_user_permission_to_user_group(
             self, target_user_group, user, permission_name):
         permission = UserGroupModel().grant_user_permission(
             target_user_group, user, permission_name)
         self.user_user_group_permission_ids.append(
             (target_user_group.users_group_id, user.user_id))
         return permission
 
     def grant_user_group_permission_to_user_group(
             self, target_user_group, user_group, permission_name):
         permission = UserGroupModel().grant_user_group_permission(
             target_user_group, user_group, permission_name)
         self.user_group_user_group_permission_ids.append(
             (target_user_group.users_group_id, user_group.users_group_id))
         return permission
 
     def revoke_user_permission(self, user_name, permission_name):
         self._inherit_default_user_permissions(user_name, True)
         UserModel().revoke_perm(user_name, permission_name)
 
     def _inherit_default_user_permissions(self, user_name, value):
         user = UserModel().get_by_username(user_name)
         user.inherit_default_permissions = value
         Session().add(user)
         Session().commit()
 
     def cleanup(self):
         self._cleanup_permissions()
         self._cleanup_repo_groups()
         self._cleanup_user_groups()
         self._cleanup_users()
 
     def _cleanup_permissions(self):
         if self.user_permissions:
             for user_name, permission_name in self.user_permissions:
                 self.revoke_user_permission(user_name, permission_name)
 
         for permission in self.user_repo_permission_ids:
             RepoModel().revoke_user_permission(*permission)
 
         for permission in self.user_group_repo_permission_ids:
             RepoModel().revoke_user_group_permission(*permission)
 
         for permission in self.user_repo_group_permission_ids:
             RepoGroupModel().revoke_user_permission(*permission)
 
         for permission in self.user_group_repo_group_permission_ids:
             RepoGroupModel().revoke_user_group_permission(*permission)
 
         for permission in self.user_user_group_permission_ids:
             UserGroupModel().revoke_user_permission(*permission)
 
         for permission in self.user_group_user_group_permission_ids:
             UserGroupModel().revoke_user_group_permission(*permission)
 
     def _cleanup_repo_groups(self):
         def _repo_group_compare(first_group_id, second_group_id):
             """
             Gives higher priority to the groups with the most complex paths
             """
             first_group = RepoGroup.get(first_group_id)
             second_group = RepoGroup.get(second_group_id)
             first_group_parts = (
                 len(first_group.group_name.split('/')) if first_group else 0)
             second_group_parts = (
                 len(second_group.group_name.split('/')) if second_group else 0)
             return cmp(second_group_parts, first_group_parts)
 
         sorted_repo_group_ids = sorted(
             self.repo_group_ids, cmp=_repo_group_compare)
         for repo_group_id in sorted_repo_group_ids:
             self.fixture.destroy_repo_group(repo_group_id)
 
     def _cleanup_user_groups(self):
         def _user_group_compare(first_group_id, second_group_id):
             """
             Gives higher priority to the groups with the most complex paths
             """
             first_group = UserGroup.get(first_group_id)
             second_group = UserGroup.get(second_group_id)
             first_group_parts = (
                 len(first_group.users_group_name.split('/'))
                 if first_group else 0)
             second_group_parts = (
                 len(second_group.users_group_name.split('/'))
                 if second_group else 0)
             return cmp(second_group_parts, first_group_parts)
 
         sorted_user_group_ids = sorted(
             self.user_group_ids, cmp=_user_group_compare)
         for user_group_id in sorted_user_group_ids:
             self.fixture.destroy_user_group(user_group_id)
 
     def _cleanup_users(self):
         for user_id in self.user_ids:
             self.fixture.destroy_user(user_id)
 
 
 # TODO: Think about moving this into a pytest-pyro package and make it a
 # pytest plugin
 @pytest.hookimpl(tryfirst=True, hookwrapper=True)
 def pytest_runtest_makereport(item, call):
     """
     Adding the remote traceback if the exception has this information.
 
     Pyro4 attaches this information as the attribute `_pyroTraceback`
     to the exception instance.
     """
     outcome = yield
     report = outcome.get_result()
     if call.excinfo:
         _add_pyro_remote_traceback(report, call.excinfo.value)
 
 
 def _add_pyro_remote_traceback(report, exc):
     pyro_traceback = getattr(exc, '_pyroTraceback', None)
 
     if pyro_traceback:
         traceback = ''.join(pyro_traceback)
         section = 'Pyro4 remote traceback ' + report.when
         report.sections.append((section, traceback))
 
 
 @pytest.fixture(scope='session')
 def testrun():
     return {
         'uuid': uuid.uuid4(),
         'start': datetime.datetime.utcnow().isoformat(),
         'timestamp': int(time.time()),
     }
 
 
 @pytest.fixture(autouse=True)
 def collect_appenlight_stats(request, testrun):
     """
     This fixture reports memory consumtion of single tests.
 
     It gathers data based on `psutil` and sends them to Appenlight. The option
     ``--ae`` has te be used to enable this fixture and the API key for your
     application has to be provided in ``--ae-key``.
     """
     try:
         # cygwin cannot have yet psutil support.
         import psutil
     except ImportError:
         return
 
     if not request.config.getoption('--appenlight'):
         return
     else:
         # Only request the pylonsapp fixture if appenlight tracking is
         # enabled. This will speed up a test run of unit tests by 2 to 3
         # seconds if appenlight is not enabled.
         pylonsapp = request.getfuncargvalue("pylonsapp")
     url = '{}/api/logs'.format(request.config.getoption('--appenlight-url'))
     client = AppenlightClient(
         url=url,
         api_key=request.config.getoption('--appenlight-api-key'),
         namespace=request.node.nodeid,
         request=str(testrun['uuid']),
         testrun=testrun)
 
     client.collect({
         'message': "Starting",
     })
 
     server_and_port = pylonsapp.config['vcs.server']
     server = create_vcsserver_proxy(server_and_port)
     with server:
         vcs_pid = server.get_pid()
         server.run_gc()
     vcs_process = psutil.Process(vcs_pid)
     mem = vcs_process.memory_info()
     client.tag_before('vcsserver.rss', mem.rss)
     client.tag_before('vcsserver.vms', mem.vms)
 
     test_process = psutil.Process()
     mem = test_process.memory_info()
     client.tag_before('test.rss', mem.rss)
     client.tag_before('test.vms', mem.vms)
 
     client.tag_before('time', time.time())
 
     @request.addfinalizer
     def send_stats():
         client.tag_after('time', time.time())
         with server:
             gc_stats = server.run_gc()
         for tag, value in gc_stats.items():
             client.tag_after(tag, value)
         mem = vcs_process.memory_info()
         client.tag_after('vcsserver.rss', mem.rss)
         client.tag_after('vcsserver.vms', mem.vms)
 
         mem = test_process.memory_info()
         client.tag_after('test.rss', mem.rss)
         client.tag_after('test.vms', mem.vms)
 
         client.collect({
             'message': "Finished",
         })
         client.send_stats()
 
     return client
 
 
 class AppenlightClient():
 
     url_template = '{url}?protocol_version=0.5'
 
     def __init__(
             self, url, api_key, add_server=True, add_timestamp=True,
             namespace=None, request=None, testrun=None):
         self.url = self.url_template.format(url=url)
         self.api_key = api_key
         self.add_server = add_server
         self.add_timestamp = add_timestamp
         self.namespace = namespace
         self.request = request
         self.server = socket.getfqdn(socket.gethostname())
         self.tags_before = {}
         self.tags_after = {}
         self.stats = []
         self.testrun = testrun or {}
 
     def tag_before(self, tag, value):
         self.tags_before[tag] = value
 
     def tag_after(self, tag, value):
         self.tags_after[tag] = value
 
     def collect(self, data):
         if self.add_server:
             data.setdefault('server', self.server)
         if self.add_timestamp:
             data.setdefault('date', datetime.datetime.utcnow().isoformat())
         if self.namespace:
             data.setdefault('namespace', self.namespace)
         if self.request:
             data.setdefault('request', self.request)
         self.stats.append(data)
 
     def send_stats(self):
         tags = [
             ('testrun', self.request),
             ('testrun.start', self.testrun['start']),
             ('testrun.timestamp', self.testrun['timestamp']),
             ('test', self.namespace),
         ]
         for key, value in self.tags_before.items():
             tags.append((key + '.before', value))
             try:
                 delta = self.tags_after[key] - value
                 tags.append((key + '.delta', delta))
             except Exception:
                 pass
         for key, value in self.tags_after.items():
             tags.append((key + '.after', value))
         self.collect({
             'message': "Collected tags",
             'tags': tags,
         })
 
         response = requests.post(
             self.url,
             headers={
                 'X-appenlight-api-key': self.api_key},
             json=self.stats,
         )
 
         if not response.status_code == 200:
             pprint.pprint(self.stats)
             print response.headers
             print response.text
             raise Exception('Sending to appenlight failed')
 
 
 @pytest.fixture
 def gist_util(request, pylonsapp):
     """
     Provides a wired instance of `GistUtility` with integrated cleanup.
     """
     utility = GistUtility()
     request.addfinalizer(utility.cleanup)
     return utility
 
 
 class GistUtility(object):
     def __init__(self):
         self.fixture = Fixture()
         self.gist_ids = []
 
     def create_gist(self, **kwargs):
         gist = self.fixture.create_gist(**kwargs)
         self.gist_ids.append(gist.gist_id)
         return gist
 
     def cleanup(self):
         for id_ in self.gist_ids:
             self.fixture.destroy_gists(str(id_))
 
 
 @pytest.fixture
 def enabled_backends(request):
     backends = request.config.option.backends
     return backends[:]
 
 
 @pytest.fixture
 def settings_util(request):
     """
     Provides a wired instance of `SettingsUtility` with integrated cleanup.
     """
     utility = SettingsUtility()
     request.addfinalizer(utility.cleanup)
     return utility
 
 
 class SettingsUtility(object):
     def __init__(self):
         self.rhodecode_ui_ids = []
         self.rhodecode_setting_ids = []
         self.repo_rhodecode_ui_ids = []
         self.repo_rhodecode_setting_ids = []
 
     def create_repo_rhodecode_ui(
             self, repo, section, value, key=None, active=True, cleanup=True):
         key = key or hashlib.sha1(
             '{}{}{}'.format(section, value, repo.repo_id)).hexdigest()
 
         setting = RepoRhodeCodeUi()
         setting.repository_id = repo.repo_id
         setting.ui_section = section
         setting.ui_value = value
         setting.ui_key = key
         setting.ui_active = active
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.repo_rhodecode_ui_ids.append(setting.ui_id)
         return setting
 
     def create_rhodecode_ui(
             self, section, value, key=None, active=True, cleanup=True):
         key = key or hashlib.sha1('{}{}'.format(section, value)).hexdigest()
 
         setting = RhodeCodeUi()
         setting.ui_section = section
         setting.ui_value = value
         setting.ui_key = key
         setting.ui_active = active
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.rhodecode_ui_ids.append(setting.ui_id)
         return setting
 
     def create_repo_rhodecode_setting(
             self, repo, name, value, type_, cleanup=True):
         setting = RepoRhodeCodeSetting(
             repo.repo_id, key=name, val=value, type=type_)
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.repo_rhodecode_setting_ids.append(setting.app_settings_id)
         return setting
 
     def create_rhodecode_setting(self, name, value, type_, cleanup=True):
         setting = RhodeCodeSetting(key=name, val=value, type=type_)
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.rhodecode_setting_ids.append(setting.app_settings_id)
 
         return setting
 
     def cleanup(self):
         for id_ in self.rhodecode_ui_ids:
             setting = RhodeCodeUi.get(id_)
             Session().delete(setting)
 
         for id_ in self.rhodecode_setting_ids:
             setting = RhodeCodeSetting.get(id_)
             Session().delete(setting)
 
         for id_ in self.repo_rhodecode_ui_ids:
             setting = RepoRhodeCodeUi.get(id_)
             Session().delete(setting)
 
         for id_ in self.repo_rhodecode_setting_ids:
             setting = RepoRhodeCodeSetting.get(id_)
             Session().delete(setting)
 
         Session().commit()
 
 
 @pytest.fixture
 def no_notifications(request):
     notification_patcher = mock.patch(
         'rhodecode.model.notification.NotificationModel.create')
     notification_patcher.start()
     request.addfinalizer(notification_patcher.stop)
 
 
 @pytest.fixture
 def silence_action_logger(request):
     notification_patcher = mock.patch(
         'rhodecode.lib.utils.action_logger')
     notification_patcher.start()
     request.addfinalizer(notification_patcher.stop)
 
 
 @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
 def rhodecode_fixtures():
     return Fixture()
 
 
 @pytest.fixture
 def request_stub():
     """
     Stub request object.
     """
     request = pyramid.testing.DummyRequest()
     request.scheme = 'https'
     return request
 
 
 @pytest.fixture
 def config_stub(request, request_stub):
     """
     Set up pyramid.testing and return the Configurator.
     """
     config = pyramid.testing.setUp(request=request_stub)
 
     @request.addfinalizer
     def cleanup():
         pyramid.testing.tearDown()
 
     return config
 
 
 @pytest.fixture
 def StubIntegrationType():
     class _StubIntegrationType(IntegrationTypeBase):
         """ Test integration type class """
 
         key = 'test'
         display_name = 'Test integration type'
         description = 'A test integration type for testing'
         icon = 'test_icon_html_image'
 
         def __init__(self, settings):
             super(_StubIntegrationType, self).__init__(settings)
             self.sent_events = [] # for testing
 
         def send_event(self, event):
             self.sent_events.append(event)
 
         def settings_schema(self):
             class SettingsSchema(colander.Schema):
                 test_string_field = colander.SchemaNode(
                     colander.String(),
                     missing=colander.required,
                     title='test string field',
                 )
                 test_int_field = colander.SchemaNode(
                     colander.Int(),
                     title='some integer setting',
                 )
             return SettingsSchema()
 
 
     integration_type_registry.register_integration_type(_StubIntegrationType)
     return _StubIntegrationType
 
 @pytest.fixture
 def stub_integration_settings():
     return {
         'test_string_field': 'some data',
         'test_int_field': 100,
     }
 
 
 @pytest.fixture
 def repo_integration_stub(request, repo_stub, StubIntegrationType,
         stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
         name='test repo integration',
         repo=repo_stub, repo_group=None, child_repos_only=None)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture
 def repogroup_integration_stub(request, test_repo_group, StubIntegrationType,
     stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
         name='test repogroup integration',
         repo=None, repo_group=test_repo_group, child_repos_only=True)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture
 def repogroup_recursive_integration_stub(request, test_repo_group,
     StubIntegrationType, stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
         name='test recursive repogroup integration',
         repo=None, repo_group=test_repo_group, child_repos_only=False)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture
 def global_integration_stub(request, StubIntegrationType,
     stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
         name='test global integration',
         repo=None, repo_group=None, child_repos_only=None)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture
 def root_repos_integration_stub(request, StubIntegrationType,
     stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
         name='test global integration',
         repo=None, repo_group=None, child_repos_only=True)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration

rhodecode/tests/pylons_plugin.py

@@ -1,455 +1,455 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import json
 import logging.config
 import os
 import platform
 import socket
-import subprocess
+import subprocess32
 import time
 from urllib2 import urlopen, URLError
 
 import configobj
 import pylons
 import pytest
 import webob
 from beaker.session import SessionObject
 from paste.deploy import loadapp
 from pylons.i18n.translation import _get_translator
 from pylons.util import ContextObj
 from Pyro4.errors import CommunicationError
 from routes.util import URLGenerator
 
 from rhodecode.lib import vcs
 from rhodecode.tests.fixture import TestINI
 import rhodecode
 
 
 def _parse_json(value):
     return json.loads(value) if value else None
 
 
 def pytest_addoption(parser):
     group = parser.getgroup('pylons')
     group.addoption(
         '--with-pylons', dest='pylons_config',
         help="Set up a Pylons environment with the specified config file.")
     group.addoption(
         '--pylons-config-override', action='store', type=_parse_json,
         default=None, dest='pylons_config_override', help=(
             "Overrides the .ini file settings. Should be specified in JSON"
             " format, e.g. '{\"section\": {\"parameter\": \"value\", ...}}'"
         )
     )
     parser.addini(
         'pylons_config',
         "Set up a Pylons environment with the specified config file.")
 
     vcsgroup = parser.getgroup('vcs')
     vcsgroup.addoption(
         '--without-vcsserver', dest='with_vcsserver', action='store_false',
         help="Do not start the VCSServer in a background process.")
     vcsgroup.addoption(
         '--with-vcsserver', dest='vcsserver_config_pyro4',
         help="Start the VCSServer with the specified config file.")
     vcsgroup.addoption(
         '--with-vcsserver-http', dest='vcsserver_config_http',
         help="Start the HTTP VCSServer with the specified config file.")
     vcsgroup.addoption(
         '--vcsserver-protocol', dest='vcsserver_protocol',
         help="Start the VCSServer with HTTP / Pyro4 protocol support.")
     vcsgroup.addoption(
         '--vcsserver-config-override', action='store', type=_parse_json,
         default=None, dest='vcsserver_config_override', help=(
             "Overrides the .ini file settings for the VCSServer. "
             "Should be specified in JSON "
             "format, e.g. '{\"section\": {\"parameter\": \"value\", ...}}'"
         )
     )
     vcsgroup.addoption(
         '--vcsserver-port', action='store', type=int,
         default=None, help=(
             "Allows to set the port of the vcsserver. Useful when testing "
             "against an already running server and random ports cause "
             "trouble."))
     parser.addini(
         'vcsserver_config_pyro4',
         "Start the VCSServer with the specified config file.")
     parser.addini(
         'vcsserver_config_http',
         "Start the HTTP VCSServer with the specified config file.")
     parser.addini(
         'vcsserver_protocol',
         "Start the VCSServer with HTTP / Pyro4 protocol support.")
 
 
 @pytest.fixture(scope='session')
 def vcsserver(request, vcsserver_port, vcsserver_factory):
     """
     Session scope VCSServer.
 
     Tests wich need the VCSServer have to rely on this fixture in order
     to ensure it will be running.
 
     For specific needs, the fixture vcsserver_factory can be used. It allows to
     adjust the configuration file for the test run.
 
     Command line args:
 
     --without-vcsserver: Allows to switch this fixture off. You have to
     manually start the server.
 
     --vcsserver-port: Will expect the VCSServer to listen on this port.
     """
 
     if not request.config.getoption('with_vcsserver'):
         return None
 
     use_http = _use_vcs_http_server(request.config)
     return vcsserver_factory(
         request, use_http=use_http, vcsserver_port=vcsserver_port)
 
 
 @pytest.fixture(scope='session')
 def vcsserver_factory(tmpdir_factory):
     """
     Use this if you need a running vcsserver with a special configuration.
     """
 
     def factory(request, use_http=True, overrides=(), vcsserver_port=None):
 
         if vcsserver_port is None:
             vcsserver_port = get_available_port()
 
         overrides = list(overrides)
         if use_http:
             overrides.append({'server:main': {'port': vcsserver_port}})
         else:
             overrides.append({'DEFAULT': {'port': vcsserver_port}})
 
         if is_cygwin():
             platform_override = {'DEFAULT': {
                 'beaker.cache.repo_object.type': 'nocache'}}
             overrides.append(platform_override)
 
         option_name = (
             'vcsserver_config_http' if use_http else 'vcsserver_config_pyro4')
         override_option_name = 'vcsserver_config_override'
         config_file = get_config(
             request.config, option_name=option_name,
             override_option_name=override_option_name, overrides=overrides,
             basetemp=tmpdir_factory.getbasetemp().strpath,
             prefix='test_vcs_')
 
         print "Using the VCSServer configuration", config_file
         ServerClass = HttpVCSServer if use_http else Pyro4VCSServer
         server = ServerClass(config_file)
         server.start()
 
         @request.addfinalizer
         def cleanup():
             server.shutdown()
 
         server.wait_until_ready()
         return server
 
     return factory
 
 
 def is_cygwin():
     return 'cygwin' in platform.system().lower()
 
 
 def _use_vcs_http_server(config):
     protocol_option = 'vcsserver_protocol'
     protocol = (
         config.getoption(protocol_option) or
         config.getini(protocol_option) or
         'http')
     return protocol == 'http'
 
 
 class VCSServer(object):
     """
     Represents a running VCSServer instance.
     """
 
     _args = []
 
     def start(self):
         print("Starting the VCSServer: {}".format(self._args))
-        self.process = subprocess.Popen(self._args)
+        self.process = subprocess32.Popen(self._args)
 
     def wait_until_ready(self, timeout=30):
         raise NotImplementedError()
 
     def shutdown(self):
         self.process.kill()
 
 
 class Pyro4VCSServer(VCSServer):
     def __init__(self, config_file):
         """
         :param config_file: The config file to start the server with
         """
 
         config_data = configobj.ConfigObj(config_file)
         self._config = config_data['DEFAULT']
 
         args = ['vcsserver', '--config', config_file]
         self._args = args
 
     def wait_until_ready(self, timeout=30):
         remote_server = vcs.create_vcsserver_proxy(
             self.server_and_port, 'pyro4')
         start = time.time()
         with remote_server:
             while time.time() - start < timeout:
                 try:
                     remote_server.ping()
                     break
                 except CommunicationError:
                     time.sleep(0.2)
             else:
                 pytest.exit(
                     "Starting the VCSServer failed or took more than {} "
                     "seconds.".format(timeout))
 
     @property
     def server_and_port(self):
         return '{host}:{port}'.format(**self._config)
 
 
 class HttpVCSServer(VCSServer):
     """
     Represents a running VCSServer instance.
     """
     def __init__(self, config_file):
         config_data = configobj.ConfigObj(config_file)
         self._config = config_data['server:main']
 
         args = ['pserve', config_file]
         self._args = args
 
     @property
     def http_url(self):
         template = 'http://{host}:{port}/'
         return template.format(**self._config)
 
     def start(self):
-        self.process = subprocess.Popen(self._args)
+        self.process = subprocess32.Popen(self._args)
 
     def wait_until_ready(self, timeout=30):
         host = self._config['host']
         port = self._config['port']
         status_url = 'http://{host}:{port}/status'.format(host=host, port=port)
         start = time.time()
 
         while time.time() - start < timeout:
             try:
                 urlopen(status_url)
                 break
             except URLError:
                 time.sleep(0.2)
         else:
             pytest.exit(
                 "Starting the VCSServer failed or took more than {} "
                 "seconds.".format(timeout))
 
     def shutdown(self):
         self.process.kill()
 
 
 @pytest.fixture(scope='session')
 def pylons_config(request, tmpdir_factory, rcserver_port, vcsserver_port):
     option_name = 'pylons_config'
 
     overrides = [
         {'server:main': {'port': rcserver_port}},
         {'app:main': {
             'vcs.server': 'localhost:%s' % vcsserver_port,
             # johbo: We will always start the VCSServer on our own based on the
             # fixtures of the test cases. For the test run it must always be
             # off in the INI file.
             'vcs.start_server': 'false',
         }},
     ]
     if _use_vcs_http_server(request.config):
         overrides.append({
             'app:main': {
                 'vcs.server.protocol': 'http',
                 'vcs.scm_app_implementation': 'http',
                 'vcs.hooks.protocol': 'http',
             }
         })
     else:
         overrides.append({
             'app:main': {
                 'vcs.server.protocol': 'pyro4',
                 'vcs.scm_app_implementation': 'pyro4',
                 'vcs.hooks.protocol': 'pyro4',
             }
         })
 
     filename = get_config(
         request.config, option_name=option_name,
         override_option_name='{}_override'.format(option_name),
         overrides=overrides,
         basetemp=tmpdir_factory.getbasetemp().strpath,
         prefix='test_rce_')
     return filename
 
 
 @pytest.fixture(scope='session')
 def rcserver_port(request):
     port = get_available_port()
     print 'Using rcserver port %s' % (port, )
     return port
 
 
 @pytest.fixture(scope='session')
 def vcsserver_port(request):
     port = request.config.getoption('--vcsserver-port')
     if port is None:
         port = get_available_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
 
 
 @pytest.fixture(scope='session')
 def available_port_factory():
     """
     Returns a callable which returns free port numbers.
     """
     return get_available_port
 
 
 @pytest.fixture
 def available_port(available_port_factory):
     """
     Gives you one free port for the current test.
 
     Uses "available_port_factory" to retrieve the port.
     """
     return available_port_factory()
 
 
 @pytest.fixture(scope='session')
 def pylonsapp(pylons_config, vcsserver, http_environ_session):
     print "Using the RhodeCode configuration", pylons_config
     logging.config.fileConfig(
         pylons_config, disable_existing_loggers=False)
     app = _setup_pylons_environment(pylons_config, http_environ_session)
     return app
 
 
 @pytest.fixture(scope='session')
 def testini_factory(tmpdir_factory, pylons_config):
     """
     Factory to create an INI file based on TestINI.
 
     It will make sure to place the INI file in the correct directory.
     """
     basetemp = tmpdir_factory.getbasetemp().strpath
     return TestIniFactory(basetemp, pylons_config)
 
 
 class TestIniFactory(object):
 
     def __init__(self, basetemp, template_ini):
         self._basetemp = basetemp
         self._template_ini = template_ini
 
     def __call__(self, ini_params, new_file_prefix='test'):
         ini_file = TestINI(
             self._template_ini, ini_params=ini_params,
             new_file_prefix=new_file_prefix, dir=self._basetemp)
         result = ini_file.create()
         return result
 
 
 def get_config(
         config, option_name, override_option_name, overrides=None,
         basetemp=None, prefix='test'):
     """
     Find a configuration file and apply overrides for the given `prefix`.
     """
     config_file = (
         config.getoption(option_name) or config.getini(option_name))
     if not config_file:
         pytest.exit(
             "Configuration error, could not extract {}.".format(option_name))
 
     overrides = overrides or []
     config_override = config.getoption(override_option_name)
     if config_override:
         overrides.append(config_override)
     temp_ini_file = TestINI(
         config_file, ini_params=overrides, new_file_prefix=prefix,
         dir=basetemp)
 
     return temp_ini_file.create()
 
 
 def _setup_pylons_environment(pylons_config, http_environ):
     current_path = os.getcwd()
     pylonsapp = loadapp(
         'config:' + pylons_config, relative_to=current_path)
 
     # Using rhodecode.CONFIG which is assigned during "load_environment".
     # The indirect approach is used, because "pylonsapp" may actually be
     # the Pyramid application.
     pylonsapp_config = rhodecode.CONFIG
     _init_stack(pylonsapp_config, environ=http_environ)
 
     # For compatibility add the attribute "config" which would be
     # present on the Pylons application.
     pylonsapp.config = pylonsapp_config
     return pylonsapp
 
 
 def _init_stack(config=None, environ=None):
     if not config:
         config = pylons.test.pylonsapp.config
     if not environ:
         environ = {}
     pylons.url._push_object(URLGenerator(config['routes.map'], environ or {}))
     pylons.app_globals._push_object(config['pylons.app_globals'])
     pylons.config._push_object(config)
     pylons.tmpl_context._push_object(ContextObj())
     # Initialize a translator for tests that utilize i18n
     translator = _get_translator(pylons.config.get('lang'))
     pylons.translator._push_object(translator)
     pylons.session._push_object(SessionObject(environ or {}))
     pylons.request._push_object(webob.Request.blank('', environ=environ))

rhodecode/tests/scripts/test_concurency.py

@@ -1,217 +1,215 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Test suite for making push/pull operations
 """
 
 import os
 import sys
 import shutil
 import logging
 from os.path import join as jn
 from os.path import dirname as dn
 
 from tempfile import _RandomNameSequence
-from subprocess import Popen, PIPE
-
+from subprocess32 import Popen, PIPE
 from paste.deploy import appconfig
-from pylons import config
 
 from rhodecode.lib.utils import add_cache
 from rhodecode.lib.utils2 import engine_from_config
 from rhodecode.lib.auth import get_crypt_password
 from rhodecode.model import init_model
 from rhodecode.model import meta
 from rhodecode.model.db import User, Repository
 
-from rhodecode.tests import TESTS_TMP_PATH, NEW_HG_REPO, HG_REPO
+from rhodecode.tests import TESTS_TMP_PATH, HG_REPO
 from rhodecode.config.environment import load_environment
 
 rel_path = dn(dn(dn(dn(os.path.abspath(__file__)))))
 conf = appconfig('config:rc.ini', relative_to=rel_path)
 load_environment(conf.global_conf, conf.local_conf)
 
 add_cache(conf)
 
 USER = 'test_admin'
 PASS = 'test12'
 HOST = 'rc.local'
 METHOD = 'pull'
 DEBUG = True
 log = logging.getLogger(__name__)
 
 
 class Command(object):
 
     def __init__(self, cwd):
         self.cwd = cwd
 
     def execute(self, cmd, *args):
         """Runs command on the system with given ``args``.
         """
 
         command = cmd + ' ' + ' '.join(args)
         log.debug('Executing %s' % command)
         if DEBUG:
             print command
         p = Popen(command, shell=True, stdout=PIPE, stderr=PIPE, cwd=self.cwd)
         stdout, stderr = p.communicate()
         if DEBUG:
             print stdout, stderr
         return stdout, stderr
 
 
 def get_session():
     engine = engine_from_config(conf, 'sqlalchemy.db1.')
     init_model(engine)
     sa = meta.Session
     return sa
 
 
 def create_test_user(force=True):
     print 'creating test user'
     sa = get_session()
 
     user = sa.query(User).filter(User.username == USER).scalar()
 
     if force and user is not None:
         print 'removing current user'
         for repo in sa.query(Repository).filter(Repository.user == user).all():
             sa.delete(repo)
         sa.delete(user)
         sa.commit()
 
     if user is None or force:
         print 'creating new one'
         new_usr = User()
         new_usr.username = USER
         new_usr.password = get_crypt_password(PASS)
         new_usr.email = '[e-mail]'
         new_usr.name = 'test'
         new_usr.lastname = 'lasttestname'
         new_usr.active = True
         new_usr.admin = True
         sa.add(new_usr)
         sa.commit()
 
     print 'done'
 
 
 def create_test_repo(force=True):
     print 'creating test repo'
     from rhodecode.model.repo import RepoModel
     sa = get_session()
 
     user = sa.query(User).filter(User.username == USER).scalar()
     if user is None:
         raise Exception('user not found')
 
     repo = sa.query(Repository).filter(Repository.repo_name == HG_REPO).scalar()
 
     if repo is None:
         print 'repo not found creating'
 
         form_data = {'repo_name': HG_REPO,
                      'repo_type': 'hg',
                      'private':False,
                      'clone_uri': '' }
         rm = RepoModel(sa)
         rm.base_path = '/home/hg'
         rm.create(form_data, user)
 
     print 'done'
 
 
 def set_anonymous_access(enable=True):
     sa = get_session()
     user = sa.query(User).filter(User.username == 'default').one()
     user.active = enable
     sa.add(user)
     sa.commit()
 
 
 def get_anonymous_access():
     sa = get_session()
     return sa.query(User).filter(User.username == 'default').one().active
 
 
 #==============================================================================
 # TESTS
 #==============================================================================
 def test_clone_with_credentials(repo=HG_REPO, method=METHOD,
                                 seq=None, backend='hg', check_output=True):
     cwd = path = jn(TESTS_TMP_PATH, repo)
 
     if seq is None:
         seq = _RandomNameSequence().next()
 
     try:
         shutil.rmtree(path, ignore_errors=True)
         os.makedirs(path)
     except OSError:
         raise
 
     clone_url = 'http://%(user)s:%(pass)s@%(host)s/%(cloned_repo)s' % \
                   {'user': USER,
                    'pass': PASS,
                    'host': HOST,
                    'cloned_repo': repo, }
 
     dest = path + seq
     if method == 'pull':
         stdout, stderr = Command(cwd).execute(backend, method, '--cwd', dest, clone_url)
     else:
         stdout, stderr = Command(cwd).execute(backend, method, clone_url, dest)
         if check_output:
             if backend == 'hg':
                 assert """adding file changes""" in stdout, 'no messages about cloning'
                 assert """abort""" not in stderr, 'got error from clone'
             elif backend == 'git':
                 assert """Cloning into""" in stdout, 'no messages about cloning'
 
 if __name__ == '__main__':
     try:
         create_test_user(force=False)
         seq = None
         import time
 
         try:
             METHOD = sys.argv[3]
         except Exception:
             pass
 
         try:
             backend = sys.argv[4]
         except Exception:
             backend = 'hg'
 
         if METHOD == 'pull':
             seq = _RandomNameSequence().next()
             test_clone_with_credentials(repo=sys.argv[1], method='clone',
                                         seq=seq, backend=backend)
         s = time.time()
         for i in range(1, int(sys.argv[2]) + 1):
             print 'take', i
             test_clone_with_credentials(repo=sys.argv[1], method=METHOD,
                                         seq=seq, backend=backend)
         print 'time taken %.3f' % (time.time() - s)
     except Exception as e:
         sys.exit('stop on %s' % e)

rhodecode/tests/utils.py

@@ -1,293 +1,293 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import threading
 import time
 import logging
 import os.path
-import subprocess
+import subprocess32
 import urllib2
 from urlparse import urlparse, parse_qsl
 from urllib import unquote_plus
 
 import pytest
 import rc_testdata
 from lxml.html import fromstring, tostring
 from lxml.cssselect import CSSSelector
 
 from rhodecode.model.db import User
 from rhodecode.model.meta import Session
 from rhodecode.model.scm import ScmModel
 from rhodecode.lib.vcs.backends.svn.repository import SubversionRepository
 
 
 log = logging.getLogger(__name__)
 
 
 def set_anonymous_access(enabled):
     """(Dis)allows anonymous access depending on parameter `enabled`"""
     user = User.get_default_user()
     user.active = enabled
     Session().add(user)
     Session().commit()
     log.info('anonymous access is now: %s', enabled)
     assert enabled == User.get_default_user().active, (
         'Cannot set anonymous access')
 
 
 def check_xfail_backends(node, backend_alias):
     # Using "xfail_backends" here intentionally, since this marks work
     # which is "to be done" soon.
     skip_marker = node.get_marker('xfail_backends')
     if skip_marker and backend_alias in skip_marker.args:
         msg = "Support for backend %s to be developed." % (backend_alias, )
         msg = skip_marker.kwargs.get('reason', msg)
         pytest.xfail(msg)
 
 
 def check_skip_backends(node, backend_alias):
     # Using "skip_backends" here intentionally, since this marks work which is
     # not supported.
     skip_marker = node.get_marker('skip_backends')
     if skip_marker and backend_alias in skip_marker.args:
         msg = "Feature not supported for backend %s." % (backend_alias, )
         msg = skip_marker.kwargs.get('reason', msg)
         pytest.skip(msg)
 
 
 def extract_git_repo_from_dump(dump_name, repo_name):
     """Create git repo `repo_name` from dump `dump_name`."""
     repos_path = ScmModel().repos_path
     target_path = os.path.join(repos_path, repo_name)
     rc_testdata.extract_git_dump(dump_name, target_path)
     return target_path
 
 
 def extract_hg_repo_from_dump(dump_name, repo_name):
     """Create hg repo `repo_name` from dump `dump_name`."""
     repos_path = ScmModel().repos_path
     target_path = os.path.join(repos_path, repo_name)
     rc_testdata.extract_hg_dump(dump_name, target_path)
     return target_path
 
 
 def extract_svn_repo_from_dump(dump_name, repo_name):
     """Create a svn repo `repo_name` from dump `dump_name`."""
     repos_path = ScmModel().repos_path
     target_path = os.path.join(repos_path, repo_name)
     SubversionRepository(target_path, create=True)
     _load_svn_dump_into_repo(dump_name, target_path)
     return target_path
 
 
 def assert_message_in_log(log_records, message, levelno, module):
     messages = [
         r.message for r in log_records
         if r.module == module and r.levelno == levelno
     ]
     assert message in messages
 
 
 def _load_svn_dump_into_repo(dump_name, repo_path):
     """
     Utility to populate a svn repository with a named dump
 
     Currently the dumps are in rc_testdata. They might later on be
     integrated with the main repository once they stabilize more.
     """
     dump = rc_testdata.load_svn_dump(dump_name)
-    load_dump = subprocess.Popen(
+    load_dump = subprocess32.Popen(
         ['svnadmin', 'load', repo_path],
-        stdin=subprocess.PIPE, stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE)
+        stdin=subprocess32.PIPE, stdout=subprocess32.PIPE,
+        stderr=subprocess32.PIPE)
     out, err = load_dump.communicate(dump)
     if load_dump.returncode != 0:
         log.error("Output of load_dump command: %s", out)
         log.error("Error output of load_dump command: %s", err)
         raise Exception(
             'Failed to load dump "%s" into repository at path "%s".'
             % (dump_name, repo_path))
 
 
 class AssertResponse(object):
     """
     Utility that helps to assert things about a given HTML response.
     """
 
     def __init__(self, response):
         self.response = response
 
     def one_element_exists(self, css_selector):
         self.get_element(css_selector)
 
     def no_element_exists(self, css_selector):
         assert not self._get_elements(css_selector)
 
     def element_equals_to(self, css_selector, expected_content):
         element = self.get_element(css_selector)
         element_text = self._element_to_string(element)
         assert expected_content in element_text
 
     def element_contains(self, css_selector, expected_content):
         element = self.get_element(css_selector)
         assert expected_content in element.text_content()
 
     def contains_one_link(self, link_text, href):
         doc = fromstring(self.response.body)
         sel = CSSSelector('a[href]')
         elements = [
             e for e in sel(doc) if e.text_content().strip() == link_text]
         assert len(elements) == 1, "Did not find link or found multiple links"
         self._ensure_url_equal(elements[0].attrib.get('href'), href)
 
     def contains_one_anchor(self, anchor_id):
         doc = fromstring(self.response.body)
         sel = CSSSelector('#' + anchor_id)
         elements = sel(doc)
         assert len(elements) == 1
 
     def _ensure_url_equal(self, found, expected):
         assert _Url(found) == _Url(expected)
 
     def get_element(self, css_selector):
         elements = self._get_elements(css_selector)
         assert len(elements) == 1
         return elements[0]
 
     def get_elements(self, css_selector):
         return self._get_elements(css_selector)
 
     def _get_elements(self, css_selector):
         doc = fromstring(self.response.body)
         sel = CSSSelector(css_selector)
         elements = sel(doc)
         return elements
 
     def _element_to_string(self, element):
         return tostring(element)
 
 
 class _Url(object):
     """
     A url object that can be compared with other url orbjects
     without regard to the vagaries of encoding, escaping, and ordering
     of parameters in query strings.
 
     Inspired by
     http://stackoverflow.com/questions/5371992/comparing-two-urls-in-python
     """
 
     def __init__(self, url):
         parts = urlparse(url)
         _query = frozenset(parse_qsl(parts.query))
         _path = unquote_plus(parts.path)
         parts = parts._replace(query=_query, path=_path)
         self.parts = parts
 
     def __eq__(self, other):
         return self.parts == other.parts
 
     def __hash__(self):
         return hash(self.parts)
 
 
 def run_test_concurrently(times, raise_catched_exc=True):
     """
     Add this decorator to small pieces of code that you want to test
     concurrently
 
     ex:
 
     @test_concurrently(25)
     def my_test_function():
         ...
     """
     def test_concurrently_decorator(test_func):
         def wrapper(*args, **kwargs):
             exceptions = []
 
             def call_test_func():
                 try:
                     test_func(*args, **kwargs)
                 except Exception, e:
                     exceptions.append(e)
                     if raise_catched_exc:
                         raise
             threads = []
             for i in range(times):
                 threads.append(threading.Thread(target=call_test_func))
             for t in threads:
                 t.start()
             for t in threads:
                 t.join()
             if exceptions:
                 raise Exception(
                     'test_concurrently intercepted %s exceptions: %s' % (
                         len(exceptions), exceptions))
         return wrapper
     return test_concurrently_decorator
 
 
 def wait_for_url(url, timeout=10):
     """
     Wait until URL becomes reachable.
 
     It polls the URL until the timeout is reached or it became reachable.
     If will call to `py.test.fail` in case the URL is not reachable.
     """
     timeout = time.time() + timeout
     last = 0
     wait = 0.1
 
     while (timeout > last):
         last = time.time()
         if is_url_reachable(url):
             break
         elif ((last + wait) > time.time()):
             # Go to sleep because not enough time has passed since last check.
             time.sleep(wait)
     else:
         pytest.fail("Timeout while waiting for URL {}".format(url))
 
 
 def is_url_reachable(url):
     try:
         urllib2.urlopen(url)
     except urllib2.URLError:
         return False
     return True
 
 
 def get_session_from_response(response):
     """
     This returns the session from a response object. Pylons has some magic
     to make the session available as `response.session`. But pyramid
     doesn't expose it.
     """
     # TODO: Try to look up the session key also.
     return response.request.environ['beaker.session']
 
 
 def repo_on_filesystem(repo_name):
     from rhodecode.lib import vcs
     from rhodecode.tests import TESTS_TMP_PATH
     repo = vcs.get_vcs_instance(
         os.path.join(TESTS_TMP_PATH, repo_name), create=False)
     return repo is not None

rhodecode/tests/vcs/test_utils.py

@@ -1,195 +1,195 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import datetime
 import os
-import subprocess
+import subprocess32
 
 import pytest
 
 from rhodecode.lib.vcs.exceptions import VCSError
 from rhodecode.lib.vcs.utils import author_email, author_name
 from rhodecode.lib.vcs.utils.helpers import get_scm
 from rhodecode.lib.vcs.utils.helpers import get_scms_for_path
 from rhodecode.lib.vcs.utils.helpers import parse_datetime
 from rhodecode.lib.vcs.utils.paths import get_dirs_for_path
 
 
 @pytest.mark.usefixtures("pylonsapp")
 class TestPaths:
 
     def _test_get_dirs_for_path(self, path, expected):
         """
         Tests if get_dirs_for_path returns same as expected.
         """
         expected = sorted(expected)
         result = sorted(get_dirs_for_path(path))
         assert result == expected, (
             "%s != %s which was expected result for path %s"
             % (result, expected, path))
 
     def test_get_dirs_for_path(self):
         path = 'foo/bar/baz/file'
         paths_and_results = (
             ('foo/bar/baz/file', ['foo', 'foo/bar', 'foo/bar/baz']),
             ('foo/bar/', ['foo', 'foo/bar']),
             ('foo/bar', ['foo']),
         )
         for path, expected in paths_and_results:
             self._test_get_dirs_for_path(path, expected)
 
     def test_get_scms_for_path(self, tmpdir):
         new = tmpdir.strpath
         assert get_scms_for_path(new) == []
 
         os.mkdir(os.path.join(new, '.tux'))
         assert get_scms_for_path(new) == []
 
         os.mkdir(os.path.join(new, '.git'))
         assert set(get_scms_for_path(new)) == set(['git'])
 
         os.mkdir(os.path.join(new, '.hg'))
         assert set(get_scms_for_path(new)) == set(['git', 'hg'])
 
 
 class TestGetScm:
 
     def test_existing_repository(self, vcs_repository_support):
         alias, repo = vcs_repository_support
         assert (alias, repo.path) == get_scm(repo.path)
 
     def test_raises_if_path_is_empty(self, tmpdir):
         with pytest.raises(VCSError):
             get_scm(str(tmpdir))
 
     def test_get_scm_error_path(self):
         with pytest.raises(VCSError):
             get_scm('err')
 
     def test_get_two_scms_for_path(self, tmpdir):
         multialias_repo_path = str(tmpdir)
 
-        subprocess.check_call(['hg', 'init', multialias_repo_path])
-        subprocess.check_call(['git', 'init', multialias_repo_path])
+        subprocess32.check_call(['hg', 'init', multialias_repo_path])
+        subprocess32.check_call(['git', 'init', multialias_repo_path])
 
         with pytest.raises(VCSError):
             get_scm(multialias_repo_path)
 
     def test_ignores_svn_working_copy(self, tmpdir):
         tmpdir.mkdir('.svn')
         with pytest.raises(VCSError):
             get_scm(tmpdir.strpath)
 
 
 class TestParseDatetime:
 
     def test_datetime_text(self):
         assert parse_datetime('2010-04-07 21:29:41') == \
             datetime.datetime(2010, 4, 7, 21, 29, 41)
 
     def test_no_seconds(self):
         assert parse_datetime('2010-04-07 21:29') == \
             datetime.datetime(2010, 4, 7, 21, 29)
 
     def test_date_only(self):
         assert parse_datetime('2010-04-07') == \
             datetime.datetime(2010, 4, 7)
 
     def test_another_format(self):
         assert parse_datetime('04/07/10 21:29:41') == \
             datetime.datetime(2010, 4, 7, 21, 29, 41)
 
     def test_now(self):
         assert parse_datetime('now') - datetime.datetime.now() < \
             datetime.timedelta(seconds=1)
 
     def test_today(self):
         today = datetime.date.today()
         assert parse_datetime('today') == \
             datetime.datetime(*today.timetuple()[:3])
 
     def test_yesterday(self):
         yesterday = datetime.date.today() - datetime.timedelta(days=1)
         assert parse_datetime('yesterday') == \
             datetime.datetime(*yesterday.timetuple()[:3])
 
     def test_tomorrow(self):
         tomorrow = datetime.date.today() + datetime.timedelta(days=1)
         args = tomorrow.timetuple()[:3] + (23, 59, 59)
         assert parse_datetime('tomorrow') == datetime.datetime(*args)
 
     def test_days(self):
         timestamp = datetime.datetime.today() - datetime.timedelta(days=3)
         args = timestamp.timetuple()[:3] + (0, 0, 0, 0)
         expected = datetime.datetime(*args)
         assert parse_datetime('3d') == expected
         assert parse_datetime('3 d') == expected
         assert parse_datetime('3 day') == expected
         assert parse_datetime('3 days') == expected
 
     def test_weeks(self):
         timestamp = datetime.datetime.today() - datetime.timedelta(days=3 * 7)
         args = timestamp.timetuple()[:3] + (0, 0, 0, 0)
         expected = datetime.datetime(*args)
         assert parse_datetime('3w') == expected
         assert parse_datetime('3 w') == expected
         assert parse_datetime('3 week') == expected
         assert parse_datetime('3 weeks') == expected
 
     def test_mixed(self):
         timestamp = (
             datetime.datetime.today() - datetime.timedelta(days=2 * 7 + 3))
         args = timestamp.timetuple()[:3] + (0, 0, 0, 0)
         expected = datetime.datetime(*args)
         assert parse_datetime('2w3d') == expected
         assert parse_datetime('2w 3d') == expected
         assert parse_datetime('2w 3 days') == expected
         assert parse_datetime('2 weeks 3 days') == expected
 
 
 @pytest.mark.parametrize("test_str, name, email", [
     ('Marcin Kuzminski <[e-mail]>',
      'Marcin Kuzminski', '[e-mail]'),
     ('Marcin Kuzminski Spaces < [e-mail] >',
      'Marcin Kuzminski Spaces', '[e-mail]'),
     ('Marcin Kuzminski <[e-mail]>',
      'Marcin Kuzminski', '[e-mail]'),
     ('mrf RFC_SPEC <[e-mail]>',
      'mrf RFC_SPEC', '[e-mail]'),
     ('username <[e-mail]>',
      'username', '[e-mail]'),
     ('username <[e-mail]',
      'username', '[e-mail]'),
     ('broken [e-mail]',
      'broken', '[e-mail]'),
     ('<[e-mail]>',
      '', '[e-mail]'),
     ('justname',
      'justname', ''),
     ('Mr Double Name [e-mail] ',
      'Mr Double Name', '[e-mail]'),
 ])
 class TestAuthorExtractors:
 
     def test_author_email(self, test_str, name, email):
         assert email == author_email(test_str)
 
     def test_author_name(self, test_str, name, email):
         assert name == author_name(test_str)

rhodecode/tests/vcs/utils.py

@@ -1,118 +1,118 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # 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 Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Utilities for tests only. These are not or should not be used normally -
 functions here are crafted as we don't want to use ``vcs`` to verify tests.
 """
 
 import os
 import re
 import sys
 
-from subprocess import Popen
+from subprocess32 import Popen
 
 
 class VCSTestError(Exception):
     pass
 
 
 def run_command(cmd, args):
     """
     Runs command on the system with given ``args``.
     """
     command = ' '.join((cmd, args))
     p = Popen(command, shell=True)
     status = os.waitpid(p.pid, 0)[1]
     return status
 
 
 def eprint(msg):
     """
     Prints given ``msg`` into sys.stderr as nose test runner hides all output
     from sys.stdout by default and if we want to pipe stream somewhere we don't
     need those verbose messages anyway.
     Appends line break.
     """
     sys.stderr.write(msg)
     sys.stderr.write('\n')
 
 
 # TODO: Revisit once we have CI running, if this is not helping us, remove it
 class SCMFetcher(object):
 
     def __init__(self, alias, test_repo_path):
         """
         :param clone_cmd: command which would clone remote repository; pass
           only first bits - remote path and destination would be appended
           using ``remote_repo`` and ``test_repo_path``
         """
         self.alias = alias
         self.test_repo_path = test_repo_path
 
     def setup(self):
         if not os.path.isdir(self.test_repo_path):
             self.fetch_repo()
 
     def fetch_repo(self):
         """
         Tries to fetch repository from remote path.
         """
         remote = self.remote_repo
         eprint(
             "Fetching repository %s into %s" % (remote, self.test_repo_path))
         run_command(self.clone_cmd,  '%s %s' % (remote, self.test_repo_path))
 
 
 def get_normalized_path(path):
     """
     If given path exists, new path would be generated and returned. Otherwise
     same whats given is returned. Assumes that there would be no more than
     10000 same named files.
     """
     if os.path.exists(path):
         dir, basename = os.path.split(path)
         splitted_name = basename.split('.')
         if len(splitted_name) > 1:
             ext = splitted_name[-1]
         else:
             ext = None
         name = '.'.join(splitted_name[:-1])
         matcher = re.compile(r'^.*-(\d{5})$')
         start = 0
         m = matcher.match(name)
         if not m:
             # Haven't append number yet so return first
             newname = '%s-00000' % name
             newpath = os.path.join(dir, newname)
             if ext:
                 newpath = '.'.join((newpath, ext))
             return get_normalized_path(newpath)
         else:
             start = int(m.group(1)[-5:]) + 1
             for x in xrange(start, 10000):
                 newname = name[:-5] + str(x).rjust(5, '0')
                 newpath = os.path.join(dir, newname)
                 if ext:
                     newpath = '.'.join((newpath, ext))
                 if not os.path.exists(newpath):
                     return newpath
         raise VCSTestError("Couldn't compute new path for %s" % path)
     return path