returns an iterator obj with contents of git command's

        response to stdout

        """

        git_command = self._get_fixedpath(request.path_info)

        if git_command not in self.commands:

            log.debug('command %s not allowed' % git_command)

            return exc.HTTPMethodNotAllowed()

        if 'CONTENT_LENGTH' in environ:

            inputstream = FileWrapper(environ['wsgi.input'],

                                      request.content_length)

        else:

            inputstream = environ['wsgi.input']

        try:

            gitenv = os.environ

            from rhodecode import CONFIG

            from rhodecode.lib.base import _get_ip_addr

            gitenv['RHODECODE_USER'] = self.username

            gitenv['RHODECODE_CONFIG_IP'] = _get_ip_addr(environ)

            # forget all configs

            gitenv['GIT_CONFIG_NOGLOBAL'] = '1'

            # we need current .ini file used to later initialize rhodecode

            # env and connect to db

            gitenv['RHODECODE_CONFIG_FILE'] = CONFIG['__file__']

            opts = dict(

                env=gitenv,

                cwd=os.getcwd()

            )

            out = subprocessio.SubprocessIOChunker(

                r'git %s --stateless-rpc "%s"' % (git_command[4:],

                                                  self.content_path),

                inputstream=inputstream,

                **opts

            )

        except EnvironmentError, e:

            log.exception(e)

            raise exc.HTTPExpectationFailed()

        if git_command in [u'git-receive-pack']:

            # updating refs manually after each push.

            # Needed for pre-1.7.0.4 git clients using regular HTTP mode.

            subprocess.call(u'git --git-dir "%s" '

                            'update-server-info' % self.content_path,

                            shell=True)

        resp = Response()

        resp.content_type = 'application/x-%s-result' % git_command.encode('utf8')

        resp.app_iter = out

        return resp

    def __call__(self, environ, start_response):

        request = Request(environ)

        _path = self._get_fixedpath(request.path_info)

        if _path.startswith('info/refs'):

            app = self.inforefs

        elif [a for a in self.valid_accepts if a in request.accept]:

            app = self.backend

        try:

            resp = app(request, environ)

        except exc.HTTPException, e:

            resp = e

            log.exception(e)

        except Exception, e:

            log.exception(e)

            resp = exc.HTTPInternalServerError()

        return resp(environ, start_response)

class GitDirectory(object):

    def __init__(self, repo_root, repo_name, username):

        repo_location = os.path.join(repo_root, repo_name)

        if not os.path.isdir(repo_location):

            raise OSError(repo_location)

        self.content_path = repo_location

        self.repo_name = repo_name

        self.repo_location = repo_location

        self.username = username

    def __call__(self, environ, start_response):

        content_path = self.content_path

        try:

            app = GitRepository(self.repo_name, content_path, self.username)

        except (AssertionError, OSError):

            if os.path.isdir(os.path.join(content_path, '.git')):

                app = GitRepository(self.repo_name,

                                    os.path.join(content_path, '.git'),

                                    self.username)

            else:

                return exc.HTTPNotFound()(environ, start_response, self.username)

        return app(environ, start_response)

def make_wsgi_app(repo_name, repo_root, username):