from vcs.utils.lazy import LazyProperty

import logging

import os

import sys

import traceback

log = logging.getLogger(__name__)

class ResultWrapper(object):

    def __init__(self, task):

        self.task = task

def run_task(task, *args, **kwargs):

    try:

        t = task.delay(*args, **kwargs)

        log.info('running task %s', t.task_id)

        return t

    except Exception, e:

        if e.errno == 111:

            log.debug('Unnable to connect. Sync execution')

        else:

            log.error(traceback.format_exc())

        #pure sync version

        return ResultWrapper(task(*args, **kwargs))

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.helpers import person

from pylons_app.lib.smtp_mailer import SmtpMailer

from pylons_app.lib.utils import OrderedDict

from operator import itemgetter

from vcs.backends.hg import MercurialRepository

from time import mktime

    return settings   

@task

def whoosh_index(repo_location, full_index):

    log = whoosh_index.get_logger()

    from pylons_app.lib.indexers.daemon import WhooshIndexingDaemon, LockHeld

    try:

        l = DaemonLock()

        WhooshIndexingDaemon(repo_location=repo_location)\

            .run(full_index=full_index)

        l.release()

        return 'Done'

    except LockHeld:

        log.info('LockHeld')

        return 'LockHeld'    

@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

    from pylons_app.model.db import Statistics, Repository

    log = get_commits_stats.get_logger()

    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

    last_rev = 0

    last_cs = None

    timegetter = itemgetter('time')

    sa = get_session()

        sa.add(stats)

        sa.commit()    

    except:

        log.error(traceback.format_exc())

        sa.rollback()

        return False

    return True

@task

def reset_user_password(user_email):

    log = reset_user_password.get_logger()

    from pylons_app.lib import auth

from os.path import dirname as dn, join as jn

from pylons_app.config.environment import load_environment

from pylons_app.model.hg_model import HgModel

from shutil import rmtree

from webhelpers.html.builder import escape

from vcs.utils.lazy import LazyProperty

from os.path import join as jn

#to get the pylons_app import

project_path = dn(dn(dn(dn(os.path.realpath(__file__)))))

sys.path.append(project_path)

from pylons_app.model.hg_model import HgModel

from pylons_app.lib.helpers import safe_unicode

from whoosh.index import create_in, open_dir

from shutil import rmtree

from pylons_app.lib.indexers import INDEX_EXTENSIONS, IDX_LOCATION, SCHEMA, IDX_NAME

from warnings import warn

class LockHeld(Exception):pass

class DaemonLock(object):

    USAGE:

    try:

        l = lock()

        main()

        l.release()

    except LockHeld:

        sys.exit(1)

    def __init__(self, file=None, callbackfn=None,

                 desc='daemon lock', debug=False):

        self.pidfile = file if file else os.path.join(os.path.dirname(__file__),

                                                      'running.lock')

            # ensure the lock will be removed

            self.release()

    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

        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:

        except OSError, e:

            if self.debug:

                print 'removing pidfile failed %s' % e

            pass

    def makelock(self, lockname, pidfile):

        this function will make an actual lock

        @param lockname: acctual pid of file

        @param pidfile: the file to write the pid in

        if self.debug:

            print 'creating a file %s and pid: %s' % (pidfile, lockname)

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

        pidfile.write(lockname)

        pidfile.close

        self.held = True

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

def create_test_index(repo_location, full_index):

    """Makes default test index

    @param repo_location:

    @param full_index:

    """

    from pylons_app.lib.indexers.daemon import WhooshIndexingDaemon

    from pylons_app.lib.indexers import IDX_LOCATION

    import shutil

    if os.path.exists(IDX_LOCATION):

        shutil.rmtree(IDX_LOCATION)

		                 <th>${_('Mimetype')}</th>

		                 <th>${_('Revision')}</th>

		                 <th>${_('Last modified')}</th>

		                 <th>${_('Last commiter')}</th>

		             </tr>

		         </thead>

		    %for cnt,node in enumerate(c.files_list,1):

				<tr class="parity${cnt%2}">

		             <td>

						${h.link_to(node.name,h.url('files_home',repo_name=c.repo_name,revision=c.cur_rev,f_path=node.path),class_=file_class(node))}

		             </td>

		             <td>

		             </td>

		             <td>

		              %if node.is_file():

		                  ${node.mimetype}

		              %endif

		             </td>