from rhodecode.lib.auth import set_available_permissions

from rhodecode.lib.utils import repo2db_mapper, make_ui, set_rhodecode_config

from rhodecode.model import init_model

from rhodecode.model.scm import ScmModel

log = logging.getLogger(__name__)

def load_environment(global_conf, app_conf, initial=False):

    """Configure the Pylons environment via the ``pylons.config``

    object

    """

    config = PylonsConfig()

    # Pylons paths

    root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

    paths = dict(root=root,

                 controllers=os.path.join(root, 'controllers'),

                 static_files=os.path.join(root, 'public'),

                 templates=[os.path.join(root, 'templates')])

    # Initialize config with the basic options

    config.init_app(global_conf, app_conf, package='rhodecode', paths=paths)

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

    rhodecode.CONFIG = config

    config['routes.map'] = make_map(config)

    config['pylons.app_globals'] = app_globals.Globals(config)

    config['pylons.h'] = rhodecode.lib.helpers

    # Setup cache object as early as possible

    import pylons

    pylons.cache._push_object(config['pylons.app_globals'].cache)

    # Create the Mako TemplateLookup, with the default auto-escaping

    config['pylons.app_globals'].mako_lookup = TemplateLookup(

        directories=paths['templates'],

        error_handler=handle_mako_error,

        module_directory=os.path.join(app_conf['cache_dir'], 'templates'),

        input_encoding='utf-8', default_filters=['escape'],

        imports=['from webhelpers.html import escape'])

    #sets the c attribute access when don't existing attribute are accessed

    config['pylons.strict_tmpl_context'] = True

    test = os.path.split(config['__file__'])[-1] == 'test.ini'

    if test:

        from rhodecode.lib.utils import create_test_env, create_test_index

from rhodecode.lib.utils import BasePasterCommand, Command

from celery.app import app_or_default

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

from rhodecode.lib 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):

        try:

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

        except KeyError:

            CELERY_ON = False

        if CELERY_ON == False:

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

                            'file before running celeryd')

        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