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

import celery.bin.worker

import click

import kallithea

import kallithea.bin.kallithea_cli_base as cli_base

@cli_base.register_command(config_file_initialize_app=True)

@click.argument('celery_args', nargs=-1)

def celery_run(celery_args):

    """Start Celery worker(s) for asynchronous tasks.

    This commands starts the Celery daemon which will spawn workers to handle

    certain asynchronous tasks for Kallithea.

    Any extra arguments you pass to this command will be passed through to

    Celery. Use '--' before such extra arguments to avoid options to be parsed

    by this CLI command.

    """

        raise Exception('Please set use_celery = true in .ini config '

                        'file before running this command')

    cmd = celery.bin.worker.worker(kallithea.CELERY_APP)

    return cmd.run_from_argv(None, command='celery-run -c CONFIG_FILE --', argv=list(celery_args))

"""

import logging

import os

from hashlib import sha1

from decorator import decorator

from tg import config

import kallithea

from kallithea.lib.pidlock import DaemonLock, LockHeld

from kallithea.model import meta

log = logging.getLogger(__name__)

def task(f_org):

    """Wrapper of celery.task.task, running async if CELERY_APP

    """

        def f_async(*args, **kwargs):

            log.info('executing %s task', f_org.__name__)

            try:

                f_org(*args, **kwargs)

            finally:

                meta.Session.remove()  # prevent reuse of auto created db sessions

                log.info('executed %s task', f_org.__name__)

        runner = kallithea.CELERY_APP.task(name=f_org.__name__, ignore_result=True)(f_async)

        def f_wrapped(*args, **kwargs):

            t = runner.apply_async(args=args, kwargs=kwargs)

            log.info('executing task %s in async mode - id %s', f_org, t.task_id)

            meta.Session().add(stats)

            meta.Session().commit()

        except:

            log.error(traceback.format_exc())

            meta.Session().rollback()

            lock.release()

            return

        # final release

        lock.release()

        # execute another task if celery is enabled

            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)

@celerylib.task

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

    """