# List of modules to import when celery starts.

import sys

import os

import ConfigParser

root = os.getcwd()

PYLONS_CONFIG_NAME = 'development.ini'

sys.path.append(root)

config = ConfigParser.ConfigParser({'here':root})

config.read('%s/%s' % (root, PYLONS_CONFIG_NAME))

PYLONS_CONFIG = config

CELERY_IMPORTS = ("pylons_app.lib.celerylib.tasks",)

## Result store settings.

CELERY_RESULT_BACKEND = "database"

CELERY_RESULT_DBURI = dict(config.items('app:main'))['sqlalchemy.db1.url']

CELERY_RESULT_SERIALIZER = 'json'

BROKER_CONNECTION_MAX_RETRIES = 30

## Broker settings.

BROKER_HOST = "localhost"

BROKER_PORT = 5672

BROKER_VHOST = "rabbitmqhost"

BROKER_USER = "rabbitmq"

BROKER_PASSWORD = "qweqwe"

## Worker settings

## If you're doing mostly I/O you can have more processes,

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

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

pylons_email_config = dict(config.items('DEFAULT'))

CELERY_SEND_TASK_ERROR_EMAILS = True

#List of (name, email_address) tuples for the admins that should receive error e-mails.

ADMINS = [('Administrator', pylons_email_config.get('email_to'))]

#The e-mail address this worker sends e-mails from. Default is "celery@localhost".

SERVER_EMAIL = pylons_email_config.get('error_email_from')

#The mail server to use. Default is "localhost".

MAIL_HOST = pylons_email_config.get('smtp_server')

#Username (if required) to log on to the mail server with.

MAIL_HOST_USER = pylons_email_config.get('smtp_username')

#Password (if required) to log on to the mail server with.

MAIL_HOST_PASSWORD = pylons_email_config.get('smtp_password')

MAIL_PORT = pylons_email_config.get('smtp_port')

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

# INSTRUCTIONS FOR RABBITMQ

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

# rabbitmqctl add_user rabbitmq qweqwe

# rabbitmqctl add_vhost rabbitmqhost

# rabbitmqctl set_permissions -p rabbitmqhost rabbitmq ".*" ".*" ".*"

#!/usr/bin/env python

# encoding: utf-8

# summary controller for pylons

# Copyright (C) 2009-2010 Marcin Kuzminski <marcin@python-works.com>

# 

# 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; version 2

# of the License or (at your opinion) any later version of the license.

# 

# 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, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.

"""

Created on April 18, 2010

summary controller for pylons

@author: marcink

"""

from pylons import tmpl_context as c, request, url

from pylons_app.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from pylons_app.lib.base import BaseController, render

from pylons_app.lib.utils import OrderedDict

from pylons_app.model.hg_model import HgModel

from pylons_app.model.db import Statistics

from webhelpers.paginate import Page

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

                                   'repository.admin')           

    def __before__(self):

        super(SummaryController, self).__before__()

    def index(self):

        hg_model = HgModel()

        c.repo_info = hg_model.get_repo(c.repo_name)

        c.repo_changesets = Page(list(c.repo_info[:10]), page=1, items_per_page=20)

        e = request.environ

        uri = u'%(protocol)s://%(user)s@%(host)s/%(repo_name)s' % {

                                        'protocol': e.get('wsgi.url_scheme'),

                                        'user':str(c.hg_app_user.username),

                                        'host':e.get('HTTP_HOST'),

                                        'repo_name':c.repo_name, }

        c.clone_repo_url = uri

        c.repo_tags = OrderedDict()

        for name, hash in c.repo_info.tags.items()[:10]:

            c.repo_tags[name] = c.repo_info.get_changeset(hash)

        c.repo_branches = OrderedDict()

        for name, hash in c.repo_info.branches.items()[:10]:

            c.repo_branches[name] = c.repo_info.get_changeset(hash)

        td = datetime.today() + timedelta(days=1) 

        y, m, d = td.year, td.month, td.day

        ts_min_y = mktime((y - 1, (td - timedelta(days=calendar.mdays[m])).month,

                            d, 0, 0, 0, 0, 0, 0,))

        ts_min_m = mktime((y, (td - timedelta(days=calendar.mdays[m])).month,

                            d, 0, 0, 0, 0, 0, 0,))

        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')

from pylons_app.lib.pidlock import DaemonLock, LockHeld

from vcs.utils.lazy import LazyProperty

from decorator import decorator

import logging

import os

import sys

import traceback

from hashlib import md5

log = logging.getLogger(__name__)

class ResultWrapper(object):

    def __init__(self, task):

        self.task = task

    @LazyProperty

    def result(self):

        return self.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:

        print 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))

def locked_task(func):

    def __wrapper(func, *fargs, **fkwargs):

        params = list(fargs)

        params.extend(['%s-%s' % ar for ar in fkwargs.items()])

        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 sqlalchemy.orm import sessionmaker, scoped_session

    engine = engine_from_config(dict(config.items('app:main')), 'sqlalchemy.db1.')

    sa = scoped_session(sessionmaker(bind=engine))

    return sa

def get_hg_settings():

    from pylons_app.model.db import HgAppSettings

    try:

        sa = get_session()

        ret = sa.query(HgAppSettings).all()

    finally:

        sa.remove()

    if not ret:

        raise Exception('Could not get application settings !')

    settings = {}

    for each in ret:

        settings['hg_app_' + each.app_settings_name] = each.app_settings_value    

    return settings

def get_hg_ui_settings():

    from pylons_app.model.db import HgAppUi

    try:

        sa = get_session()

        ret = sa.query(HgAppUi).all()

    finally:

        sa.remove()

    if not ret:

        raise Exception('Could not get application ui settings !')

    settings = {}

    for each in ret:

        k = each.ui_key

        v = each.ui_value

        if k == '/':

            k = 'root_path'

        if k.find('.') != -1:

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

        if each.ui_section == 'hooks':

            v = each.ui_active

        settings[each.ui_section + '_' + k] = v  

    return settings   

@task

@locked_task

def whoosh_index(repo_location, full_index):

    log = whoosh_index.get_logger()

    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):

    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

    parse_limit = 350 #limit for single task changeset parsing

    last_rev = 0

    last_cs = None

    timegetter = itemgetter('time')

    sa = get_session()

    dbrepo = sa.query(Repository)\

        .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)])

        k = mktime(timetupple)

        if commits_by_day_author_aggregate.has_key(author_key_cleaner(cs.author)):

            try:

                l = [timegetter(x) for x in commits_by_day_author_aggregate\

                        [author_key_cleaner(cs.author)]['data']]

                time_pos = l.index(k)

            except ValueError:

                time_pos = False

            if time_pos >= 0 and time_pos is not False:

                datadict = commits_by_day_author_aggregate\

                    [author_key_cleaner(cs.author)]['data'][time_pos]

                datadict["commits"] += 1

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

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

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

                #print datadict

            else:

                #print '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),

                               }

                    commits_by_day_author_aggregate\

                        [author_key_cleaner(cs.author)]['data'].append(datadict)

        else:

            #print k, 'nokey ADDING'

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

                commits_by_day_author_aggregate[author_key_cleaner(cs.author)] = {

                                    "label":author_key_cleaner(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 commits_by_day_aggregate.has_key(k):

            commits_by_day_aggregate[k] += 1

        else:

            commits_by_day_aggregate[k] = 1

        if cnt >= parse_limit:

            #don't fetch to much data since we can freeze application

            break

    overview_data = []

    for k, v in commits_by_day_aggregate.items():

        overview_data.append([k, v])

    overview_data = sorted(overview_data, key=itemgetter(0))

    if not commits_by_day_author_aggregate:

        commits_by_day_author_aggregate[author_key_cleaner(repo.contact)] = {

            "label":author_key_cleaner(repo.contact),

            "data":[0, 1],

            "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

    return True

@task

def reset_user_password(user_email):

    log = reset_user_password.get_logger()

    from pylons_app.lib import auth

    from pylons_app.model.db import User

    try:

        try:

            sa = get_session()

            user = sa.query(User).filter(User.email == user_email).scalar()

            new_passwd = auth.PasswordGenerator().gen_password(8,

                             auth.PasswordGenerator.ALPHABETS_BIG_SMALL)

            if user:

                user.password = auth.get_crypt_password(new_passwd)

                sa.add(user)

                sa.commit()

                log.info('change password for %s', user_email)

            if new_passwd is None:

                raise Exception('unable to generate new password')

        except:

            log.error(traceback.format_exc())

            sa.rollback()

        run_task(send_email, user_email,

                 "Your new hg-app password",

                 'Your new hg-app password:%s' % (new_passwd))

        log.info('send new password mail to %s', user_email)

    except:

        log.error('Failed to update user password')

        log.error(traceback.format_exc())

    return True

@task    

def send_email(recipients, subject, body):

    log = send_email.get_logger()

    email_config = dict(config.items('DEFAULT')) 

    mail_from = email_config.get('app_email_from')

    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 = email_config.get('smtp_use_tls')

    ssl = False

    try:

        m = SmtpMailer(mail_from, user, passwd, mail_server,

                       mail_port, ssl, tls)

        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

    USAGE:

    try:

        l = DaemonLock(desc='test 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')

        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:

                else:

        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:

            if self.debug:

                print 'removing pidfile %s' % self.pidfile

            os.remove(self.pidfile)

            self.held = False

        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

#register div.inner

{

    margin: 0 auto;

    padding: 20px;

    width: 380px;

	background: #FFFFFF;

    border-top: none;

    border-bottom: none;

}

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

	register -> form

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

#register div.form

{

    margin: 0;

    padding: 0;

    clear: both;

    overflow: hidden;

}

#register div.form div.fields

{

	margin: 0;

	padding: 0;

    clear: both;

    overflow: hidden;

}

#register div.form div.fields div.field

{

	margin: 0;

	padding: 0 0 10px 0; 

	clear: both;

	overflow: hidden;

}

#register div.form div.fields div.field span.error-message

{

	margin: 8px 0 0 0;

	padding: 0;

	height: 1%;

	display: block;

	color: #FF0000;

}

#register div.form div.fields div.field div.label

{

	margin: 2px 10px 0 0;

	padding: 5px 0 0 5px;

	width: 100px;

	float: left;

    text-align: right;

}

#register div.form div.fields div.field div.label label

{

    color: #000000;

    font-weight: bold;

}

#register  div.form div.fields div.field div.label span

{

	margin: 0;

	padding: 2px 0 0 0;

	height: 1%;

	display: block;

	color: #363636;

}

#register div.form div.fields div.field div.input

{

	margin: 0;

	padding: 0;

	float: left;

}

#register div.form div.fields div.field div.input input

{

    margin: 0;

    padding: 7px 7px 6px 7px;

    width: 245px;

    background: #FFFFFF;

    border-top: 1px solid #b3b3b3;

    border-left: 1px solid #b3b3b3;

    border-right: 1px solid #eaeaea;

    border-bottom: 1px solid #eaeaea;

    color: #000000;

	font-family: Lucida Grande, Verdana, Lucida Sans Regular, Lucida Sans Unicode, Arial, sans-serif;

	font-size: 11px;

}

#register div.form div.fields div.field div.input  input.error

{

	background: #FBE3E4;

	border-top: 1px solid #e1b2b3;

	border-left: 1px solid #e1b2b3;

	border-right: 1px solid #FBC2C4;

	border-bottom: 1px solid #FBC2C4;

}

#register div.form div.fields div.field div.input  input.success

{

	background: #E6EFC2;

	border-top: 1px solid #cebb98;

	border-left: 1px solid #cebb98;

	border-right: 1px solid #c6d880;

	border-bottom: 1px solid #c6d880;

}

#register div.form div.fields div.field div.input div.link

{

	margin: 6px 0 0 0;

	padding: 0;

	text-align: right;

}

#register div.form div.fields div.field div.checkbox

{

	margin: 0 0 0 184px;

	padding: 0;

}

#register div.form div.fields div.field div.checkbox label

{

    color: #565656;

    font-weight: bold;

}

#register div.form div.fields div.buttons

{

	margin: 0;

	padding: 10px 0 0 114px;

	clear: both;

	overflow: hidden;

	border-top: 1px solid #DDDDDD;

	text-align: left;

}