# List of modules to import when celery starts.

import sys

import os

sys.path.append(os.getcwd())

## Result store settings.

CELERY_RESULT_BACKEND = "database"

CELERY_RESULT_DBURI = "sqlite:///hg_app.db"

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"

CELERYD_MAX_TASKS_PER_CHILD = 1

#CELERY_ALWAYS_EAGER = True

#rabbitmqctl add_user rabbitmq qweqwe

#rabbitmqctl add_vhost rabbitmqhost

from celery.decorators import task

from celery.task.sets import subtask

from datetime import datetime, timedelta

from pylons.i18n.translation import _

from pylons_app.lib.celerylib import run_task

from pylons_app.lib.helpers import person

from pylons_app.lib.smtp_mailer import SmtpMailer

from pylons_app.lib.utils import OrderedDict

from time import mktime

from vcs.backends.hg import MercurialRepository

import calendar

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    

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

    return settings   

@task

def whoosh_index(repo_location, full_index):

    log = whoosh_index.get_logger()

    from pylons_app.lib.indexers import DaemonLock

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

    log = get_commits_stats.get_logger()

    aggregate = OrderedDict()

    repo = MercurialRepository(repos_path + repo)

    #graph range

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

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

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

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

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

    def author_key_cleaner(k):

        k = person(k)

        k = k.replace('"', "'") #for js data compatibilty

        return k

    for cs in repo[:200]:#added limit 200 until fix #29 is made

        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 aggregate.has_key(author_key_cleaner(cs.author)):

            if aggregate[author_key_cleaner(cs.author)].has_key(k):

                aggregate[author_key_cleaner(cs.author)][k]["commits"] += 1

                aggregate[author_key_cleaner(cs.author)][k]["added"] += len(cs.added)

                aggregate[author_key_cleaner(cs.author)][k]["changed"] += len(cs.changed)

        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:

                       mail_port, ssl, tls)

        m.send(recipients, subject, body)  

    except:

        log.error('Mail sending failed')

        log.error(traceback.format_exc())

        return False

    return True

# 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 Jan 26, 2010

@author: marcink

A deamon will read from task table and run tasks

"""

import sys

import os

from os.path import dirname as dn

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 pidlock import LockHeld, DaemonLock

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

import logging

log = logging.getLogger('whooshIndexer')

def scan_paths(root_location):

    return HgModel.repo_scan('/', root_location, None, True)

class WhooshIndexingDaemon(object):

    """Deamon for atomic jobs"""

    def __init__(self, indexname='HG_INDEX', repo_location=None):

        self.indexname = indexname

        self.repo_location = repo_location

        self.initial = False

        if not os.path.isdir(IDX_LOCATION):

            os.mkdir(IDX_LOCATION)

            log.info('Cannot run incremental index since it does not'

                     ' yet exist running full build')

            self.initial = True

    def get_paths(self, root_dir):

        """recursive walk in root dir and return a set of all path in that dir

        excluding files in .hg dir"""

        index_paths_ = set()

        for path, dirs, files in os.walk(root_dir):

            if path.find('.hg') == -1:

                for f in files:

    if arg[0] == 'full':

        full_index = True

    elif arg[0] == 'incremental':

        # False means looking just for changes

        full_index = False

    else:

        sys.stdout.write('Please use [full|incremental]' 

                         ' as script first arg \n')

        sys.exit()

    if not os.path.isdir(arg[1]):

        sys.stderr.write('%s is not a valid path \n' % arg[1])

        sys.exit()

    else:

        if arg[1].endswith('/'):

            repo_location = arg[1] + '*'

        else:

            repo_location = arg[1] + '/*'

    try:

        l = DaemonLock()

        WhooshIndexingDaemon(repo_location=repo_location)\

            .run(full_index=full_index)

        l.release()

    except LockHeld:

        sys.exit(1)

"""Pylons application test package

This package assumes the Pylons environment is already loaded, such as

when this script is imported from the `nosetests --with-pylons=test.ini`

command.

This module initializes the application via ``websetup`` (`paster

setup-app`) and provides the base testing objects.

"""

from unittest import TestCase

from paste.deploy import loadapp

from paste.script.appinstall import SetupCommand

from pylons import config, url

from routes.util import URLGenerator

from webtest import TestApp

import os

from pylons_app.model import meta

import logging

log = logging.getLogger(__name__) 

import pylons.test

__all__ = ['environ', 'url', 'TestController']

# Invoke websetup with the current config file

#SetupCommand('setup-app').run([pylons.test.pylonsapp.config['__file__']])

environ = {}

class TestController(TestCase):

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

        wsgiapp = pylons.test.pylonsapp

        config = wsgiapp.config

        self.app = TestApp(wsgiapp)

        url._push_object(URLGenerator(config['routes.map'], environ))

        self.sa = meta.Session

        TestCase.__init__(self, *args, **kwargs)

    def log_user(self):

        response = self.app.post(url(controller='login', action='index'),

                                 {'username':'test_admin',

                                  'password':'test'})

        assert response.status == '302 Found', 'Wrong response code from login got %s' % response.status

        assert response.session['hg_app_user'].username == 'test_admin', 'wrong logged in user'

        return response.follow()

                                             'name':'test',

                                             'lastname':'test'})

        assert response.status == '200 OK', 'Wrong response from register page got %s' % response.status

        assert 'This username already exists' in response.body 

    def test_register_err_wrong_data(self):

        response = self.app.post(url(controller='login', action='register'),

                                            {'username':'xs',

                                             'password':'',

                                             'email':'goodmailm',

                                             'name':'test',

                                             'lastname':'test'})

        assert response.status == '200 OK', 'Wrong response from register page got %s' % response.status

        assert 'An email address must contain a single @' in response.body

        assert 'Enter a value 3 characters long or more' in response.body

        assert 'Please enter a value<' in response.body

    def test_register_ok(self):

        username = 'test_regular4'

        password = 'qweqwe'

        name = 'testname'

        lastname = 'testlastname'

        response = self.app.post(url(controller='login', action='register'),

                                            {'username':username,

                                             'password':password,

                                             'email':email,

                                             'name':name,

                                             'lastname':lastname})

        print response.body

        assert response.status == '302 Found', 'Wrong response from register page got %s' % response.status        

        assert 'You have successfully registered into hg-app' in response.session['flash'][0], 'No flash message about user registration'

        ret = self.sa.query(User).filter(User.username == 'test_regular4').one()

        assert ret.username == username , 'field mismatch %s %s' % (ret.username, username)

        assert ret.email == email , 'field mismatch %s %s' % (ret.email, email)

        assert ret.name == name , 'field mismatch %s %s' % (ret.name, name)

        assert ret.lastname == lastname , 'field mismatch %s %s' % (ret.lastname, lastname)

    def test_forgot_password_wrong_mail(self):    

        response = self.app.post(url(controller='login', action='password_reset'),

    def test_forgot_password(self):

        response = self.app.get(url(controller='login', action='password_reset'))

        assert response.status == '200 OK', 'Wrong response from login page got %s' % response.status

        username = 'test_password_reset_1'

        password = 'qweqwe'

        email = 'marcin@python-works.com'

        name = 'passwd'

        lastname = 'reset'

        response = self.app.post(url(controller='login', action='register'),

                                            {'username':username,

                                             'password':password,

                                             'email':email,

                                             'name':name,

                                             'lastname':lastname})        

        #register new user for email test

        response = self.app.post(url(controller='login', action='password_reset'),

        print response.session['flash']

        assert 'You have successfully registered into hg-app' in response.session['flash'][0], 'No flash message about user registration'

        assert 'Your new password was sent' in response.session['flash'][1], 'No flash message about password reset'

from pylons_app.tests import *

from pylons_app.lib.indexers import IDX_LOCATION

import os

from nose.plugins.skip import SkipTest

class TestSearchController(TestController):

    def test_index(self):

        self.log_user()

        response = self.app.get(url(controller='search', action='index'))

        print response.body

        # Test response...

    def test_empty_search(self):

        if os.path.isdir(IDX_LOCATION):

            raise SkipTest('skipped due to existing index')

        else:

            self.log_user()

    def test_normal_search(self):

        self.log_user()

        print response.body