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

# 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/>.

"""

kallithea.controllers.admin.settings

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

settings controller for Kallithea admin

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Jul 14, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import traceback

import formencode

from formencode import htmlfill

from tg import config, request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPFound

import kallithea

from kallithea.controllers import base

from kallithea.lib import webutils

from kallithea.lib.auth import HasPermissionAnyDecorator, LoginRequired

from kallithea.lib.utils import repo2db_mapper, set_app_settings

from kallithea.lib.utils2 import safe_str

from kallithea.lib.vcs import VCSError

from kallithea.lib.webutils import url

from kallithea.model import async_tasks, db, meta

from kallithea.model.forms import ApplicationSettingsForm, ApplicationUiSettingsForm, ApplicationVisualisationForm

from kallithea.model.notification import EmailNotificationModel

from kallithea.model.scm import ScmModel

log = logging.getLogger(__name__)

class SettingsController(base.BaseController):

    @LoginRequired(allow_default_user=True)

    def _before(self, *args, **kwargs):

        super(SettingsController, self)._before(*args, **kwargs)

    def _get_hg_ui_settings(self):

        ret = db.Ui.query().all()

        settings = {}

        for each in ret:

            k = each.ui_section + '_' + each.ui_key

            v = each.ui_value

            if k == 'paths_/':

                k = 'paths_root_path'

            k = k.replace('.', '_')

            if each.ui_section in ['hooks', 'extensions']:

                v = each.ui_active

            settings[k] = v

        return settings

    @HasPermissionAnyDecorator('hg.admin')

    def settings_vcs(self):

        c.active = 'vcs'

        if request.POST:

            application_form = ApplicationUiSettingsForm()()

            try:

                form_result = application_form.to_python(dict(request.POST))

            except formencode.Invalid as errors:

                        webutils.flash(_('Hook already exists'), category='error')

                    elif ui_key in (x.ui_key for x in db.Ui.get_builtin_hooks()):

                        webutils.flash(_('Builtin hooks are read-only. Please use another hook name.'), category='error')

                    elif ui_value and ui_key:

                        db.Ui.create_or_update_hook(ui_key, ui_value)

                        webutils.flash(_('Added new hook'), category='success')

                    elif hook_id:

                        db.Ui.delete(hook_id)

                        meta.Session().commit()

                    # check for edits

                    update = False

                    _d = request.POST.dict_of_lists()

                    for k, v, ov in zip(_d.get('hook_ui_key', []),

                                        _d.get('hook_ui_value_new', []),

                                        _d.get('hook_ui_value', [])):

                        if v != ov:

                            db.Ui.create_or_update_hook(k, v)

                            update = True

                    if update:

                        webutils.flash(_('Updated hooks'), category='success')

                    meta.Session().commit()

                except Exception:

                    log.error(traceback.format_exc())

                    webutils.flash(_('Error occurred during hook creation'),

                            category='error')

                raise HTTPFound(location=url('admin_settings_hooks'))

        defaults = db.Setting.get_app_settings()

        defaults.update(self._get_hg_ui_settings())

        c.hooks = db.Ui.get_builtin_hooks()

        c.custom_hooks = db.Ui.get_custom_hooks()

        return htmlfill.render(

            base.render('admin/settings/settings.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    @HasPermissionAnyDecorator('hg.admin')

    def settings_search(self):

        c.active = 'search'

        if request.POST:

            repo_location = self._get_hg_ui_settings()['paths_root_path']

            full_index = request.POST.get('full_index', False)

            webutils.flash(_('Whoosh reindex task scheduled'), category='success')

            raise HTTPFound(location=url('admin_settings_search'))

        defaults = db.Setting.get_app_settings()

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

            base.render('admin/settings/settings.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    @HasPermissionAnyDecorator('hg.admin')

    def settings_system(self):

        c.active = 'system'

        defaults = db.Setting.get_app_settings()

        defaults.update(self._get_hg_ui_settings())

        c.ini = kallithea.CONFIG

        server_info = db.Setting.get_server_info()

        for key, val in server_info.items():

            setattr(c, key, val)

        return htmlfill.render(

            base.render('admin/settings/settings.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

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

"""

Kallithea wrapper of Celery

The Celery configuration is in the Kallithea ini file but must be converted to an

entirely different format before Celery can use it.

We read the configuration from tg.config at module import time. This module can

thus not be imported in global scope but must be imported on demand in function

scope after tg.config has been initialized.

To make sure that the config really has been initialized, we check one of the

mandatory settings.

"""

import logging

class CeleryConfig(object):

    task_always_eager = False

list_config_names = {'imports', 'accept_content'}

desupported = set([

    'broker.url',

    'celery.accept.content',

    'celery.always.eager',

    'celery.amqp.task.result.expires',

    'celeryd.concurrency',

    'celeryd.max.tasks.per.child',

    'celery.result.backend',  # Note: the .ini template used this instead of 'celery.result_backend' in 0.6

    'celery.result.dburi',

    'celery.result.serialier',

    'celery.result.serializer',

    'celery.send.task.error.emails',

    'celery.task_always_eager',  # still a valid configuration in celery, but not supported in Kallithea

    'celery.task.serializer',

])

log = logging.getLogger(__name__)

def make_celery_config(config):

    """Return Celery config object populated from relevant settings in a config dict, such as tg.config"""

    celery_config = CeleryConfig()

    for config_key, config_value in sorted(config.items()):

        if config_key in desupported and config_value:

            log.error('Celery configuration setting %r is no longer supported', config_key)

        parts = config_key.split('.', 1)

        if parts[0] == 'celery' and len(parts) == 2:  # Celery 4 config key

            celery_key = parts[1]

        else:

            continue

        if not isinstance(config_value, str):

            continue

        if celery_key in list_config_names:

            celery_value = config_value.split()

        elif config_value.isdigit():

            celery_value = int(config_value)

        elif config_value.lower() in ['true', 'false']:

            celery_value = config_value.lower() == 'true'

        else:

            celery_value = config_value

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

# 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/>.

"""

kallithea.lib.indexers.daemon

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

A daemon will read from task table and run tasks

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Jan 26, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import os

import traceback

from shutil import rmtree

from time import mktime

from whoosh.index import create_in, exists_in, open_dir

from whoosh.qparser import QueryParser

from kallithea.lib.conf import INDEX_EXTENSIONS, INDEX_FILENAMES

from kallithea.lib.indexers import CHGSET_IDX_NAME, CHGSETS_SCHEMA, IDX_NAME, SCHEMA

from kallithea.lib.utils2 import safe_str

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError, ChangesetError, NodeDoesNotExistError, RepositoryError

from kallithea.model import db

from kallithea.model.scm import ScmModel

log = logging.getLogger('whoosh_indexer')

class WhooshIndexingDaemon(object):

    """

    Daemon for atomic indexing jobs

    """

    def __init__(self, indexname=IDX_NAME, index_location=None,

                 repo_location=None, repo_list=None,

                 repo_update_list=None):

        self.indexname = indexname

        self.index_location = index_location

        if not index_location:

            raise Exception('You have to provide index location')

        self.repo_location = repo_location

        if not repo_location:

            raise Exception('You have to provide repositories location')

        self.repo_paths = ScmModel().repo_scan(self.repo_location)

        # filter repo list

        if repo_list:

            repo_list = set(repo_list)

            self.filtered_repo_paths = {}

            for repo_name, repo in self.repo_paths.items():

                if repo_name in repo_list:

                    self.filtered_repo_paths[repo_name] = repo

            self.repo_paths = self.filtered_repo_paths

        # filter update repo list

        self.filtered_repo_update_paths = {}

        if repo_update_list:

            self.filtered_repo_update_paths = {}

            for repo_name, repo in self.repo_paths.items():

                if repo_name in repo_update_list:

                    self.filtered_repo_update_paths[repo_name] = repo

                log.debug('>> COMMITING CHANGES TO FILE INDEX <<')

                writer.commit(merge=True)

                log.debug('>>> FINISHED REBUILDING FILE INDEX <<<')

            else:

                log.debug('>> NOTHING TO COMMIT TO FILE INDEX <<')

                writer.cancel()

    def build_indexes(self):

        if os.path.exists(self.index_location):

            log.debug('removing previous index')

            rmtree(self.index_location)

        if not os.path.exists(self.index_location):

            os.mkdir(self.index_location)

        chgset_idx = create_in(self.index_location, CHGSETS_SCHEMA,

                               indexname=CHGSET_IDX_NAME)

        chgset_idx_writer = chgset_idx.writer()

        file_idx = create_in(self.index_location, SCHEMA, indexname=IDX_NAME)

        file_idx_writer = file_idx.writer()

        log.debug('BUILDING INDEX FOR EXTENSIONS %s '

                  'AND REPOS %s', INDEX_EXTENSIONS, ' and '.join(self.repo_paths))

        for repo_name, repo in sorted(self.repo_paths.items()):

            log.debug('Updating indices for repo %s', repo_name)

            # skip indexing if there aren't any revisions

            if len(repo) < 1:

                continue

            self.index_files(file_idx_writer, repo_name, repo)

            self.index_changesets(chgset_idx_writer, repo_name, repo)

        log.debug('>> COMMITING CHANGES <<')

        file_idx_writer.commit(merge=True)

        chgset_idx_writer.commit(merge=True)

        log.debug('>>> FINISHED BUILDING INDEX <<<')

    def update_indexes(self):

        self.update_file_index()

        self.update_changeset_index()

    def run(self, full_index=False):

        """Run daemon"""

        if full_index or self.initial:

            self.build_indexes()

        else:

            self.update_indexes()

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

# 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/>.

"""

kallithea.model.async_tasks

~~~~~~~~~~~~~~~~~~~~~~~~~~~

Kallithea task modules, containing all task that suppose to be run

by celery daemon

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Oct 6, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import email.message

import email.utils

import os

import smtplib

import time

import traceback

from collections import OrderedDict

from operator import itemgetter

from time import mktime

import celery.utils.log

from tg import config

import kallithea

from kallithea.lib import celerylib, conf, ext_json, hooks

from kallithea.lib.utils2 import asbool, ascii_bytes

from kallithea.lib.vcs.utils import author_email, author_name

from kallithea.model import db, meta, repo, userlog

log = celery.utils.log.get_task_logger(__name__)

def _author_username(author):

    """Return the username of the user identified by the email part of the 'author' string,

    default to the name or email.

    Kind of similar to h.person() ."""

    email = author_email(author)

    if email:

        user = db.User.get_by_email(email)

        if user is not None:

            return user.username

    # Still nothing?  Just pass back the author name if any, else the email

    return author_name(author) or email

@celerylib.task

def get_commits_stats(repo_name, ts_min_y, ts_max_y, recurse_limit=100):

    lockkey = celerylib.__get_lockkey('get_commits_stats', repo_name, ts_min_y,

                            ts_max_y)

    log.info('running task with lockkey %s', lockkey)

    try:

        lock = celerylib.DaemonLock(os.path.join(config['cache_dir'], lockkey))

        co_day_auth_aggr = {}

        commits_by_day_aggregate = {}

        db_repo = db.Repository.get_by_repo_name(repo_name)

        if db_repo is None:

            return

        scm_repo = db_repo.scm_instance

        repo_size = scm_repo.count()

        # return if repo have no revisions

        if repo_size < 1:

            lock.release()

            return

        skip_date_limit = True

        parse_limit = int(config.get('commit_parse_limit'))

        last_rev = None

        last_cs = None

        timegetter = itemgetter('time')

        dbrepo = db.Repository.query() \

            .filter(db.Repository.repo_name == repo_name).scalar()

        cur_stats = db.Statistics.query() \

            .filter(db.Statistics.repository == dbrepo).scalar()

        if cur_stats is not None:

            last_rev = cur_stats.stat_on_revision

scripts

'''.split())

bottom_external_modules = set('''

tg

mercurial

sqlalchemy

alembic

formencode

pygments

dulwich

beaker

psycopg2

docs

setup

conftest

'''.split())

normal_modules = set('''

kallithea

kallithea.controllers.base

kallithea.lib

kallithea.lib.auth

kallithea.lib.auth_modules

kallithea.lib.celerylib

kallithea.lib.db_manage

kallithea.lib.helpers

kallithea.lib.hooks

kallithea.lib.indexers

kallithea.lib.utils

kallithea.lib.utils2

kallithea.lib.vcs

kallithea.lib.webutils

kallithea.model

kallithea.model.async_tasks

kallithea.model.scm

kallithea.templates.py

'''.split())

shown_modules = normal_modules | top_modules

# break the chains somehow - this is a cleanup TODO list

known_violations = set([

('kallithea.lib.auth_modules', 'kallithea.lib.auth'),  # needs base&facade

('kallithea.lib.utils', 'kallithea.model'),  # clean up utils

('kallithea.lib.utils', 'kallithea.model.db'),

('kallithea.lib.utils', 'kallithea.model.scm'),

('kallithea.model.async_tasks', 'kallithea.lib.hooks'),

('kallithea.model.async_tasks', 'kallithea.model'),

('kallithea.model', 'kallithea.lib.auth'),  # auth.HasXXX

('kallithea.model', 'kallithea.lib.auth_modules'),  # validators

('kallithea.model', 'kallithea.lib.hooks'),  # clean up hooks

('kallithea.model', 'kallithea.model.scm'),

('kallithea.model.scm', 'kallithea.lib.hooks'),

])

extra_edges = [

('kallithea.config', 'kallithea.controllers'),  # through TG

('kallithea.lib.auth', 'kallithea.lib.auth_modules'),  # custom loader

]

def normalize(s):

    """Given a string with dot path, return the string it should be shown as."""

    parts = s.replace('.__init__', '').split('.')

    short_2 = '.'.join(parts[:2])

    short_3 = '.'.join(parts[:3])

    short_4 = '.'.join(parts[:4])

    if parts[0] in ['scripts', 'contributor_data', 'i18n_utils']:

        return 'scripts'

    if short_3 == 'kallithea.model.meta':

        return 'kallithea.model.db'

    if parts[:4] == ['kallithea', 'lib', 'vcs', 'ssh']:

        return 'kallithea.lib.vcs.ssh'

    if short_4 in shown_modules:

        return short_4

    if short_3 in shown_modules:

        return short_3

    if short_2 in shown_modules:

        return short_2

    if short_2 == 'kallithea.tests':

        return None

    if parts[0] in ignored_modules:

        return None

    assert parts[0] in bottom_external_modules, parts

    return parts[0]

def main(filenames):

    if not filenames or filenames[0].startswith('-'):

        print('''\

Usage:

    hg files 'set:!binary()&grep("^#!.*python")' 'set:**.py' | xargs scripts/deps.py

    dot -Tsvg deps.dot > deps.svg

        ''')

        raise SystemExit(1)