class FeedController(BaseRepoController):

    @LoginRequired(api_access=True)

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def __before__(self):

        super(FeedController, self).__before__()

        #common values for feeds

        self.description = _('Changes on %s repository')

        self.title = self.title = _('%s %s feed') % (c.rhodecode_name, '%s')

        self.language = 'en-us'

        self.ttl = "5"

        import rhodecode

        CONF = rhodecode.CONFIG

        self.include_diff = str2bool(CONF.get('rss_include_diff', False))

        self.feed_nr = safe_int(CONF.get('rss_items_per_page', 20))

        # we need to protect from parsing huge diffs here other way

        # we can kill the server

        self.feed_diff_limit = safe_int(CONF.get('rss_cut_off_limit', 32 * 1024))

    def _get_title(self, cs):

        return "%s" % (

            h.shorter(cs.message, 160)

        )

    def __changes(self, cs):

        changes = []

        diff_processor = DiffProcessor(cs.diff(),

                                       diff_limit=self.feed_diff_limit)

        _parsed = diff_processor.prepare(inline_diff=False)

        limited_diff = False

        if isinstance(_parsed, LimitedDiffContainer):

            limited_diff = True

        for st in _parsed:

            st.update({'added': st['stats']['added'],

                       'removed': st['stats']['deleted']})

            changes.append('\n %(operation)s %(filename)s '

                           '(%(added)s lines added, %(removed)s lines removed)'

                            % st)

        if limited_diff:

            changes = changes + ['\n ' +

                                 _('Changeset was too big and was cut off...')]

        return diff_processor, changes

    def __get_desc(self, cs):

        #branches, tags, bookmarks

        if cs.branch:

            desc_msg.append('branch: %s<br/>' % cs.branch)

        if h.is_hg(c.rhodecode_repo):

            for book in cs.bookmarks:

                desc_msg.append('bookmark: %s<br/>' % book)

        for tag in cs.tags:

            desc_msg.append('tag: %s<br/>' % tag)

        diff_processor, changes = self.__changes(cs)

        # rev link

        _url = url('changeset_home', repo_name=cs.repository.name,

                   revision=cs.raw_id, qualified=True)

        desc_msg.append('changeset: <a href="%s">%s</a>' % (_url, cs.raw_id[:8]))

        desc_msg.append('<pre>')

        desc_msg.append(cs.message)

        desc_msg.append('\n')

        desc_msg.extend(changes)

        if self.include_diff:

            desc_msg.append('\n\n')

            desc_msg.append(diff_processor.as_raw())

        desc_msg.append('</pre>')

        return map(safe_unicode, desc_msg)

    def atom(self, repo_name):

        """Produce an atom-1.0 feed via feedgenerator module"""

        @cache_region('long_term')

        def _get_feed_from_cache(key, kind):

            feed = Atom1Feed(

                 title=self.title % repo_name,

                 link=url('summary_home', repo_name=repo_name,

                          qualified=True),

                 description=self.description % repo_name,

                 language=self.language,

                 ttl=self.ttl

            )

            for cs in reversed(list(c.rhodecode_repo[-self.feed_nr:])):

                feed.add_item(title=self._get_title(cs),

                              link=url('changeset_home', repo_name=repo_name,

                                       revision=cs.raw_id, qualified=True),

                              author_name=cs.author,

                              description=''.join(self.__get_desc(cs)),

                              pubdate=cs.date,

                              )

            response.content_type = feed.mime_type

                else:

                    lbl = '%s' % (rev.short_id[:8])

                    _url = url('changeset_home', repo_name=repo_name,

                               revision=rev.raw_id)

                    title = tooltip(rev.message)

            else:

                ## changeset cannot be found/striped/removed etc.

                lbl = ('%s' % rev)[:12]

                _url = '#'

                title = _('Changeset not found')

            if parse_cs:

                return link_to(lbl, _url, title=title, class_='tooltip')

            return link_to(lbl, _url, raw_id=rev.raw_id, repo_name=repo_name,

                           class_='lazy-cs' if lazy_cs else '')

        def _get_op(rev_txt):

            _op = None

            _name = rev_txt

            if len(rev_txt.split('=>')) == 2:

                _op, _name = rev_txt.split('=>')

            return _op, _name

        revs = []

        if len(filter(lambda v: v != '', revs_ids)) > 0:

            repo = None

            for rev in revs_ids[:revs_top_limit]:

                _op, _name = _get_op(rev)

                # we want parsed changesets, or new log store format is bad

                if parse_cs:

                    try:

                        if repo is None:

                            repo = user_log.repository.scm_instance

                        _rev = repo.get_changeset(rev)

                        revs.append(_rev)

                    except ChangesetDoesNotExistError:

                        log.error('cannot find revision %s in this repo' % rev)

                        revs.append(rev)

                        continue

                else:

                    _rev = AttributeDict({

                        'short_id': rev[:12],

                        'raw_id': rev,

                        'message': '',

                        'op': _op,

                        'ref_name': _name

                    })

                    revs.append(_rev)

            [lnk(rev, repo_name) for rev in revs[:revs_limit]]

        _op1, _name1 = _get_op(revs_ids[0])

        _op2, _name2 = _get_op(revs_ids[-1])

        _rev = '%s...%s' % (_name1, _name2)

        compare_view = (

            ' <div class="compare_view tooltip" title="%s">'

            '<a href="%s">%s</a> </div>' % (

                _('Show all combined changesets %s->%s') % (

                    revs_ids[0][:12], revs_ids[-1][:12]

                ),

                url('changeset_home', repo_name=repo_name,

                    revision=_rev

                ),

                _('compare view')

            )

        )

        # if we have exactly one more than normally displayed

        # just display it, takes less space than displaying

        # "and 1 more revisions"

        if len(revs_ids) == revs_limit + 1:

            rev = revs[revs_limit]

            cs_links.append(", " + lnk(rev, repo_name))

        # hidden-by-default ones

        if len(revs_ids) > revs_limit + 1:

            uniq_id = revs_ids[0]

            html_tmpl = (

                '<span> %s <a class="show_more" id="_%s" '

                'href="#more">%s</a> %s</span>'

            )

            if not feed:

                cs_links.append(html_tmpl % (

                      _('and'),

                      uniq_id, _('%s more') % (len(revs_ids) - revs_limit),

                      _('revisions')

                    )

                )

            if not feed:

                html_tmpl = '<span id="%s" style="display:none">, %s </span>'

            else:

                html_tmpl = '<span id="%s"> %s </span>'

            morelinks = ', '.join(

              [lnk(rev, repo_name) for rev in revs[revs_limit:]]

            )

    :author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import os

import re

import logging

import traceback

from dulwich import server as dulserver

from dulwich.web import LimitedInputFilter, GunzipFilter

from rhodecode.lib.exceptions import HTTPLockedRC

from rhodecode.lib.hooks import pre_pull

class SimpleGitUploadPackHandler(dulserver.UploadPackHandler):

    def handle(self):

        write = lambda x: self.proto.write_sideband(1, x)

        graph_walker = dulserver.ProtocolGraphWalker(self,

                                                     self.repo.object_store,

                                                     self.repo.get_peeled)

        objects_iter = self.repo.fetch_objects(

          graph_walker.determine_wants, graph_walker, self.progress,

          get_tagged=self.get_tagged)

        # Did the process short-circuit (e.g. in a stateless RPC call)? Note

        # that the client still expects a 0-object pack in most cases.

        if objects_iter is None:

            return

        self.progress("counting objects: %d, done.\n" % len(objects_iter))

        dulserver.write_pack_objects(dulserver.ProtocolFile(None, write),

                                     objects_iter)

        for msg in messages:

            self.progress(msg + "\n")

        # we are done

        self.proto.write("0000")

dulserver.DEFAULT_HANDLERS = {

  #git-ls-remote, git-clone, git-fetch and git-pull

  'git-upload-pack': SimpleGitUploadPackHandler,

  #git-push

  'git-receive-pack': dulserver.ReceivePackHandler,

}

# not used for now until dulwich get's fixed

#from dulwich.repo import Repo

#from dulwich.web import make_wsgi_chain

from paste.httpheaders import REMOTE_USER, AUTH_TYPE

from webob.exc import HTTPNotFound, HTTPForbidden, HTTPInternalServerError, \

    HTTPBadRequest, HTTPNotAcceptable

from rhodecode.lib.utils2 import safe_str, fix_PATH, get_server_url,\

    _set_extras

from rhodecode.lib.base import BaseVCSController

from rhodecode.lib.auth import get_container_username

from rhodecode.lib.utils import is_valid_repo, make_ui

from rhodecode.lib.compat import json

from rhodecode.model.db import User, RhodeCodeUi

log = logging.getLogger(__name__)

GIT_PROTO_PAT = re.compile(r'^/(.+)/(info/refs|git-upload-pack|git-receive-pack)')

def is_git(environ):

    path_info = environ['PATH_INFO']

    isgit_path = GIT_PROTO_PAT.match(path_info)

    log.debug('pathinfo: %s detected as GIT %s' % (

        path_info, isgit_path is not None)

    )

    return isgit_path

class SimpleGit(BaseVCSController):

    def _handle_request(self, environ, start_response):

            return ret

        finally:

            f.close()

    def write_to_path(self, path=None):

        """Write configuration to a file on disk."""

        if path is None:

            path = self.path

        f = GitFile(path, 'wb')

        try:

            self.write_to_file(f)

        finally:

            f.close()

    def write_to_file(self, f):

        """Write configuration to a file-like object."""

        for section, values in self._values.iteritems():

            try:

                section_name, subsection_name = section

            except ValueError:

                (section_name, ) = section

                subsection_name = None

            if subsection_name is None:

                f.write("[%s]\n" % section_name)

            else:

                f.write("[%s \"%s\"]\n" % (section_name, subsection_name))

            for key, value in values.iteritems():

                f.write("%s = %s\n" % (key, _escape_value(value)))

class StackedConfig(Config):

    """Configuration which reads from multiple config files.."""

    def __init__(self, backends, writable=None):

        self.backends = backends

        self.writable = writable

    def __repr__(self):

        return "<%s for %r>" % (self.__class__.__name__, self.backends)

    @classmethod

    def default_backends(cls):

        """Retrieve the default configuration.

        This will look in the repository configuration (if for_path is

        specified), the users' home directory and the system

        configuration.

        """

        backends = []

        for path in paths:

            try:

                cf = ConfigFile.from_path(path)

            except (IOError, OSError), e:

                if e.errno != errno.ENOENT:

                    raise

                else:

                    continue

            backends.append(cf)

        return backends

    def get(self, section, name):

        for backend in self.backends:

            try:

                return backend.get(section, name)

            except KeyError:

                pass

        raise KeyError(name)

    def set(self, section, name, value):

        if self.writable is None:

            raise NotImplementedError(self.set)

        return self.writable.set(section, name, value)

            cmd += ' -- "%s"' % path

        stdout, stderr = self.run_git_command(cmd)

        # If we used 'show' command, strip first few lines (until actual diff

        # starts)

        if rev1 == self.EMPTY_CHANGESET:

            lines = stdout.splitlines()

            x = 0

            for line in lines:

                if line.startswith('diff'):

                    break

                x += 1

            # Append new line just like 'diff' command do

            stdout = '\n'.join(lines[x:]) + '\n'

        return stdout

    @LazyProperty

    def in_memory_changeset(self):

        """

        Returns ``GitInMemoryChangeset`` object for this repository.

        """

        return GitInMemoryChangeset(self)

    def clone(self, url, update_after_clone=True, bare=False):

        """

        Tries to clone changes from external location.

        :param update_after_clone: If set to ``False``, git won't checkout

          working directory

        :param bare: If set to ``True``, repository would be cloned into

          *bare* git repository (no working directory at all).

        """

        url = self._get_url(url)

        cmd = ['clone']

        if bare:

            cmd.append('--bare')

        elif not update_after_clone:

            cmd.append('--no-checkout')

        cmd += ['--', '"%s"' % url, '"%s"' % self.path]

        cmd = ' '.join(cmd)

        # If error occurs run_git_command raises RepositoryError already

        self.run_git_command(cmd)

    def pull(self, url):

        """

        Tries to pull changes from external location.

        """

        url = self._get_url(url)

        cmd = ' '.join(cmd)

        # If error occurs run_git_command raises RepositoryError already

        self.run_git_command(cmd)

    def fetch(self, url):

        """

        Tries to pull changes from external location.

        """

        url = self._get_url(url)

        so, se = self.run_git_command('ls-remote -h %s' % url)

        refs = []

        for line in (x for x in so.splitlines()):

            sha, ref = line.split('\t')

            refs.append(ref)

        refs = ' '.join(('+%s:%s' % (r, r) for r in refs))

        cmd = '''fetch %s -- %s''' % (url, refs)

        self.run_git_command(cmd)

    @LazyProperty

    def workdir(self):

        """

        Returns ``Workdir`` instance for this repository.

        """

        return GitWorkdir(self)

    def get_config_value(self, section, name, config_file=None):

        """

        Returns configuration value for a given [``section``] and ``name``.

        :param section: Section we want to retrieve value from

        :param name: Name of configuration we want to retrieve

        :param config_file: A path to file which should be used to retrieve

          configuration from (might also be a list of file paths)

        """

        if config_file is None:

            config_file = []

        elif isinstance(config_file, basestring):

            config_file = [config_file]

        def gen_configs():

            for path in config_file + self._config_files:

                try:

                    yield ConfigFile.from_path(path)

                except (IOError, OSError, ValueError):

                    continue

        for config in gen_configs():

            try: