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):

            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

            return feed.writeString('utf-8')

        key = repo_name + '_ATOM'

            region_invalidate(_get_feed_from_cache, None, key)

        return _get_feed_from_cache(key)

    def rss(self, repo_name):

        """Produce an rss2 feed via feedgenerator module"""

        @cache_region('long_term')

        def _get_feed_from_cache(key):

            feed = Rss201rev2Feed(

                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

            return feed.writeString('utf-8')

        key = repo_name + '_RSS'

            region_invalidate(_get_feed_from_cache, None, key)

        return _get_feed_from_cache(key)

    NodeDoesNotExistError

from rhodecode.config.conf import ALL_READMES, ALL_EXTS, LANGUAGES_EXTENSIONS_MAP

from rhodecode.model.db import Statistics, CacheInvalidation

from rhodecode.lib.utils import jsonify

from rhodecode.lib.utils2 import safe_unicode, safe_str

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator,\

    NotAnonymous

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.vcs.backends.base import EmptyChangeset

from rhodecode.lib.markup_renderer import MarkupRenderer

from rhodecode.lib.celerylib import run_task

from rhodecode.lib.celerylib.tasks import get_commits_stats

from rhodecode.lib.helpers import RepoPage

from rhodecode.lib.compat import json, OrderedDict

from rhodecode.lib.vcs.nodes import FileNode

from rhodecode.controllers.changelog import _load_changelog_summary

log = logging.getLogger(__name__)

README_FILES = [''.join([x[0][0], x[1][0]]) for x in

                    sorted(list(product(ALL_READMES, ALL_EXTS)),

                           key=lambda y:y[0][1] + y[1][1])]

class SummaryController(BaseRepoController):

    def __before__(self):

        super(SummaryController, self).__before__()

    def _get_download_links(self, repo):

        download_l = []

        branches_group = ([], _("Branches"))

        tags_group = ([], _("Tags"))

        for name, chs in c.rhodecode_repo.branches.items():

            #chs = chs.split(':')[-1]

            branches_group[0].append((chs, name),)

        download_l.append(branches_group)

        for name, chs in c.rhodecode_repo.tags.items():

            #chs = chs.split(':')[-1]

            tags_group[0].append((chs, name),)

        download_l.append(tags_group)

        return download_l

    def __get_readme_data(self, db_repo):

        repo_name = db_repo.repo_name

        @cache_region('long_term')

        def _get_readme_from_cache(key):

            readme_data = None

            readme_file = None

            log.debug('Looking for README file')

            try:

                # get's the landing revision! or tip if fails

                cs = db_repo.get_landing_changeset()

                if isinstance(cs, EmptyChangeset):

                    raise EmptyRepositoryError()

                renderer = MarkupRenderer()

                for f in README_FILES:

                    try:

                        readme = cs.get_node(f)

                        if not isinstance(readme, FileNode):

                            continue

                        readme_file = f

                        log.debug('Found README file `%s` rendering...' %

                                  readme_file)

                        readme_data = renderer.render(readme.content, f)

                        break

                    except NodeDoesNotExistError:

                        continue

            except ChangesetError:

                log.error(traceback.format_exc())

                pass

            except EmptyRepositoryError:

                pass

            except Exception:

                log.error(traceback.format_exc())

            return readme_data, readme_file

        key = repo_name + '_README'

            region_invalidate(_get_readme_from_cache, None, key)

        return _get_readme_from_cache(key)

    @LoginRequired()

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

                                   'repository.admin')

    def index(self, repo_name):

        c.dbrepo = dbrepo = c.rhodecode_db_repo

        _load_changelog_summary()

        if self.rhodecode_user.username == 'default':

            # for default(anonymous) user we don't need to pass credentials

            username = ''

            password = ''

        else:

            username = str(self.rhodecode_user.username)

            password = '@'

        parsed_url = urlparse(url.current(qualified=True))

        default_clone_uri = '{scheme}://{user}{pass}{netloc}{path}'

        uri_tmpl = config.get('clone_uri', default_clone_uri)

        uri_tmpl = uri_tmpl.replace('{', '%(').replace('}', ')s')

        decoded_path = safe_unicode(urllib.unquote(parsed_url.path))

        uri_dict = {

           'user': urllib.quote(username),

           'pass': password,

           'scheme': parsed_url.scheme,

           'netloc': parsed_url.netloc,

           'path': urllib.quote(safe_str(decoded_path))

        }

        uri = (uri_tmpl % uri_dict)

        # generate another clone url by id

        uri_dict.update(

         {'path': decoded_path.replace(repo_name, '_%s' % c.dbrepo.repo_id)}

        )

        uri_id = uri_tmpl % uri_dict

        c.clone_repo_url = uri

        c.clone_repo_url_id = uri_id

        td = date.today() + timedelta(days=1)

        td_1m = td - timedelta(days=calendar.mdays[td.month])

        td_1y = td - timedelta(days=365)

        ts_min_m = mktime(td_1m.timetuple())

        ts_min_y = mktime(td_1y.timetuple())

        ts_max_y = mktime(td.timetuple())

    from rhodecode.model.scm import ScmModel

    sa = meta.Session()

    rm = RepoModel()

    user = User.get_first_admin()

    added = []

    ##creation defaults

    defs = RhodeCodeSetting.get_default_repo_settings(strip_prefix=True)

    enable_statistics = defs.get('repo_enable_statistics')

    enable_locking = defs.get('repo_enable_locking')

    enable_downloads = defs.get('repo_enable_downloads')

    private = defs.get('repo_private')

    for name, repo in initial_repo_list.items():

        group = map_groups(name)

        db_repo = rm.get_by_repo_name(name)

        # found repo that is on filesystem not in RhodeCode database

        if not db_repo:

            log.info('repository %s not found, creating now' % name)

            added.append(name)

            desc = (repo.description

                    if repo.description != 'unknown'

                    else '%s repository' % name)

            new_repo = rm.create_repo(

                repo_name=name,

                repo_type=repo.alias,

                description=desc,

                repos_group=getattr(group, 'group_id', None),

                owner=user,

                just_db=True,

                enable_locking=enable_locking,

                enable_downloads=enable_downloads,

                enable_statistics=enable_statistics,

                private=private

            )

            # we added that repo just now, and make sure it has githook

            # installed

            if new_repo.repo_type == 'git':

                ScmModel().install_git_hook(new_repo.scm_instance)

            new_repo.update_changeset_cache()

        elif install_git_hook:

            if db_repo.repo_type == 'git':

                ScmModel().install_git_hook(db_repo.scm_instance)

        # during starting install all cache keys for all repositories in the

        # system, this will register all repos and multiple instances

        cache_key = CacheInvalidation._get_cache_key(name)

        log.debug("Creating invalidation cache key for %s: %s", name, cache_key)

    sa.commit()

    removed = []

    if remove_obsolete:

        # remove from database those repositories that are not in the filesystem

        for repo in sa.query(Repository).all():

            if repo.repo_name not in initial_repo_list.keys():

                log.debug("Removing non-existing repository found in db `%s`" %

                          repo.repo_name)

                try:

                    removed.append(repo.repo_name)

                    RepoModel(sa).delete(repo, forks='detach', fs_remove=False)

                    sa.commit()

                except Exception:

                    #don't hold further removals on error

                    log.error(traceback.format_exc())

                    sa.rollback()

    return added, removed

# set cache regions for beaker so celery can utilise it

def add_cache(settings):

    cache_settings = {'regions': None}

    for key in settings.keys():

        for prefix in ['beaker.cache.', 'cache.']:

            if key.startswith(prefix):

                name = key.split(prefix)[1].strip()

                cache_settings[name] = settings[key].strip()

    if cache_settings['regions']:

        for region in cache_settings['regions'].split(','):

            region = region.strip()

            region_settings = {}

            for key, value in cache_settings.items():

                if key.startswith(region):

                    region_settings[key.split('.')[1]] = value

            region_settings['expire'] = int(region_settings.get('expire',

                                                                60))

            region_settings.setdefault('lock_dir',

                                       cache_settings.get('lock_dir'))

            region_settings.setdefault('data_dir',

                                       cache_settings.get('data_dir'))

            if 'type' not in region_settings:

                region_settings['type'] = cache_settings.get('type',

                                                             'memory')

            beaker.cache.cache_regions[region] = region_settings

            cmts = cmts.filter(ChangesetComment.revision.in_(revisions))

        grouped = defaultdict(list)

        for cmt in cmts.all():

            grouped[cmt.revision].append(cmt)

        return grouped

    def statuses(self, revisions=None):

        """

        Returns statuses for this repository

        :param revisions: list of revisions to get statuses for

        :type revisions: list

        """

        statuses = ChangesetStatus.query()\

            .filter(ChangesetStatus.repo == self)\

            .filter(ChangesetStatus.version == 0)

        if revisions:

            statuses = statuses.filter(ChangesetStatus.revision.in_(revisions))

        grouped = {}

        #maybe we have open new pullrequest without a status ?

        stat = ChangesetStatus.STATUS_UNDER_REVIEW

        status_lbl = ChangesetStatus.get_status_lbl(stat)

        for pr in PullRequest.query().filter(PullRequest.org_repo == self).all():

            for rev in pr.revisions:

                pr_id = pr.pull_request_id

                pr_repo = pr.other_repo.repo_name

                grouped[rev] = [stat, status_lbl, pr_id, pr_repo]

        for stat in statuses.all():

            pr_id = pr_repo = None

            if stat.pull_request:

                pr_id = stat.pull_request.pull_request_id

                pr_repo = stat.pull_request.other_repo.repo_name

            grouped[stat.revision] = [str(stat.status), stat.status_lbl,

                                      pr_id, pr_repo]

        return grouped

    def _repo_size(self):

        from rhodecode.lib import helpers as h

        log.debug('calculating repository size...')

        return h.format_byte_size(self.scm_instance.size)

    #==========================================================================

    # SCM CACHE INSTANCE

    #==========================================================================

    def set_invalidate(self):

        """

        Mark caches of this repo as invalid.

        """

        CacheInvalidation.set_invalidate(self.repo_name)

    def scm_instance_no_cache(self):

        return self.__get_instance()

    @property

    def scm_instance(self):

        import rhodecode

        full_cache = str2bool(rhodecode.CONFIG.get('vcs_full_cache'))

        if full_cache:

            return self.scm_instance_cached()

        return self.__get_instance()

        @cache_region('long_term')

        def _c(repo_name):

            return self.__get_instance()

        rn = self.repo_name

            region_invalidate(_c, None, rn)

        else:

            log.debug('Getting obj for %s from cache' % (rn))

        return _c(rn)

    def __get_instance(self):

        repo_full_path = self.repo_full_path

        try:

            alias = get_scm(repo_full_path)[0]

            log.debug('Creating instance of %s repository from %s'

                      % (alias, repo_full_path))

            backend = get_backend(alias)

        except VCSError:

            log.error(traceback.format_exc())

            log.error('Perhaps this repository is in db and not in '

                      'filesystem run rescan repositories with '

                      '"destroy old data " option from admin panel')

            return

        if alias == 'hg':

            repo = backend(safe_str(repo_full_path), create=False,

                           baseui=self._ui)

            # skip hidden web repository

            if repo._get_hidden():

                return

        else:

            repo = backend(repo_full_path, create=False)

        return repo

class RepoGroup(Base, BaseModel):

    __tablename__ = 'groups'

    __table_args__ = (

        UniqueConstraint('group_name', 'group_parent_id'),

        CheckConstraint('group_id != group_parent_id'),

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8'},

    )

    __mapper_args__ = {'order_by': 'group_name'}

    group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    group_name = Column("group_name", String(255, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None)

    group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)

    group_description = Column("group_description", String(10000, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    enable_locking = Column("enable_locking", Boolean(), nullable=False, unique=None, default=False)

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)

        self.cache_active = False

    def __unicode__(self):

        return u"<%s('%s:%s[%s]')>" % (self.__class__.__name__,

                            self.cache_id, self.cache_key, self.cache_active)

    def _cache_key_partition(self):

        prefix, repo_name, suffix = self.cache_key.partition(self.cache_args)

        return prefix, repo_name, suffix

    def get_prefix(self):

        """

        get prefix that might have been used in _get_cache_key to

        generate self.cache_key. Only used for informational purposes

        in repo_edit.html.

        """

        # prefix, repo_name, suffix

        return self._cache_key_partition()[0]

    def get_suffix(self):

        """

        get suffix that might have been used in _get_cache_key to

        generate self.cache_key. Only used for informational purposes

        in repo_edit.html.

        """

        # prefix, repo_name, suffix

        return self._cache_key_partition()[2]

    @classmethod

    def clear_cache(cls):

        """

        Delete all cache keys from database.

        Should only be run when all instances are down and all entries thus stale.

        """

        cls.query().delete()

        Session().commit()

    @classmethod

    def _get_cache_key(cls, key):

        """

        Wrapper for generating a unique cache key for this instance and "key".

        key must / will start with a repo_name which will be stored in .cache_args .

        """

        import rhodecode

        prefix = rhodecode.CONFIG.get('instance_id', '')

        return "%s%s" % (prefix, key)

    @classmethod

    def set_invalidate(cls, repo_name):

        """

        Mark all caches of a repo as invalid in the database.

        """

        inv_objs = Session().query(cls).filter(cls.cache_args == repo_name).all()

        try:

            for inv_obj in inv_objs:

                log.debug('marking %s key for invalidation based on repo_name=%s'

                          % (inv_obj, safe_str(repo_name)))

                inv_obj.cache_active = False

                Session().add(inv_obj)

            Session().commit()

        except Exception:

            log.error(traceback.format_exc())

            Session().rollback()

    @classmethod

        """

        """

    @classmethod

class ChangesetComment(Base, BaseModel):

    __tablename__ = 'changeset_comments'

    __table_args__ = (

        Index('cc_revision_idx', 'revision'),

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8'},

    )

    comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)

    repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)

    revision = Column('revision', String(40), nullable=True)

    pull_request_id = Column("pull_request_id", Integer(), ForeignKey('pull_requests.pull_request_id'), nullable=True)

    line_no = Column('line_no', Unicode(10), nullable=True)

    hl_lines = Column('hl_lines', Unicode(512), nullable=True)

    f_path = Column('f_path', Unicode(1000), nullable=True)

    user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)

    text = Column('text', UnicodeText(25000), nullable=False)

    created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    modified_at = Column('modified_at', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    author = relationship('User', lazy='joined')

    repo = relationship('Repository')

    status_change = relationship('ChangesetStatus', cascade="all, delete, delete-orphan")

    pull_request = relationship('PullRequest', lazy='joined')

    @classmethod

    def get_users(cls, revision=None, pull_request_id=None):

        """

        Returns user associated with this ChangesetComment. ie those

        who actually commented

        :param cls:

        :param revision:

        """

        q = Session().query(User)\

                .join(ChangesetComment.author)

        if revision:

            q = q.filter(cls.revision == revision)

        elif pull_request_id:

            q = q.filter(cls.pull_request_id == pull_request_id)

        return q.all()

class ChangesetStatus(Base, BaseModel):

    __tablename__ = 'changeset_statuses'

    __table_args__ = (

        Index('cs_revision_idx', 'revision'),

    action_logger, REMOVED_REPO_PAT

from rhodecode.model import BaseModel

from rhodecode.model.db import Repository, RhodeCodeUi, CacheInvalidation, \

    UserFollowing, UserLog, User, RepoGroup, PullRequest

from rhodecode.lib.hooks import log_push_action

log = logging.getLogger(__name__)

class UserTemp(object):

    def __init__(self, user_id):

        self.user_id = user_id

    def __repr__(self):

        return "<%s('id:%s')>" % (self.__class__.__name__, self.user_id)

class RepoTemp(object):

    def __init__(self, repo_id):

        self.repo_id = repo_id

    def __repr__(self):

        return "<%s('id:%s')>" % (self.__class__.__name__, self.repo_id)

class CachedRepoList(object):

    """

    Cached repo list, uses in-memory cache after initialization, that is

    super fast

    """

    def __init__(self, db_repo_list, repos_path, order_by=None, perm_set=None):

        self.db_repo_list = db_repo_list

        self.repos_path = repos_path

        self.order_by = order_by

        self.reversed = (order_by or '').startswith('-')

        if not perm_set:

            perm_set = ['repository.read', 'repository.write',

                        'repository.admin']

        self.perm_set = perm_set

    def __len__(self):

        return len(self.db_repo_list)

    def __repr__(self):

        return '<%s (%s)>' % (self.__class__.__name__, self.__len__())

    def __iter__(self):

        # for each repo

        for dbr in self.db_repo_list:

            # check permission at this level

            if not HasRepoPermissionAny(

                *self.perm_set)(dbr.repo_name, 'get repo check'):

                continue

            try:

                last_change = scmr.last_change

                tip = h.get_changeset_safe(scmr, 'tip')

            except Exception:

                log.error(

                    '%s this repository is present in database but it '

                    'cannot be created as an scm instance, org_exc:%s'

                    % (dbr.repo_name, traceback.format_exc())

                )

                continue

            tmp_d = {}

            tmp_d['name'] = dbr.repo_name

            tmp_d['name_sort'] = tmp_d['name'].lower()

            tmp_d['raw_name'] = tmp_d['name'].lower()

            tmp_d['description'] = dbr.description

            tmp_d['description_sort'] = tmp_d['description'].lower()

            tmp_d['last_change'] = last_change

            tmp_d['last_change_sort'] = time.mktime(last_change.timetuple())

            tmp_d['tip'] = tip.raw_id

            tmp_d['tip_sort'] = tip.revision

            tmp_d['rev'] = tip.revision

            tmp_d['contact'] = dbr.user.full_contact

            tmp_d['contact_sort'] = tmp_d['contact']

            tmp_d['owner_sort'] = tmp_d['contact']

            tmp_d['repo_archives'] = list(scmr._get_archives())

            tmp_d['last_msg'] = tip.message

            tmp_d['author'] = tip.author

            tmp_d['dbrepo'] = dbr.get_dict()

            tmp_d['dbrepo_fork'] = dbr.fork.get_dict() if dbr.fork else {}

            yield tmp_d

class SimpleCachedRepoList(CachedRepoList):

    """

    Lighter version of CachedRepoList without the scm initialisation

    """

    def __iter__(self):

        for dbr in self.db_repo_list:

            # check permission at this level

            if not HasRepoPermissionAny(

                *self.perm_set)(dbr.repo_name, 'get repo check'):