import rhodecode

from rhodecode.lib.utils import BasePasterCommand, Command, load_rcextensions

from celery.app import app_or_default

from celery.bin import camqadm, celerybeat, celeryd, celeryev

from rhodecode.lib.utils2 import str2bool

__all__ = ['CeleryDaemonCommand', 'CeleryBeatCommand',

           'CAMQPAdminCommand', 'CeleryEventCommand']

class CeleryCommand(BasePasterCommand):

    """Abstract class implements run methods needed for celery

    Starts the celery worker that uses a paste.deploy configuration

    file.

    """

    def update_parser(self):

        """

        Abstract method.  Allows for the class's parser to be updated

        before the superclass's `run` method is called.  Necessary to

        allow options/arguments to be passed through to the underlying

        celery command.

        """

        cmd = self.celery_command(app_or_default())

        for x in cmd.get_options():

            self.parser.add_option(x)

    def command(self):

        from pylons import config

        try:

            CELERY_ON = str2bool(config['app_conf'].get('use_celery'))

        except KeyError:

            CELERY_ON = False

            raise Exception('Please enable celery_on in .ini config '

                            'file before running celeryd')

        rhodecode.CELERY_ON = CELERY_ON

        load_rcextensions(config['here'])

        cmd = self.celery_command(app_or_default())

        return cmd.run(**vars(self.options))

class CeleryDaemonCommand(CeleryCommand):

    """Start the celery worker

    Starts the celery worker that uses a paste.deploy configuration

    file.

    """

    usage = 'CONFIG_FILE [celeryd options...]'

    summary = __doc__.splitlines()[0]

    description = "".join(__doc__.splitlines()[2:])

    parser = Command.standard_parser(quiet=True)

    celery_command = celeryd.WorkerCommand

class CeleryBeatCommand(CeleryCommand):

    """Start the celery beat server

    Starts the celery beat server using a paste.deploy configuration

    file.

    """

    usage = 'CONFIG_FILE [celerybeat options...]'

    summary = __doc__.splitlines()[0]

    description = "".join(__doc__.splitlines()[2:])

    parser = Command.standard_parser(quiet=True)

    celery_command = celerybeat.BeatCommand

class CAMQPAdminCommand(CeleryCommand):

    """CAMQP Admin

    CAMQP celery admin tool.

    """

    usage = 'CONFIG_FILE [camqadm options...]'

    summary = __doc__.splitlines()[0]

    description = "".join(__doc__.splitlines()[2:])

    parser = Command.standard_parser(quiet=True)

    celery_command = camqadm.AMQPAdminCommand

class CeleryEventCommand(CeleryCommand):

    """Celery event command.

    Capture celery events.

    """

    usage = 'CONFIG_FILE [celeryev options...]'

    summary = __doc__.splitlines()[0]

    description = "".join(__doc__.splitlines()[2:])

    parser = Command.standard_parser(quiet=True)

    celery_command = celeryev.EvCommand

#!/usr/bin/env python

# -*- coding: utf-8 -*-

import os

import re

import shutil

import logging

from rhodecode.lib.dbmigrate.migrate import exceptions

from rhodecode.lib.dbmigrate.migrate.versioning import pathed, script

from datetime import datetime

log = logging.getLogger(__name__)

class VerNum(object):

    """A version number that behaves like a string and int at the same time"""

    _instances = dict()

    def __new__(cls, value):

        val = str(value)

        if val not in cls._instances:

            cls._instances[val] = super(VerNum, cls).__new__(cls)

        ret = cls._instances[val]

        return ret

    def __init__(self,value):

        self.value = str(int(value))

        if self < 0:

            raise ValueError("Version number cannot be negative")

    def __add__(self, value):

        ret = int(self) + int(value)

        return VerNum(ret)

    def __sub__(self, value):

        return self + (int(value) * -1)

    def __cmp__(self, value):

        return int(self) - int(value)

    def __repr__(self):

        return "<VerNum(%s)>" % self.value

    def __str__(self):

        return str(self.value)

    def __int__(self):

        return int(self.value)

class Collection(pathed.Pathed):

    """A collection of versioning scripts in a repository"""

    FILENAME_WITH_VERSION = re.compile(r'^(\d{3,}).*')

    def __init__(self, path):

        """Collect current version scripts in repository

        and store them in self.versions

        """

        super(Collection, self).__init__(path)

        # Create temporary list of files, allowing skipped version numbers.

        files = os.listdir(path)

        if '1' in files:

            # deprecation

            raise Exception('It looks like you have a repository in the old '

                'format (with directories for each version). '

                'Please convert repository before proceeding.')

        tempVersions = dict()

        for filename in files:

            match = self.FILENAME_WITH_VERSION.match(filename)

            if match:

                num = int(match.group(1))

                tempVersions.setdefault(num, []).append(filename)

            else:

                pass  # Must be a helper file or something, let's ignore it.

        # Create the versions member where the keys

        # are VerNum's and the values are Version's.

        self.versions = dict()

        for num, files in tempVersions.items():

            self.versions[VerNum(num)] = Version(num, path, files)

    @property

    def latest(self):

        """:returns: Latest version in Collection"""

        return max([VerNum(0)] + self.versions.keys())

    def _next_ver_num(self, use_timestamp_numbering):

            return VerNum(int(datetime.utcnow().strftime('%Y%m%d%H%M%S')))

        else:

            return self.latest + 1

    def create_new_python_version(self, description, **k):

        """Create Python files for new version"""

        ver = self._next_ver_num(k.pop('use_timestamp_numbering', False))

        extra = str_to_filename(description)

        if extra:

            if extra == '_':

                extra = ''

            elif not extra.startswith('_'):

                extra = '_%s' % extra

        filename = '%03d%s.py' % (ver, extra)

        filepath = self._version_path(filename)

        script.PythonScript.create(filepath, **k)

        self.versions[ver] = Version(ver, self.path, [filename])

    def create_new_sql_version(self, database, description, **k):

        """Create SQL files for new version"""

        ver = self._next_ver_num(k.pop('use_timestamp_numbering', False))

        self.versions[ver] = Version(ver, self.path, [])

        extra = str_to_filename(description)

        if extra:

            if extra == '_':

                extra = ''

            elif not extra.startswith('_'):

                extra = '_%s' % extra

        # Create new files.

        for op in ('upgrade', 'downgrade'):

            filename = '%03d%s_%s_%s.sql' % (ver, extra, database, op)

            filepath = self._version_path(filename)

            script.SqlScript.create(filepath, **k)

            self.versions[ver].add_script(filepath)

    def version(self, vernum=None):

        """Returns latest Version if vernum is not given.

        Otherwise, returns wanted version"""

        if vernum is None:

            vernum = self.latest

        return self.versions[VerNum(vernum)]

    @classmethod

    def clear(cls):

        super(Collection, cls).clear()

    def _version_path(self, ver):

        """Returns path of file in versions repository"""

        return os.path.join(self.path, str(ver))

class Version(object):

    """A single version in a collection

    :param vernum: Version Number

    :param path: Path to script files

    :param filelist: List of scripts

    :type vernum: int, VerNum

    :type path: string

    :type filelist: list

    """

    def __init__(self, vernum, path, filelist):

        self.version = VerNum(vernum)

        # Collect scripts in this folder

        self.sql = dict()

        self.python = None

        for script in filelist:

            self.add_script(os.path.join(path, script))

    def script(self, database=None, operation=None):

        """Returns SQL or Python Script"""

        for db in (database, 'default'):

            # Try to return a .sql script first

            try:

                return self.sql[db][operation]

            except KeyError:

                continue  # No .sql script exists

        # TODO: maybe add force Python parameter?

        ret = self.python

        assert ret is not None, \

            "There is no script for %d version" % self.version

        return ret

    def add_script(self, path):

        """Add script to Collection/Version"""

        if path.endswith(Extensions.py):

    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)

    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

def load_rcextensions(root_path):

    import rhodecode

    from rhodecode.config import conf

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

    if os.path.isfile(path):

        rcext = create_module('rc', path)

        EXT = rhodecode.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)

            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 rhodecode.config import rcextensions

        for k in dir(rcextensions):

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

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

def get_custom_lexer(extension):

    """

    returns a custom lexer if it's defined in rcextensions module, or None

    if there's no custom lexer defined

    """

    import rhodecode

    from pygments import lexers

    #check if we didn't define this extension as other lexer

    if rhodecode.EXTENSIONS and extension in rhodecode.EXTENSIONS.EXTRA_LEXERS:

        _lexer_name = rhodecode.EXTENSIONS.EXTRA_LEXERS[extension]

        return lexers.get_lexer_by_name(_lexer_name)

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

# TEST FUNCTIONS AND CREATORS

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

def create_test_index(repo_location, config, full_index):

    """

    Makes default test index

    :param config: test config

    :param full_index:

    """

    from rhodecode.lib.indexers.daemon import WhooshIndexingDaemon

    from rhodecode.lib.pidlock import DaemonLock, LockHeld

    repo_location = repo_location

    index_location = os.path.join(config['app_conf']['index_dir'])

    if not os.path.exists(index_location):

        os.makedirs(index_location)

    try:

        l = DaemonLock(file_=jn(dn(index_location), 'make_index.lock'))

        WhooshIndexingDaemon(index_location=index_location,

                             repo_location=repo_location)\

            .run(full_index=full_index)

        l.release()

    except LockHeld:

        pass

def create_test_env(repos_test_path, config):

    """

    Makes a fresh database and

    install test repository into tmp dir

    """

    from rhodecode.lib.db_manage import DbManage

    from rhodecode.tests import HG_REPO, GIT_REPO, TESTS_TMP_PATH

    # PART ONE create db

    dbconf = config['sqlalchemy.db1.url']

    log.debug('making test db %s' % dbconf)

    # create test dir if it doesn't exist

    if not os.path.isdir(repos_test_path):

        log.debug('Creating testdir %s' % repos_test_path)

        os.makedirs(repos_test_path)

    dbmanage = DbManage(log_sql=True, dbconf=dbconf, root=config['here'],

                        tests=True)

    dbmanage.create_tables(override=True)

    dbmanage.create_settings(dbmanage.config_prompt(repos_test_path))

    dbmanage.create_default_user()

    dbmanage.admin_prompt()

    dbmanage.create_permissions()

    dbmanage.populate_default_permissions()

    Session().commit()

    # PART TWO make test repo

    log.debug('making test vcs repositories')

    idx_path = config['app_conf']['index_dir']

    data_path = config['app_conf']['cache_dir']

    #clean index and data

    if idx_path and os.path.exists(idx_path):

        log.debug('remove %s' % idx_path)

        shutil.rmtree(idx_path)

    if data_path and os.path.exists(data_path):

from rhodecode.model import BaseModel

from rhodecode.model.db import User, Permission, UserToPerm, UserRepoToPerm,\

    UserRepoGroupToPerm, UserUserGroupToPerm

from rhodecode.lib.utils2 import str2bool

log = logging.getLogger(__name__)

class PermissionModel(BaseModel):

    """

    Permissions model for RhodeCode

    """

    cls = Permission

    def create_permissions(self):

        """

        Create permissions for whole system

        """

        for p in Permission.PERMS:

            if not Permission.get_by_key(p[0]):

                new_perm = Permission()

                new_perm.permission_name = p[0]

                new_perm.permission_longname = p[0]  #translation err with p[1]

                self.sa.add(new_perm)

    def create_default_permissions(self, user):

        """

        Creates only missing default permissions for user

        :param user:

        """

        user = self._get_user(user)

        def _make_perm(perm):

            new_perm = UserToPerm()

            new_perm.user = user

            new_perm.permission = Permission.get_by_key(perm)

            return new_perm

        def _get_group(perm_name):

            return '.'.join(perm_name.split('.')[:1])

        perms = UserToPerm.query().filter(UserToPerm.user == user).all()

        defined_perms_groups = map(_get_group,

                                (x.permission.permission_name for x in perms))

        log.debug('GOT ALREADY DEFINED:%s' % perms)

        DEFAULT_PERMS = Permission.DEFAULT_USER_PERMISSIONS

        # for every default permission that needs to be created, we check if

        # it's group is already defined, if it's not we create default perm

        for perm_name in DEFAULT_PERMS:

            gr = _get_group(perm_name)

            if gr not in defined_perms_groups:

                log.debug('GR:%s not found, creating permission %s'

                          % (gr, perm_name))

                new_perm = _make_perm(perm_name)

                self.sa.add(new_perm)

    def update(self, form_result):

        perm_user = User.get_by_username(username=form_result['perm_user_name'])

        try:

            # stage 1 set anonymous access

            if perm_user.username == 'default':

                perm_user.active = str2bool(form_result['anonymous'])

                self.sa.add(perm_user)

            # stage 2 reset defaults and set them from form data

            def _make_new(usr, perm_name):

                log.debug('Creating new permission:%s' % (perm_name))

                new = UserToPerm()

                new.user = usr

                new.permission = Permission.get_by_key(perm_name)

                return new

            # clear current entries, to make this function idempotent

            # it will fix even if we define more permissions or permissions

            # are somehow missing

            u2p = self.sa.query(UserToPerm)\

                .filter(UserToPerm.user == perm_user)\

                .all()

            for p in u2p:

                self.sa.delete(p)

            #create fresh set of permissions

            for def_perm_key in ['default_repo_perm', 'default_group_perm',

                                 'default_user_group_perm',

                                 'default_repo_create',

                                 #'default_repo_group_create', #not implemented yet

                                 'default_user_group_create',

                                 'default_fork', 'default_register',

                                 'default_extern_activate']:

                p = _make_new(perm_user, form_result[def_perm_key])

                self.sa.add(p)

            #stage 3 update all default permissions for repos if checked

                _def_name = form_result['default_repo_perm'].split('repository.')[-1]

                _def = Permission.get_by_key('repository.' + _def_name)

                # repos

                for r2p in self.sa.query(UserRepoToPerm)\

                               .filter(UserRepoToPerm.user == perm_user)\

                               .all():

                    #don't reset PRIVATE repositories

                    if not r2p.repository.private:

                        r2p.permission = _def

                        self.sa.add(r2p)

                _def_name = form_result['default_group_perm'].split('group.')[-1]

                # groups

                _def = Permission.get_by_key('group.' + _def_name)

                for g2p in self.sa.query(UserRepoGroupToPerm)\

                               .filter(UserRepoGroupToPerm.user == perm_user)\

                               .all():

                    g2p.permission = _def

                    self.sa.add(g2p)

                _def_name = form_result['default_user_group_perm'].split('usergroup.')[-1]

                # groups

                _def = Permission.get_by_key('usergroup.' + _def_name)

                for g2p in self.sa.query(UserUserGroupToPerm)\

                               .filter(UserUserGroupToPerm.user == perm_user)\

                               .all():

                    g2p.permission = _def

                    self.sa.add(g2p)

            self.sa.commit()

        except (DatabaseError,):

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise