include COPYING

include rhodecode/config/deployment.ini_tmpl

recursive-include rhodecode/public/css *

recursive-include rhodecode/public/images *

include rhodecode/public/js/yui2.js

include rhodecode/public/js/excanvas.min.js

include rhodecode/public/js/yui.flot.js

-------------

Installation

-------------

- I highly recommend to install new virtualenv for rhodecode see 

- Create new virtualenv using `virtualenv --no-site-packages /var/www/rhodecode-venv`

  this will install new virtual env into /var/www/rhodecode-venv. 

  Activate the virtualenv by running 

  `source activate /var/www/rhodecode-venv/bin/activate`   

- Make a folder for rhodecode somewhere on the filesystem for example /var/www/rhodecode  

- Run `paster setup-app production.ini` it should create all needed tables 

  and an admin account make sure You specify correct path to repositories. 

- Remember that the given path for mercurial repositories must be write 

  accessible for the application

  the app should be available at the 127.0.0.1:5000

- Use admin account you created to login.

- Default permissions on each repository is read, and owner is admin. So remember

  to update these.

- In order to use full power of async tasks, You must install message broker

  preferably rabbitmq and start celeryd daemon together with rhodecode. 

##option to use threads of process

use_threadpool = true

use = egg:Paste#http

host = 127.0.0.1

[app:main]

use = egg:rhodecode

full_stack = true

lang=en

cache_dir = %(here)s/data

app_instance_uuid = ${app_instance_uuid}

####################################

###         BEAKER CACHE        ####

"""

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

import os

import sys

import uuid

from rhodecode.lib.auth import get_crypt_password

from rhodecode.lib.utils import ask_ok

from rhodecode.model import init_model

from rhodecode.model.db import User, Permission, RhodeCodeUi, RhodeCodeSettings, \

    UserToPerm

from sqlalchemy.engine import create_engine

import logging

log = logging.getLogger(__name__)

class DbManage(object):

        self.dbname = dbname

        self.tests = tests

        engine = create_engine(dburi, echo=log_sql) 

        init_model(engine)

        self.sa = meta.Session

        self.db_exists = False

    def check_for_db(self, override):

            self.db_exists = True

            if not override:

                raise Exception('database already exists')

    def create_tables(self, override=False):

        """

        Create a auth database

        """

        self.check_for_db(override)

        if override:

            if self.tests:

                destroy = True

            else:

                destroy = ask_ok('Are you sure to destroy old database ? [y/n]')

            if not destroy:

                sys.exit()

            if self.db_exists and destroy:

        checkfirst = not override

        meta.Base.metadata.create_all(checkfirst=checkfirst)

        log.info('Created tables for %s', self.dbname)

    def admin_prompt(self):

        if not self.tests:

            import getpass

            username = raw_input('Specify admin username:')

            password = getpass.getpass('Specify admin password:')

            email = raw_input('Specify admin email:')

            self.create_user(username, password, email, True)

        else:

            log.info('creating admin and regular test users')

            self.create_user('test_admin', 'test12', 'test_admin@mail.com', True)

            self.create_user('test_regular', 'test12', 'test_regular@mail.com', False)

    ch.setFormatter(formatter)

    # add ch to logger

    log.addHandler(ch)

    #PART ONE create db

    dbname = config['sqlalchemy.db1.url'].split('/')[-1]

    dbmanage.create_tables(override=True)

    dbmanage.config_prompt(repos_test_path)

    dbmanage.create_default_user()

    dbmanage.admin_prompt()

    dbmanage.create_permissions()

    dbmanage.populate_default_permissions()

"""Setup the rhodecode application"""

from rhodecode.config.environment import load_environment

from rhodecode.lib.db_manage import DbManage

import logging

import os

log = logging.getLogger(__name__)

def setup_app(command, conf, vars):

    """Place any commands to setup rhodecode here"""

    dbname = os.path.split(conf['sqlalchemy.db1.url'])[-1] 

    dbmanage.create_tables(override=True)

    dbmanage.create_default_user()

    dbmanage.admin_prompt()

    dbmanage.create_permissions()

    dbmanage.populate_default_permissions()

    load_environment(conf.global_conf, conf.local_conf, initial=True)

from rhodecode import get_version

try:

    from setuptools import setup, find_packages

except ImportError:

    from ez_setup import use_setuptools

    use_setuptools()

    from setuptools import setup, find_packages

setup(

    version=get_version(),

    description='Mercurial repository serving and browsing app',

    keywords='mercurial web hgwebdir replacement serving hgweb rhodecode',

    license='BSD',

    author_email='marcin@python-works.com',

    url='http://hg.python-works.com',

    setup_requires=["PasteScript>=1.6.3"],

    packages=find_packages(exclude=['ez_setup']),

    include_package_data=True,

    test_suite='nose.collector',

    package_data={'rhodecode': ['i18n/*/LC_MESSAGES/*.mo']},

    message_extractors={'rhodecode': [

            ('**.py', 'python', None),