def inforefs(self, req, environ):

        """

        WSGI Response producer for HTTP GET Git Smart

        HTTP /info/refs request.

        """

        git_command = req.GET.get('service')

        if git_command not in self.commands:

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

            return exc.HTTPMethodNotAllowed()

        # From Documentation/technical/http-protocol.txt shipped with Git:

        #

        # Clients MUST verify the first pkt-line is `# service=$servicename`.

        # Servers MUST set $servicename to be the request parameter value.

        # Servers SHOULD include an LF at the end of this line.

        # Clients MUST ignore an LF at the end of the line.

        #

        #  smart_reply     =  PKT-LINE("# service=$servicename" LF)

        #                     ref_list

        #                     "0000"

        server_advert = '# service=%s\n' % git_command

        packet_len = str(hex(len(server_advert) + 4)[2:].rjust(4, '0')).lower()

        _git_path = kallithea.CONFIG.get('git_path', 'git')

        cmd = [_git_path, git_command[4:],

               '--stateless-rpc', '--advertise-refs', self.content_path]

        log.debug('handling cmd %s', cmd)

        try:

            out = subprocessio.SubprocessIOChunker(cmd,

                starting_values=[packet_len + server_advert + '0000']

            )

        except EnvironmentError as e:

            log.error(traceback.format_exc())

            raise exc.HTTPExpectationFailed()

        resp = Response()

        resp.content_type = 'application/x-%s-advertisement' % str(git_command)

        resp.charset = None

        resp.app_iter = out

        return resp

    def backend(self, req, environ):

        """

        WSGI Response producer for HTTP POST Git Smart HTTP requests.

        Reads commands and data from HTTP POST's body.

        returns an iterator obj with contents of git command's

        response to stdout

        """

        _git_path = kallithea.CONFIG.get('git_path', 'git')

        git_command = self._get_fixedpath(req.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'],

                                      req.content_length)

        else:

            inputstream = environ['wsgi.input']

        gitenv = dict(os.environ)

        # forget all configs

        gitenv['GIT_CONFIG_NOGLOBAL'] = '1'

        cmd = [_git_path, git_command[4:], '--stateless-rpc', self.content_path]

        log.debug('handling cmd %s', cmd)

        try:

            out = subprocessio.SubprocessIOChunker(

                cmd,

                inputstream=inputstream,

                env=gitenv,

                cwd=self.content_path,

            )

        except EnvironmentError as e:

            log.error(traceback.format_exc())

            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.

            from kallithea.lib.vcs import get_repo

            from dulwich.server import update_server_info

            repo = get_repo(self.content_path)

            if repo:

                update_server_info(repo._repo)

        resp = Response()

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

        resp.charset = None

        resp.app_iter = out

        return resp

    def __call__(self, environ, start_response):

        req = Request(environ)

        _path = self._get_fixedpath(req.path_info)

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

            app = self.inforefs

            app = self.backend

        try:

            resp = app(req, environ)

        except exc.HTTPException as e:

            resp = e

            log.error(traceback.format_exc())

        except Exception as e:

            log.error(traceback.format_exc())

            resp = exc.HTTPInternalServerError()

        return resp(environ, start_response)

class GitDirectory(object):

    def __init__(self, repo_root, repo_name):

        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

    def __call__(self, environ, start_response):

        content_path = self.content_path

        try:

            app = GitRepository(self.repo_name, content_path)

        except (AssertionError, OSError):

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

            if os.path.isdir(content_path):

                app = GitRepository(self.repo_name, content_path)

            else:

                return exc.HTTPNotFound()(environ, start_response)

        return app(environ, start_response)

def make_wsgi_app(repo_name, repo_root):

    from dulwich.web import LimitedInputFilter, GunzipFilter

    app = GitDirectory(repo_root, repo_name)

    return GunzipFilter(LimitedInputFilter(app))