vcs: Do not pass the backend key into the scm app instances.

We used the key as a value for a response header. Since this header is removed there
is no need to pass the backend key araound.

rhodecode/lib/middleware/simplegit.py

@@ -1,85 +1,85 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/
 
 """
 SimpleGit middleware for handling git protocol request (push/clone etc.)
 It's implemented with basic auth function
 """
 import re
 import logging
 import urlparse
 
 import rhodecode
 from rhodecode.lib import utils2
 from rhodecode.lib.middleware import simplevcs
 
 log = logging.getLogger(__name__)
 
 
 GIT_PROTO_PAT = re.compile(
     r'^/(.+)/(info/refs|git-upload-pack|git-receive-pack)')
 
 
 class SimpleGit(simplevcs.SimpleVCS):
 
     SCM = 'git'
 
     def _get_repository_name(self, environ):
         """
         Gets repository name out of PATH_INFO header
 
         :param environ: environ where PATH_INFO is stored
         """
         repo_name = GIT_PROTO_PAT.match(environ['PATH_INFO']).group(1)
         return repo_name
 
     _ACTION_MAPPING = {
         'git-receive-pack': 'push',
         'git-upload-pack': 'pull',
     }
 
     def _get_action(self, environ):
         """
         Maps git request commands into a pull or push command.
         In case of unknown/unexpected data, it returns 'pull' to be safe.
 
         :param environ:
         """
         path = environ['PATH_INFO']
 
         if path.endswith('/info/refs'):
             query = urlparse.parse_qs(environ['QUERY_STRING'])
             service_cmd = query.get('service', [''])[0]
             return self._ACTION_MAPPING.get(service_cmd, 'pull')
         elif path.endswith('/git-receive-pack'):
             return 'push'
         elif path.endswith('/git-upload-pack'):
             return 'pull'
 
         return 'pull'
 
     def _create_wsgi_app(self, repo_path, repo_name, config):
         return self.scm_app.create_git_wsgi_app(
-            repo_path, repo_name, config, self.SCM)
+            repo_path, repo_name, config)
 
     def _create_config(self, extras, repo_name):
         extras['git_update_server_info'] = utils2.str2bool(
             rhodecode.CONFIG.get('git_update_server_info'))
         return extras

rhodecode/lib/middleware/simplehg.py

@@ -1,81 +1,81 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/
 
 """
 SimpleHG middleware for handling mercurial protocol request
 (push/clone etc.). It's implemented with basic auth function
 """
 
 import logging
 import urlparse
 
 from rhodecode.lib import utils
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.middleware import simplevcs
 
 log = logging.getLogger(__name__)
 
 
 class SimpleHg(simplevcs.SimpleVCS):
 
     SCM = 'hg'
 
     def _get_repository_name(self, environ):
         """
         Gets repository name out of PATH_INFO header
 
         :param environ: environ where PATH_INFO is stored
         """
         return environ['PATH_INFO'].strip('/')
 
     _ACTION_MAPPING = {
         'changegroup': 'pull',
         'changegroupsubset': 'pull',
         'getbundle': 'pull',
         'stream_out': 'pull',
         'listkeys': 'pull',
         'unbundle': 'push',
         'pushkey': 'push',
     }
 
     def _get_action(self, environ):
         """
         Maps mercurial request commands into a pull or push command.
         In case of unknown/unexpected data, it returns 'pull' to be safe.
 
         :param environ:
         """
         query = urlparse.parse_qs(environ['QUERY_STRING'],
                                   keep_blank_values=True)
         if 'cmd' in query:
             cmd = query['cmd'][0]
             return self._ACTION_MAPPING.get(cmd, 'pull')
 
         return 'pull'
 
     def _create_wsgi_app(self, repo_path, repo_name, config):
         return self.scm_app.create_hg_wsgi_app(
-            repo_path, repo_name, config, self.SCM)
+            repo_path, repo_name, config)
 
     def _create_config(self, extras, repo_name):
         config = utils.make_db_config(repo=repo_name)
         config.set('rhodecode', 'RC_SCM_DATA', json.dumps(extras))
 
         return config.serialize()

rhodecode/lib/middleware/utils/scm_app.py

@@ -1,63 +1,63 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2012-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/
 
 """
 Equivalent of rhodecode.lib.middleware.scm_app but using remote apps.
 """
 
 import logging
 
 from rhodecode.lib.middleware.utils import wsgi_app_caller_client
 
 
 log = logging.getLogger(__name__)
 
 
 HG_REMOTE_WSGI = None
 GIT_REMOTE_WSGI = None
 
 
-def create_git_wsgi_app(repo_path, repo_name, config, backend):
+def create_git_wsgi_app(repo_path, repo_name, config):
     """
     Return a WSGI app backed by a remote app to handle Git.
 
     config is a dictionary holding the extras.
     """
     factory = GIT_REMOTE_WSGI
     if not factory:
         log.error('Pyro server has not been initialized yet')
 
     return wsgi_app_caller_client.RemoteAppCaller(
-        factory, backend, repo_path, repo_name, config)
+        factory, repo_path, repo_name, config)
 
 
-def create_hg_wsgi_app(repo_path, repo_name, config, backend):
+def create_hg_wsgi_app(repo_path, repo_name, config):
     """
     Return a WSGI app backed by a remote app to handle Mercurial.
 
     config is a list of 3-item tuples representing a ConfigObject (it is the
     serialized version of the config object).
     """
     factory = HG_REMOTE_WSGI
     if not factory:
         log.error('Pyro server has not been initialized yet')
 
     return wsgi_app_caller_client.RemoteAppCaller(
-        factory, backend, repo_path, repo_name, config)
+        factory, repo_path, repo_name, config)

rhodecode/lib/middleware/utils/scm_app_http.py

@@ -1,136 +1,135 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/
 
 """
 Implementation of the scm_app interface using raw HTTP communication.
 """
 
 import base64
 import logging
 import urlparse
 import wsgiref.util
 
 import msgpack
 import requests
 import webob.request
 
 import rhodecode
 
 
 log = logging.getLogger(__name__)
 
 
-def create_git_wsgi_app(repo_path, repo_name, config, backend):
+def create_git_wsgi_app(repo_path, repo_name, config):
     url = _vcs_streaming_url() + 'git/'
-    return VcsHttpProxy(url, repo_path, repo_name, config, backend)
+    return VcsHttpProxy(url, repo_path, repo_name, config)
 
 
-def create_hg_wsgi_app(repo_path, repo_name, config, backend):
+def create_hg_wsgi_app(repo_path, repo_name, config):
     url = _vcs_streaming_url() + 'hg/'
-    return VcsHttpProxy(url, repo_path, repo_name, config, backend)
+    return VcsHttpProxy(url, repo_path, repo_name, config)
 
 
 def _vcs_streaming_url():
     template = 'http://{}/stream/'
     return template.format(rhodecode.CONFIG['vcs.server'])
 
 
 # TODO: johbo: Avoid the global.
 session = requests.Session()
 # Requests speedup, avoid reading .netrc and similar
 session.trust_env = False
 
 
 class VcsHttpProxy(object):
     """
     A WSGI application which proxies vcs requests.
 
     The goal is to shuffle the data around without touching it. The only
     exception is the extra data from the config object which we send to the
     server as well.
     """
 
-    def __init__(self, url, repo_path, repo_name, config, backend):
+    def __init__(self, url, repo_path, repo_name, config):
         """
         :param str url: The URL of the VCSServer to call.
         """
         self._url = url
         self._repo_name = repo_name
         self._repo_path = repo_path
         self._config = config
-        self._backend = backend
         log.debug(
             "Creating VcsHttpProxy for repo %s, url %s",
             repo_name, url)
 
     def __call__(self, environ, start_response):
         status = '200 OK'
 
         config = msgpack.packb(self._config)
         request = webob.request.Request(environ)
         request_headers = request.headers
         request_headers.update({
             # TODO: johbo: Remove this, rely on URL path only
             'X-RC-Repo-Name': self._repo_name,
             'X-RC-Repo-Path': self._repo_path,
             'X-RC-Path-Info': environ['PATH_INFO'],
             # TODO: johbo: Avoid encoding and put this into payload?
             'X-RC-Repo-Config': base64.b64encode(config),
         })
 
         data = environ['wsgi.input'].read()
         method = environ['REQUEST_METHOD']
 
         # Preserve the query string
         url = self._url
         url = urlparse.urljoin(url, self._repo_name)
         if environ.get('QUERY_STRING'):
             url += '?' + environ['QUERY_STRING']
 
         response = session.request(
             method, url,
             data=data,
             headers=request_headers,
             stream=True)
 
         # Preserve the headers of the response, except hop_by_hop ones
         response_headers = [
             (h, v) for h, v in response.headers.items()
             if not wsgiref.util.is_hop_by_hop(h)
         ]
 
         # TODO: johbo: Better way to get the status including text?
         status = str(response.status_code)
         start_response(status, response_headers)
         return _maybe_stream(response)
 
 
 def _maybe_stream(response):
     """
     Try to generate chunks from the response if it is chunked.
     """
     if _is_chunked(response):
         return response.raw.read_chunked()
     else:
         return [response.content]
 
 
 def _is_chunked(response):
     return response.headers.get('Transfer-Encoding', '') == 'chunked'

rhodecode/lib/middleware/utils/wsgi_app_caller_client.py

@@ -1,100 +1,98 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2012-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/
 
 """
 Utility to call a WSGI app wrapped in a WSGIAppCaller object.
 """
 
 import logging
 
 from Pyro4.errors import ConnectionClosedError
 
 
 log = logging.getLogger(__name__)
 
 
 def _get_clean_environ(environ):
     """Return a copy of the WSGI environment without wsgi.* keys.
 
     It also omits any non-string values.
 
     :param environ: WSGI environment to clean
     :type environ: dict
 
     :returns: WSGI environment to pass to WSGIAppCaller.handle.
     :rtype: dict
     """
     clean_environ = dict(
         (k, v) for k, v in environ.iteritems()
         if type(v) == str and type(k) == str and not k.startswith('wsgi.')
     )
 
     return clean_environ
 
 
 # pylint: disable=too-few-public-methods
 class RemoteAppCaller(object):
     """Create and calls a remote WSGI app using the given factory.
 
     It first cleans the environment, so as to reduce the data transferred.
     """
 
-    def __init__(self, remote_wsgi, backend, *args, **kwargs):
+    def __init__(self, remote_wsgi, *args, **kwargs):
         """
         :param remote_wsgi: The remote wsgi object that creates a
           WSGIAppCaller. This object
           has to have a handle method, with the signature:
           handle(environ, start_response, *args, **kwargs)
-        :param backend: Key (str) of the SCM backend that is in use.
         :param args: args to be passed to the app creation
         :param kwargs: kwargs to be passed to the app creation
         """
         self._remote_wsgi = remote_wsgi
-        self._backend = backend
         self._args = args
         self._kwargs = kwargs
 
     def __call__(self, environ, start_response):
         """
         :param environ: WSGI environment with which the app will be run
         :type environ: dict
         :param start_response: callable of WSGI protocol
         :type start_response: callable
 
         :returns: an iterable with the data returned by the app
         :rtype: iterable<str>
         """
         log.debug("Forwarding WSGI request via proxy %s", self._remote_wsgi)
         input_data = environ['wsgi.input'].read()
         clean_environ = _get_clean_environ(environ)
 
         try:
             data, status, headers = self._remote_wsgi.handle(
                 clean_environ, input_data, *self._args, **self._kwargs)
         except ConnectionClosedError:
             log.debug('Remote Pyro Server ConnectionClosedError')
             self._remote_wsgi._pyroReconnect(tries=15)
             data, status, headers = self._remote_wsgi.handle(
                 clean_environ, input_data, *self._args, **self._kwargs)
 
         log.debug("Got result from proxy, returning to WSGI container")
         start_response(status, headers)
 
         return data

rhodecode/tests/lib/middleware/mock_scm_app.py

@@ -1,41 +1,41 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/
 
 """
 Provides a mock implementation of the scm_app module.
 
 It resembles the same API as :mod:`rhodecode.lib.middleware.utils.scm_app`
 for testing purposes.
 """
 import mock
 
 
-def create_git_wsgi_app(repo_path, repo_name, config, backend):
+def create_git_wsgi_app(repo_path, repo_name, config):
     return mock_git_wsgi
 
 
-def create_hg_wsgi_app(repo_path, repo_name, config, backend):
+def create_hg_wsgi_app(repo_path, repo_name, config):
     return mock_hg_wsgi
 
 
 # Utilities to ease testing
 
 mock_hg_wsgi = mock.Mock()
 mock_git_wsgi = mock.Mock()

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

@@ -1,131 +1,130 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/
 
 import mock
 import Pyro4
 import pytest
 import webtest
 
 from rhodecode.lib.middleware.utils import scm_app_http, scm_app
-from rhodecode.lib.middleware.simplegit import SimpleGit
 from rhodecode.lib.vcs.conf import settings
 
 
 def vcs_http_app(vcsserver_http_echo_app):
     """
     VcsHttpProxy wrapped in WebTest.
     """
     git_url = vcsserver_http_echo_app.http_url + 'stream/git/'
     vcs_http_proxy = scm_app_http.VcsHttpProxy(
-        git_url, 'stub_path', 'stub_name', None, 'stub_backend')
+        git_url, 'stub_path', 'stub_name', None)
     app = webtest.TestApp(vcs_http_proxy)
     return app
 
 
 @pytest.fixture(scope='module')
 def vcsserver_http_echo_app(request, vcsserver_factory):
     """
     A running VCSServer with the EchoApp activated via HTTP.
     """
     vcsserver = vcsserver_factory(
         request=request,
         use_http=True,
         overrides=[{'app:main': {'dev.use_echo_app': 'true'}}])
     return vcsserver
 
 
 @pytest.fixture(scope='session')
 def data():
     one_kb = "x" * 1024
     return one_kb * 1024 * 10
 
 
 def test_reuse_app_no_data(repeat, vcsserver_http_echo_app):
     app = vcs_http_app(vcsserver_http_echo_app)
     for x in xrange(repeat / 10):
         response = app.post('/')
         assert response.status_code == 200
 
 
 def test_reuse_app_with_data(data, repeat, vcsserver_http_echo_app):
     app = vcs_http_app(vcsserver_http_echo_app)
     for x in xrange(repeat / 10):
         response = app.post('/', params=data)
         assert response.status_code == 200
 
 
 def test_create_app_per_request_no_data(repeat, vcsserver_http_echo_app):
     for x in xrange(repeat / 10):
         app = vcs_http_app(vcsserver_http_echo_app)
         response = app.post('/')
         assert response.status_code == 200
 
 
 def test_create_app_per_request_with_data(
         data, repeat, vcsserver_http_echo_app):
     for x in xrange(repeat / 10):
         app = vcs_http_app(vcsserver_http_echo_app)
         response = app.post('/', params=data)
         assert response.status_code == 200
 
 
 @pytest.fixture(scope='module')
 def vcsserver_pyro_echo_app(request, vcsserver_factory):
     """
     A running VCSServer with the EchoApp activated via Pyro4.
     """
     vcsserver = vcsserver_factory(
         request=request,
         use_http=False,
         overrides=[{'DEFAULT': {'dev.use_echo_app': 'true'}}])
     return vcsserver
 
 
 def vcs_pyro4_app(vcsserver_pyro_echo_app):
     """
     Pyro4 based Vcs proxy wrapped in WebTest
     """
     stub_config = {
         'git_update_server_info': 'stub',
     }
     server_and_port = vcsserver_pyro_echo_app.server_and_port
     GIT_REMOTE_WSGI = Pyro4.Proxy(
         settings.pyro_remote(
             settings.PYRO_GIT_REMOTE_WSGI, server_and_port))
     with mock.patch('rhodecode.lib.middleware.utils.scm_app.GIT_REMOTE_WSGI',
                     GIT_REMOTE_WSGI):
         pyro4_app = scm_app.create_git_wsgi_app(
-            'stub_path', 'stub_name', stub_config, SimpleGit.SCM)
+            'stub_path', 'stub_name', stub_config)
     app = webtest.TestApp(pyro4_app)
     return app
 
 
 def test_pyro4_no_data(repeat, pylonsapp, vcsserver_pyro_echo_app):
     for x in xrange(repeat / 10):
         app = vcs_pyro4_app(vcsserver_pyro_echo_app)
         response = app.post('/')
         assert response.status_code == 200
 
 
 def test_pyro4_with_data(repeat, pylonsapp, vcsserver_pyro_echo_app, data):
     for x in xrange(repeat / 10):
         app = vcs_pyro4_app(vcsserver_pyro_echo_app)
         response = app.post('/', params=data)
         assert response.status_code == 200

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 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)
     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)
     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, 'stub_backend')
+        echo_app_url, 'stub_path', 'stub_name', None)

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

@@ -1,102 +1,100 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 webtest
 
 from rhodecode.lib.middleware.utils import wsgi_app_caller_client
 
 # pylint: disable=protected-access,too-many-public-methods
 
 
 BASE_ENVIRON = {
     'REQUEST_METHOD': 'GET',
     'SERVER_NAME': 'localhost',
     'SERVER_PORT': '80',
     'SCRIPT_NAME': '',
     'PATH_INFO': '/',
     'QUERY_STRING': '',
     'foo.bool_var': True,
     'foo.str_var': 'True',
     'wsgi.foo': True,
     # Some non string values. The validator expects to get an iterable as
     # value.
     (42,): '42',
     (True,): 'False',
 }
 
 
 def assert_all_values_are_str(environ):
     """Checks that all values of a dict are str."""
     for key, value in environ.iteritems():
         assert isinstance(value, str), (
             "Value for key %s: has type %s but 'str' was expected. Value: %s" %
             (key, type(value), repr(value)))
 
 
 def assert_all_keys_are_str(environ):
     """Checks that all keys of a dict are str."""
     for key, value in environ.iteritems():
         assert isinstance(value, str), (
             "Key %s: has type %s but 'str' was expected. " %
             (repr(key), type(key)))
 
 
 def assert_no_prefix_in_keys(environ, prefix):
     """Checks that no key of the dict starts with the prefix."""
     for key in environ:
         assert not key.startswith(prefix), 'Key %s should not be present' % key
 
 
 def test_get_environ():
     clean_environ = wsgi_app_caller_client._get_clean_environ(BASE_ENVIRON)
 
     assert len(clean_environ) == 7
     assert_no_prefix_in_keys(clean_environ, 'wsgi.')
     assert_all_keys_are_str(clean_environ)
     assert_all_values_are_str(clean_environ)
 
 
 def test_remote_app_caller():
 
     class RemoteAppCallerMock(object):
 
         def handle(self, environ, input_data, arg1, arg2,
                    arg3=None, arg4=None, arg5=None):
             assert ((arg1, arg2, arg3, arg4, arg5) ==
                     ('a1', 'a2', 'a3', 'a4', None))
             # Note: RemoteAppCaller is expected to return a tuple like the
             # following one
             return (['content'], '200 OK', [('Content-Type', 'text/plain')])
 
     wrapper_app = wsgi_app_caller_client.RemoteAppCaller(
-        RemoteAppCallerMock(), 'dummy-backend',
-        'a1', 'a2', arg3='a3', arg4='a4')
+        RemoteAppCallerMock(), 'a1', 'a2', arg3='a3', arg4='a4')
 
     test_app = webtest.TestApp(wrapper_app)
 
     response = test_app.get('/path')
 
     assert response.status == '200 OK'
     assert sorted(response.headers.items()) == sorted([
-        ('X-RhodeCode-Backend', 'dummy-backend'),
         ('Content-Type', 'text/plain'),
         ('Content-Length', '7'),
     ])
     assert response.body == 'content'