removed = []

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

    unicode_initial_repo_list = set(safe_unicode(name) for name in initial_repo_list)

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

        if repo.repo_name not in unicode_initial_repo_list:

            if remove_obsolete:

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

                          repo.repo_name)

                try:

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

            removed.append(repo.repo_name)

    return added, removed

def load_rcextensions(root_path):

    import kallithea

    from kallithea.config import conf

    path = os.path.join(root_path, 'rcextensions', '__init__.py')

    if os.path.isfile(path):

        rcext = create_module('rc', path)

        EXT = kallithea.EXTENSIONS = rcext

        log.debug('Found rcextensions now loading %s...', rcext)

        # Additional mappings that are not present in the pygments lexers

        conf.LANGUAGES_EXTENSIONS_MAP.update(getattr(EXT, 'EXTRA_MAPPINGS', {}))

        #OVERRIDE OUR EXTENSIONS FROM RC-EXTENSIONS (if present)

        if getattr(EXT, 'INDEX_EXTENSIONS', []):

            log.debug('settings custom INDEX_EXTENSIONS')

            conf.INDEX_EXTENSIONS = getattr(EXT, 'INDEX_EXTENSIONS', [])

        #ADDITIONAL MAPPINGS

        log.debug('adding extra into INDEX_EXTENSIONS')

        conf.INDEX_EXTENSIONS.extend(getattr(EXT, 'EXTRA_INDEX_EXTENSIONS', []))

        # auto check if the module is not missing any data, set to default if is

        # this will help autoupdate new feature of rcext module

        #from kallithea.config import rcextensions

        #for k in dir(rcextensions):

        #    if not k.startswith('_') and not hasattr(EXT, k):

        #        setattr(EXT, k, getattr(rcextensions, k))

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

# MISC

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

def check_git_version():

    """

    Checks what version of git is installed in system, and issues a warning

    if it's too old for Kallithea to work properly.

    """

    from kallithea import BACKENDS

    from kallithea.lib.vcs.backends.git.repository import GitRepository

    from kallithea.lib.vcs.conf import settings

    from distutils.version import StrictVersion

    if 'git' not in BACKENDS:

        return None

    stdout, stderr = GitRepository._run_git_command(['--version'], _bare=True,

                                                    _safe=True)

    m = re.search("\d+.\d+.\d+", stdout)

    if m:

        ver = StrictVersion(m.group(0))

    else:

        ver = StrictVersion('0.0.0')

    req_ver = StrictVersion('1.7.4')

    log.debug('Git executable: "%s" version %s detected: %s',

              settings.GIT_EXECUTABLE_PATH, ver, stdout)

    if stderr:

        log.warning('Error detecting git version: %r', stderr)

    elif ver < req_ver:

        log.warning('Kallithea detected git version %s, which is too old '

                    'for the system to function properly. '

                    'Please upgrade to version %s or later.' % (ver, req_ver))

    return ver

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

# CACHE RELATED METHODS

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

# set cache regions for beaker so celery can utilise it

def setup_cache_regions(settings):

    cache_settings = {'regions': None}

            if key.startswith(prefix):

    if cache_settings['regions']:

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

            region_settings = {}

                if key.startswith(region):

            region_settings.setdefault('lock_dir',

                                       cache_settings.get('lock_dir'))

            region_settings.setdefault('data_dir',

                                       cache_settings.get('data_dir'))

            beaker.cache.cache_regions[region] = region_settings

def conditional_cache(region, prefix, condition, func):

    """

    Conditional caching function use like::

        def _c(arg):

            #heavy computation function

            return data

        # depending from condition the compute is wrapped in cache or not

        compute = conditional_cache('short_term', 'cache_desc', condition=True, func=func)

        return compute(arg)

    :param region: name of cache region

    :param prefix: cache region prefix

    :param condition: condition for cache to be triggered, and return data cached

    :param func: wrapped heavy function to compute

    """

    wrapped = func

    if condition:

        log.debug('conditional_cache: True, wrapping call of '

                  'func: %s into %s region cache' % (region, func))

        wrapped = _cache_decorate((prefix,), None, None, region)(func)

    return wrapped