pytest >= 4.6.6, < 5.5

pytest-sugar >= 0.9.2, < 0.10

pytest-benchmark >= 3.2.2, < 3.3

pytest-localserver >= 0.5.0, < 0.6

mock >= 3.0.0, < 4.1

Sphinx >= 1.8.0, < 3.1

WebTest >= 2.0.6, < 2.1

pyflakes == 2.2.0

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

"""

Global configuration file for TurboGears2 specific settings in Kallithea.

This file complements the .ini file.

"""

import logging

import os

import platform

import sys

import alembic.config

import mercurial

import tg

from alembic.migration import MigrationContext

from alembic.script.base import ScriptDirectory

from sqlalchemy import create_engine

from tg import FullStackApplicationConfigurator

import kallithea.lib.locale

import kallithea.model.base

import kallithea.model.meta

from kallithea.lib import celerypylons

from kallithea.lib.utils import check_git_version, load_rcextensions, set_app_settings, set_indexer_config, set_vcs_config

from kallithea.lib.utils2 import asbool

from kallithea.model import db

log = logging.getLogger(__name__)

base_config = FullStackApplicationConfigurator()

base_config.update_blueprint({

    'package': kallithea,

    # Rendering Engines Configuration

    'renderers': [

        'json',

        'mako',

    ],

    'default_renderer': 'mako',

    'use_dotted_templatenames': False,

    # Configure Sessions, store data as JSON to avoid pickle security issues

    'session.enabled': True,

    'session.data_serializer': 'json',

    # Configure the base SQLALchemy Setup

    'use_sqlalchemy': True,

    'model': kallithea.model.base,

    'DBSession': kallithea.model.meta.Session,

    # Configure App without an authentication backend.

    'auth_backend': None,

    # Use custom error page for these errors. By default, Turbogears2 does not add

    # 400 in this list.

    # Explicitly listing all is considered more robust than appending to defaults,

    # in light of possible future framework changes.

    'errorpage.status_codes': [400, 401, 403, 404],

    # Disable transaction manager -- currently Kallithea takes care of transactions itself

    'tm.enabled': False,

    # Set the default i18n source language so TG doesn't search beyond 'en' in Accept-Language.

    'i18n.lang': 'en',

})

# DebugBar, a debug toolbar for TurboGears2.

# (https://github.com/TurboGears/tgext.debugbar)

# To enable it, install 'tgext.debugbar' and 'kajiki', and run Kallithea with

# 'debug = true' (not in production!)

# See the Kallithea documentation for more information.

try:

    from tgext.debugbar import enable_debugbar

    assert kajiki

except ImportError:

    pass

else:

    base_config['renderers'].append('kajiki')

    enable_debugbar(base_config)

def setup_configuration(app):

    config = app.config

    if not kallithea.lib.locale.current_locale_is_valid():

        log.error("Terminating ...")

        sys.exit(1)

    # Mercurial sets encoding at module import time, so we have to monkey patch it

    hgencoding = config.get('hgencoding')

    if hgencoding:

        mercurial.encoding.encoding = hgencoding

    if config.get('ignore_alembic_revision', False):

        log.warning('database alembic revision checking is disabled')

    else:

        dbconf = config['sqlalchemy.url']

        alembic_cfg = alembic.config.Config()

        alembic_cfg.set_main_option('script_location', 'kallithea:alembic')

        alembic_cfg.set_main_option('sqlalchemy.url', dbconf)

        script_dir = ScriptDirectory.from_config(alembic_cfg)

        available_heads = sorted(script_dir.get_heads())

        engine = create_engine(dbconf)

        with engine.connect() as conn:

            context = MigrationContext.configure(conn)

            current_heads = sorted(str(s) for s in context.get_current_heads())

        if current_heads != available_heads:

            log.error('Failed to run Kallithea:\n\n'

                      'The database version does not match the Kallithea version.\n'

                      'Please read the documentation on how to upgrade or downgrade the database.\n'

                      'Current database version id(s): %s\n'

                      'Expected database version id(s): %s\n'

                      'If you are a developer and you know what you are doing, you can add `ignore_alembic_revision = True` '

                      'to your .ini file to skip the check.\n' % (' '.join(current_heads), ' '.join(available_heads)))

            sys.exit(1)

    # store some globals into kallithea

    kallithea.DEFAULT_USER_ID = db.User.get_default_user().user_id

    if asbool(config.get('use_celery')):

        kallithea.CELERY_APP = celerypylons.make_app()

    kallithea.CONFIG = config

    load_rcextensions(root_path=config['here'])

    set_app_settings(config)

    instance_id = kallithea.CONFIG.get('instance_id', '*')

    if instance_id == '*':

        instance_id = '%s-%s' % (platform.uname()[1], os.getpid())

        kallithea.CONFIG['instance_id'] = instance_id

    # update kallithea.CONFIG with the meanwhile changed 'config'

    kallithea.CONFIG.update(config)

    # configure vcs and indexer libraries (they are supposed to be independent

    # as much as possible and thus avoid importing tg.config or

    # kallithea.CONFIG).

    set_vcs_config(kallithea.CONFIG)

    set_indexer_config(kallithea.CONFIG)

    check_git_version()

    kallithea.model.meta.Session.remove()

tg.hooks.register('configure_new_app', setup_configuration)

# -*- 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.compare

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

compare controller showing differences between two

repos, branches, bookmarks or tips

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: May 6, 2012

:author: marcink

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

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

"""

import logging

import re

import mercurial.unionrepo

from tg import request

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPBadRequest, HTTPFound, HTTPNotFound

from kallithea.config.routing import url

from kallithea.lib import diffs

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController, render

from kallithea.lib.graphmod import graph_data

from kallithea.lib.utils2 import ascii_bytes, ascii_str, safe_bytes

from kallithea.model.db import Repository

log = logging.getLogger(__name__)

class CompareController(BaseRepoController):

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

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

        # The base repository has already been retrieved.

        c.a_repo = c.db_repo

        # Retrieve the "changeset" repository (default: same as base).

        other_repo = request.GET.get('other_repo', None)

        if other_repo is None:

            c.cs_repo = c.a_repo

        else:

            c.cs_repo = Repository.get_by_repo_name(other_repo)

            if c.cs_repo is None:

                msg = _('Could not find other repository %s') % other_repo

                h.flash(msg, category='error')

                raise HTTPFound(location=url('compare_home', repo_name=c.a_repo.repo_name))

        # Verify that it's even possible to compare these two repositories.

        if c.a_repo.scm_instance.alias != c.cs_repo.scm_instance.alias:

            msg = _('Cannot compare repositories of different types')

            h.flash(msg, category='error')

            raise HTTPFound(location=url('compare_home', repo_name=c.a_repo.repo_name))

    @staticmethod

    def _get_changesets(alias, org_repo, org_rev, other_repo, other_rev):

        """

        Returns lists of changesets that can be merged from org_repo@org_rev

        to other_repo@other_rev

        ... and the other way

        ... and the ancestors that would be used for merge

        :param org_repo: repo object, that is most likely the original repo we forked from

        :param org_rev: the revision we want our compare to be made

        :param other_repo: repo object, most likely the fork of org_repo. It has

            all changesets that we need to obtain

        :param other_rev: revision we want out compare to be made on other_repo

        """

        ancestors = None

        if org_rev == other_rev:

            org_changesets = []

            other_changesets = []

        elif alias == 'hg':

            # case two independent repos

            if org_repo != other_repo:

                hgrepo = mercurial.unionrepo.makeunionrepository(other_repo.baseui,

                                                       safe_bytes(other_repo.path),

                                                       safe_bytes(org_repo.path))

                # all ancestors of other_rev will be in other_repo and

                # rev numbers from hgrepo can be used in other_repo - org_rev ancestors cannot

            # no remote compare do it on the same repository

            else:

                hgrepo = other_repo._repo

            ancestors = [ascii_str(hgrepo[ancestor].hex()) for ancestor in

                         hgrepo.revs(b"id(%s) & ::id(%s)", ascii_bytes(other_rev), ascii_bytes(org_rev))]

            if ancestors:

                log.debug("shortcut found: %s is already an ancestor of %s", other_rev, org_rev)

            else:

                log.debug("no shortcut found: %s is not an ancestor of %s", other_rev, org_rev)

                ancestors = [ascii_str(hgrepo[ancestor].hex()) for ancestor in

                             hgrepo.revs(b"heads(::id(%s) & ::id(%s))", ascii_bytes(org_rev), ascii_bytes(other_rev))] # FIXME: expensive!

            other_changesets = [

                other_repo.get_changeset(rev)

                for rev in hgrepo.revs(

                    b"ancestors(id(%s)) and not ancestors(id(%s)) and not id(%s)",

                    ascii_bytes(other_rev), ascii_bytes(org_rev), ascii_bytes(org_rev))

            ]

            org_changesets = [

                org_repo.get_changeset(ascii_str(hgrepo[rev].hex()))

                for rev in hgrepo.revs(

                    b"ancestors(id(%s)) and not ancestors(id(%s)) and not id(%s)",

                    ascii_bytes(org_rev), ascii_bytes(other_rev), ascii_bytes(other_rev))

            ]

        elif alias == 'git':

            if org_repo != other_repo:

                from dulwich.repo import Repo

                gitrepo = Repo(org_repo.path)

                SubprocessGitClient(thin_packs=False).fetch(other_repo.path, gitrepo)

                gitrepo_remote = Repo(other_repo.path)

                SubprocessGitClient(thin_packs=False).fetch(org_repo.path, gitrepo_remote)

                revs = [

                    ascii_str(x.commit.id)

                    for x in gitrepo_remote.get_walker(include=[ascii_bytes(other_rev)],

                                                       exclude=[ascii_bytes(org_rev)])

                ]

                other_changesets = [other_repo.get_changeset(rev) for rev in reversed(revs)]

                if other_changesets:

                    ancestors = [other_changesets[0].parents[0].raw_id]

                else:

                    # no changesets from other repo, ancestor is the other_rev

                    ancestors = [other_rev]

                gitrepo.close()

                gitrepo_remote.close()

            else:

                so = org_repo.run_git_command(

                    ['log', '--reverse', '--pretty=format:%H',

                     '-s', '%s..%s' % (org_rev, other_rev)]

                )

                other_changesets = [org_repo.get_changeset(cs)

                              for cs in re.findall(r'[0-9a-fA-F]{40}', so)]

                so = org_repo.run_git_command(

                    ['merge-base', org_rev, other_rev]

                )

                ancestors = [re.findall(r'[0-9a-fA-F]{40}', so)[0]]

            org_changesets = []

        else:

            raise Exception('Bad alias only git and hg is allowed')

        return other_changesets, org_changesets, ancestors

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def index(self, repo_name):

        c.compare_home = True

        c.a_ref_name = c.cs_ref_name = None

        return render('compare/compare_diff.html')

    @LoginRequired(allow_default_user=True)

    @HasRepoPermissionLevelDecorator('read')

    def compare(self, repo_name, org_ref_type, org_ref_name, other_ref_type, other_ref_name):

        org_ref_name = org_ref_name.strip()

        other_ref_name = other_ref_name.strip()

        # If merge is True:

        #   Show what org would get if merged with other:

        #   List changesets that are ancestors of other but not of org.

        #   New changesets in org is thus ignored.

        #   Diff will be from common ancestor, and merges of org to other will thus be ignored.

        # If merge is False:

        #   Make a raw diff from org to other, no matter if related or not.

        #   Changesets in one and not in the other will be ignored

        merge = bool(request.GET.get('merge'))

        # fulldiff disables cut_off_limit

        fulldiff = request.GET.get('fulldiff')

        # partial uses compare_cs.html template directly

        partial = request.environ.get('HTTP_X_PARTIAL_XHR')

        # is_ajax_preview puts hidden input field with changeset revisions

        c.is_ajax_preview = partial and request.GET.get('is_ajax_preview')

        # swap url for compare_diff page - never partial and never is_ajax_preview

        c.swap_url = h.url('compare_url',

            repo_name=c.cs_repo.repo_name,

            org_ref_type=other_ref_type, org_ref_name=other_ref_name,

            other_repo=c.a_repo.repo_name,

            other_ref_type=org_ref_type, other_ref_name=org_ref_name,

            merge=merge or '')

        ignore_whitespace_diff = h.get_ignore_whitespace_diff(request.GET)

        diff_context_size = h.get_diff_context_size(request.GET)

        c.a_rev = self._get_ref_rev(c.a_repo, org_ref_type, org_ref_name,

            returnempty=True)

        c.cs_rev = self._get_ref_rev(c.cs_repo, other_ref_type, other_ref_name)

        c.compare_home = False

        c.a_ref_name = org_ref_name

        c.a_ref_type = org_ref_type

        c.cs_ref_name = other_ref_name

        c.cs_ref_type = other_ref_type

        c.cs_ranges, c.cs_ranges_org, c.ancestors = self._get_changesets(

            c.a_repo.scm_instance.alias, c.a_repo.scm_instance, c.a_rev,

            c.cs_repo.scm_instance, c.cs_rev)

        raw_ids = [x.raw_id for x in c.cs_ranges]

        c.cs_comments = c.cs_repo.get_comments(raw_ids)

        c.cs_statuses = c.cs_repo.statuses(raw_ids)

        revs = [ctx.revision for ctx in reversed(c.cs_ranges)]

        c.jsdata = graph_data(c.cs_repo.scm_instance, revs)

        if partial:

            return render('compare/compare_cs.html')

        org_repo = c.a_repo

        other_repo = c.cs_repo

        if merge:

            rev1 = msg = None

            if not c.cs_ranges:

                msg = _('Cannot show empty diff')

            elif not c.ancestors:

                msg = _('No ancestor found for merge diff')

            elif len(c.ancestors) == 1:

                rev1 = c.ancestors[0]

            else:

                msg = _('Multiple merge ancestors found for merge compare')

            if rev1 is None:

                h.flash(msg, category='error')

                log.error(msg)

                raise HTTPNotFound

            # case we want a simple diff without incoming changesets,

            # previewing what will be merged.

            # Make the diff on the other repo (which is known to have other_rev)

            log.debug('Using ancestor %s as rev1 instead of %s',

                      rev1, c.a_rev)

            org_repo = other_repo

        else: # comparing tips, not necessarily linearly related

            if org_repo != other_repo:

                # TODO: we could do this by using hg unionrepo

                log.error('cannot compare across repos %s and %s', org_repo, other_repo)

                h.flash(_('Cannot compare repositories without using common ancestor'), category='error')

                raise HTTPBadRequest

            rev1 = c.a_rev

        diff_limit = None if fulldiff else self.cut_off_limit

        log.debug('running diff between %s and %s in %s',

                  rev1, c.cs_rev, org_repo.scm_instance.path)

        raw_diff = diffs.get_diff(org_repo.scm_instance, rev1=rev1, rev2=c.cs_rev,

                                      ignore_whitespace=ignore_whitespace_diff,

                                      context=diff_context_size)

        diff_processor = diffs.DiffProcessor(raw_diff, diff_limit=diff_limit)

        c.limited_diff = diff_processor.limited_diff

        c.file_diff_data = []

        c.lines_added = 0

        c.lines_deleted = 0

        for f in diff_processor.parsed:

            st = f['stats']

            c.lines_added += st['added']

            c.lines_deleted += st['deleted']

            filename = f['filename']

            fid = h.FID('', filename)

            html_diff = diffs.as_html(enable_comments=False, parsed_lines=[f])

            c.file_diff_data.append((fid, None, f['operation'], f['old_filename'], filename, html_diff, st))

        return render('compare/compare_diff.html')

# -*- 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.celerylib.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.utils

import os

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, ext_json

from kallithea.lib.helpers import person

from kallithea.lib.hooks import log_create_repository

from kallithea.lib.rcmail.smtp_mailer import SmtpMailer

from kallithea.lib.utils import action_logger

from kallithea.lib.utils2 import asbool, ascii_bytes

from kallithea.lib.vcs.utils import author_email

from kallithea.model.db import RepoGroup, Repository, Statistics, User

__all__ = ['whoosh_index', 'get_commits_stats', 'send_email']

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

@celerylib.task

@celerylib.locked_task

@celerylib.dbsession

def whoosh_index(repo_location, full_index):

    from kallithea.lib.indexers.daemon import WhooshIndexingDaemon

    celerylib.get_session() # initialize database connection

    index_location = config['index_dir']

    WhooshIndexingDaemon(index_location=index_location,

                         repo_location=repo_location) \

                         .run(full_index=full_index)

# for js data compatibility cleans the key for person from '

def akc(k):

    return person(k).replace('"', '')

@celerylib.task

@celerylib.dbsession

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

    DBS = celerylib.get_session()

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

                            ts_max_y)

    lockkey_path = config.get('cache_dir') or config['app_conf']['cache_dir']  # Backward compatibility for TurboGears < 2.4

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

    try:

        lock = celerylib.DaemonLock(os.path.join(lockkey_path, lockkey))

        co_day_auth_aggr = {}

        commits_by_day_aggregate = {}

        repo = Repository.get_by_repo_name(repo_name)

        if repo is None:

            return True

        repo = repo.scm_instance

        repo_size = repo.count()

        # return if repo have no revisions

        if repo_size < 1:

            lock.release()

            return True

        skip_date_limit = True

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

        last_rev = None

        last_cs = None

        timegetter = itemgetter('time')

        dbrepo = DBS.query(Repository) \

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

        cur_stats = DBS.query(Statistics) \

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

        if cur_stats is not None:

            last_rev = cur_stats.stat_on_revision

        if last_rev == repo.get_changeset().revision and repo_size > 1:

            # pass silently without any work if we're not on first revision or

            # current state of parsing revision(from db marker) is the

            # last revision

            lock.release()

            return True

        if cur_stats:

            commits_by_day_aggregate = OrderedDict(ext_json.loads(

                                        cur_stats.commit_activity_combined))

            co_day_auth_aggr = ext_json.loads(cur_stats.commit_activity)

        log.debug('starting parsing %s', parse_limit)

        last_rev = last_rev + 1 if last_rev and last_rev >= 0 else 0

        log.debug('Getting revisions from %s to %s',

             last_rev, last_rev + parse_limit

        )

        for cs in repo[last_rev:last_rev + parse_limit]:

            log.debug('parsing %s', cs)

            last_cs = cs  # remember last parsed changeset

            tt = cs.date.timetuple()

            k = mktime(tt[:3] + (0, 0, 0, 0, 0, 0))

            if akc(cs.author) in co_day_auth_aggr:

                try:

                    l = [timegetter(x) for x in

                         co_day_auth_aggr[akc(cs.author)]['data']]

                    time_pos = l.index(k)

                except ValueError:

                    time_pos = None

                if time_pos is not None and time_pos >= 0:

                    datadict = \

                        co_day_auth_aggr[akc(cs.author)]['data'][time_pos]

                    datadict["commits"] += 1

                    datadict["added"] += len(cs.added)

                    datadict["changed"] += len(cs.changed)

                    datadict["removed"] += len(cs.removed)

                else:

                    if k >= ts_min_y and k <= ts_max_y or skip_date_limit:

                        datadict = {"time": k,

                                    "commits": 1,

                                    "added": len(cs.added),

                                    "changed": len(cs.changed),

                                    "removed": len(cs.removed),

                                   }

                        co_day_auth_aggr[akc(cs.author)]['data'] \

                            .append(datadict)

            else:

                if k >= ts_min_y and k <= ts_max_y or skip_date_limit:

                    co_day_auth_aggr[akc(cs.author)] = {

                                        "label": akc(cs.author),

                                        "data": [{"time": k,

                                                 "commits": 1,

                                                 "added": len(cs.added),

                                                 "changed": len(cs.changed),

                                                 "removed": len(cs.removed),

                                                 }],

                                        "schema": ["commits"],

                                        }

            # gather all data by day

            if k in commits_by_day_aggregate:

                commits_by_day_aggregate[k] += 1

            else:

                commits_by_day_aggregate[k] = 1

        overview_data = sorted(commits_by_day_aggregate.items(),

                               key=itemgetter(0))

        if not co_day_auth_aggr:

            co_day_auth_aggr[akc(repo.contact)] = {

                "label": akc(repo.contact),

                "data": [0, 1],

                "schema": ["commits"],

            }

        stats = cur_stats if cur_stats else Statistics()

        stats.commit_activity = ascii_bytes(ext_json.dumps(co_day_auth_aggr))

        stats.commit_activity_combined = ascii_bytes(ext_json.dumps(overview_data))

        log.debug('last revision %s', last_rev)

        leftovers = len(repo.revisions[last_rev:])

        log.debug('revisions to parse %s', leftovers)

        if last_rev == 0 or leftovers < parse_limit:

            log.debug('getting code trending stats')

            stats.languages = ascii_bytes(ext_json.dumps(__get_codes_stats(repo_name)))

        try:

            stats.repository = dbrepo

            stats.stat_on_revision = last_cs.revision if last_cs else 0

            DBS.add(stats)

            DBS.commit()

        except:

            log.error(traceback.format_exc())

            DBS.rollback()

            lock.release()

            return False

        # final release

        lock.release()

        # execute another task if celery is enabled

        if len(repo.revisions) > 1 and kallithea.CELERY_APP and recurse_limit > 0:

            get_commits_stats(repo_name, ts_min_y, ts_max_y, recurse_limit - 1)

        elif recurse_limit <= 0:

            log.debug('Not recursing - limit has been reached')

        else:

            log.debug('Not recursing')

    except celerylib.LockHeld:

        log.info('Task with key %s already running', lockkey)

        return 'Task with key %s already running' % lockkey

@celerylib.task

@celerylib.dbsession

def send_email(recipients, subject, body='', html_body='', headers=None, from_name=None):

    """

    Sends an email with defined parameters from the .ini files.

    :param recipients: list of recipients, if this is None, the defined email

        address from field 'email_to' and all admins is used instead

    :param subject: subject of the mail

    :param body: body of the mail

    :param html_body: html version of body

    :param headers: dictionary of prepopulated e-mail headers

    :param from_name: full name to be used as sender of this mail - often a

    .full_name_or_username value

    """

    assert isinstance(recipients, list), recipients

    if headers is None:

        headers = {}

    else:

        # do not modify the original headers object passed by the caller

        headers = headers.copy()

    email_config = config

    email_prefix = email_config.get('email_prefix', '')

    if email_prefix:

        subject = "%s %s" % (email_prefix, subject)

    if not recipients:

        # if recipients are not defined we send to email_config + all admins

        recipients = [u.email for u in User.query()

                      .filter(User.admin == True).all()]

        if email_config.get('email_to') is not None:

            recipients += email_config.get('email_to').split(',')

        # If there are still no recipients, there are no admins and no address

        # configured in email_to, so return.

        if not recipients:

            log.error("No recipients specified and no fallback available.")

            return False

        log.warning("No recipients specified for '%s' - sending to admins %s", subject, ' '.join(recipients))

    # SMTP sender

    envelope_from = email_config.get('app_email_from', 'Kallithea')

    # 'From' header

    if from_name is not None:

        # set From header based on from_name but with a generic e-mail address

        # In case app_email_from is in "Some Name <e-mail>" format, we first

        # extract the e-mail address.

        envelope_addr = author_email(envelope_from)

        headers['From'] = '"%s" <%s>' % (

            email.utils.quote('%s (no-reply)' % from_name),

            envelope_addr)

    user = email_config.get('smtp_username')

    passwd = email_config.get('smtp_password')

    mail_server = email_config.get('smtp_server')

    mail_port = email_config.get('smtp_port')

    tls = asbool(email_config.get('smtp_use_tls'))

    ssl = asbool(email_config.get('smtp_use_ssl'))

    debug = asbool(email_config.get('debug'))

    smtp_auth = email_config.get('smtp_auth')

    logmsg = ("Mail details:\n"

              "recipients: %s\n"

              "headers: %s\n"

              "subject: %s\n"

              "body:\n%s\n"

              "html:\n%s\n"

              % (' '.join(recipients), headers, subject, body, html_body))

    if mail_server:

        log.debug("Sending e-mail. " + logmsg)

    else:

        log.error("SMTP mail server not configured - cannot send e-mail.")

        log.warning(logmsg)

        return False

    try:

        m = SmtpMailer(envelope_from, user, passwd, mail_server, smtp_auth,

                       mail_port, ssl, tls, debug=debug)

        m.send(recipients, subject, body, html_body, headers=headers)

    except:

        log.error('Mail sending failed')

        log.error(traceback.format_exc())

        return False

    return True

@celerylib.task

@celerylib.dbsession

def create_repo(form_data, cur_user):

    from kallithea.model.repo import RepoModel

    DBS = celerylib.get_session()

    cur_user = User.guess_instance(cur_user)

    owner = cur_user

    repo_name = form_data['repo_name']

    repo_name_full = form_data['repo_name_full']

    repo_type = form_data['repo_type']

    description = form_data['repo_description']

    private = form_data['repo_private']

    clone_uri = form_data.get('clone_uri')

    repo_group = form_data['repo_group']

    landing_rev = form_data['repo_landing_rev']

    copy_fork_permissions = form_data.get('copy_permissions')

    copy_group_permissions = form_data.get('repo_copy_permissions')

    fork_of = form_data.get('fork_parent_id')

    state = form_data.get('repo_state', Repository.STATE_PENDING)

    # repo creation defaults, private and repo_type are filled in form

    defs = Setting.get_default_repo_settings(strip_prefix=True)

    enable_statistics = defs.get('repo_enable_statistics')

    enable_downloads = defs.get('repo_enable_downloads')

    try:

        repo = RepoModel()._create_repo(

            repo_name=repo_name_full,

            repo_type=repo_type,

            description=description,

            owner=owner,

            private=private,

            clone_uri=clone_uri,

            repo_group=repo_group,

            landing_rev=landing_rev,

            fork_of=fork_of,

            copy_fork_permissions=copy_fork_permissions,

            copy_group_permissions=copy_group_permissions,

            enable_statistics=enable_statistics,

            enable_downloads=enable_downloads,

            state=state

        )

        action_logger(cur_user, 'user_created_repo',

                      form_data['repo_name_full'], '')

        DBS.commit()

        # now create this repo on Filesystem

        RepoModel()._create_filesystem_repo(

            repo_name=repo_name,

            repo_type=repo_type,

            repo_group=RepoGroup.guess_instance(repo_group),

            clone_uri=clone_uri,

        )

        repo = Repository.get_by_repo_name(repo_name_full)

        log_create_repository(repo.get_dict(), created_by=owner.username)

        # update repo changeset caches initially

        repo.update_changeset_cache()

        # set new created state

        repo.set_state(Repository.STATE_CREATED)

        DBS.commit()

    except Exception as e:

        log.warning('Exception %s occurred when forking repository, '