## but if mostly spending CPU, try to keep it close to the

## number of CPUs on your machine. If not set, the number of CPUs/cores

## available will be used.

CELERYD_CONCURRENCY = 2

# CELERYD_LOG_FILE = "celeryd.log"

CELERYD_LOG_LEVEL = "DEBUG"

#Tasks will never be sent to the queue, but executed locally instead.

CELERY_ALWAYS_EAGER = False

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

# EMAIL SETTINGS

from pylons_app.lib.celerylib import run_task

from pylons_app.lib.celerylib.tasks import get_commits_stats

from datetime import datetime, timedelta

from time import mktime

import calendar

import logging

log = logging.getLogger(__name__)

class SummaryController(BaseController):

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

        ts_max_y = mktime((y, m, d, 0, 0, 0, 0, 0, 0,))

        run_task(get_commits_stats, c.repo_info.name, ts_min_y, ts_max_y)

        c.ts_min = ts_min_m

        c.ts_max = ts_max_y

        stats = self.sa.query(Statistics)\

            .filter(Statistics.repository == c.repo_info.dbrepo)\

            .scalar()

            c.commit_data = stats.commit_activity

            c.overview_data = stats.commit_activity_combined

        else:

            c.commit_data = json.dumps({})

            c.overview_data = json.dumps([[ts_min_y, 0], [ts_max_y, 0] ])

        return render('summary/summary.html')

        lockkey = 'task_%s' % \

            md5(str(func.__name__) + '-' + \

                '-'.join(map(str, params))).hexdigest()

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

        try:

            l = DaemonLock(lockkey)

            l.release()

        except LockHeld:

            log.info('LockHeld')

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

    return decorator(__wrapper, func)      

from celery.decorators import task

from celery.task.sets import subtask

from celeryconfig import PYLONS_CONFIG as config

from pylons.i18n.translation import _

from pylons_app.lib.celerylib import run_task, locked_task

from pylons_app.lib.helpers import person

from pylons_app.lib.smtp_mailer import SmtpMailer

from pylons_app.lib.utils import OrderedDict

from vcs.backends.hg import MercurialRepository

import traceback

__all__ = ['whoosh_index', 'get_commits_stats',

           'reset_user_password', 'send_email']

def get_session():

    from sqlalchemy import engine_from_config

    from pylons_app.lib.indexers.daemon import WhooshIndexingDaemon

    WhooshIndexingDaemon(repo_location=repo_location).run(full_index=full_index)

@task

@locked_task

def get_commits_stats(repo_name, ts_min_y, ts_max_y):

    author_key_cleaner = lambda k: person(k).replace('"', "") #for js data compatibilty

    commits_by_day_author_aggregate = {}

    commits_by_day_aggregate = {}

    repos_path = get_hg_ui_settings()['paths_root_path'].replace('*', '')

    repo = MercurialRepository(repos_path + repo_name)

    skip_date_limit = True

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

    cur_stats = sa.query(Statistics)\

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

    if cur_stats:

        last_rev = cur_stats.stat_on_revision

        #pass silently without any work

        return True

    if cur_stats:

        commits_by_day_aggregate = OrderedDict(

                                       json.loads(

                                        cur_stats.commit_activity_combined))

        commits_by_day_author_aggregate = json.loads(cur_stats.commit_activity)

    for cnt, rev in enumerate(repo.revisions[last_rev:]):

        last_cs = cs = repo.get_changeset(rev)

        k = '%s-%s-%s' % (cs.date.timetuple()[0], cs.date.timetuple()[1],

                          cs.date.timetuple()[2])

        timetupple = [int(x) for x in k.split('-')]

        timetupple.extend([0 for _ in xrange(6)])

            "schema":["commits"],

        }

    stats = cur_stats if cur_stats else Statistics()

    stats.commit_activity = json.dumps(commits_by_day_author_aggregate)

    stats.commit_activity_combined = json.dumps(overview_data)

    stats.repository = dbrepo

    stats.stat_on_revision = last_cs.revision

    try:

        sa.add(stats)

        sa.commit()    

    except:

        log.error(traceback.format_exc())

        sa.rollback()

        return False

    run_task(get_commits_stats, repo_name, ts_min_y, ts_max_y)

    return True

@task

def reset_user_password(user_email):

        m.send(recipients, subject, body)  

    except:

        log.error('Mail sending failed')

        log.error(traceback.format_exc())

        return False

    return True

import os, time

import sys

from warnings import warn

class LockHeld(Exception):pass

class DaemonLock(object):

    """daemon locking

        self.callbackfn = callbackfn

        self.desc = desc

        self.debug = debug

        self.held = False

        #run the lock automatically !

        self.lock()

    def lock(self):

        """locking function, if lock is present it will raise LockHeld exception

        """

        lockname = '%s' % (os.getpid())

        self.trylock()

        self.makelock(lockname, self.pidfile)

        return True

    def trylock(self):

        running_pid = False

        try:

            pidfile = open(self.pidfile, "r")

            pidfile.seek(0)

            if self.debug:

                print 'lock file present running_pid: %s, checking for execution'\

                % running_pid

            # Now we check the PID from lock file matches to the current

            # process PID

            if running_pid:

                        print "Lock File is there but the program is not running"

                        print "Removing lock file for the: %s" % running_pid

                        self.release()

        except IOError, e:

            if e.errno != 2:

                raise

    def release(self):

        """releases the pid by removing the pidfile

        """

        if self.callbackfn:

            #execute callback function on release

            if self.debug:

                print 'executing callback function %s' % self.callbackfn

            self.callbackfn()

        try:

}

/* -----------------------------------------------------------

	SUMMARY

----------------------------------------------------------- */

#clone_url{

	border: none;

}

/* -----------------------------------------------------------

    FILES

			      <input type="text" id="clone_url" readonly="readonly" value="hg clone ${c.clone_repo_url}" size="70"/>

			  </div>

			 </div>

			 <div class="field">

			  <div class="label">

			      <label>${_('Download')}:</label>

			  </div>

			  <div class="input-short">

		        %for cnt,archive in enumerate(c.repo_info._get_archives()):

		             %if cnt >=1:

		             |