**Overview**

  breaking the main.   

  (no external search servers required all in one application)

  file-system operations

  always up to date data. 

**Incoming**

- code review based on hg-review (when it's stable)

- git support (when vcs can handle it - almost there !)

- commit based wikis

- clonning from remote repositories into rhodecode (git/mercurial)

- other cools stuff that i can figure out (or You can help me figure out)

- activate virtualenv

- run `paster make-config RhodeCode production.ini`

- run `paster setup-app production.ini`

- run `paster runserver production.ini`

You're ready to go.

- I highly recommend to install new virtualenv for rhodecode see 

  http://pypi.python.org/pypi/virtualenv for more details.

- 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 make-config RhodeCode production.inii` in order to install 

  the application config. You can play with the app settings later 

- 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

  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. 

  The app should gain a lot of speed and become much more responsible. 

  For installation instructions You can visit: 

  http://ask.github.com/celery/getting-started/index.html. 

- For full text search You can either put crontab entry for 

  `python /var/www/rhodecode/rhodecode/lib/indexers/daemon.py incremental <path_to_repos>`

  or run indexer from admin panel. This will scann the repos given in the 

  application setup or given path for daemon.py and each scann in incremental 

            form_result = _form.to_python(dict(request.POST))

            form_result.update({'perm_user_name':id})

            permission_model.update(form_result)

            h.flash(_('Default permissions updated succesfully'),

                    category='success')

            c.perms_choices = self.perms_choices

            c.register_choices = self.register_choices

            c.create_choices = self.create_choices

            return htmlfill.render(

                render('admin/permissions/permissions.html'),

            repo_model.create(form_result, c.rhodecode_user)

            invalidate_cache('cached_repo_list')

            h.flash(_('created repository %s') % form_result['repo_name'],

                    category='success')

            if request.POST.get('user_created'):

                              form_result['repo_name'], '', self.sa)

            else:

                              form_result['repo_name'], '', self.sa)                

            c.new_repo = errors.value['repo_name']

            if request.POST.get('user_created'):

                r = render('admin/repos/repo_add_create_repository.html')

            else:              

                r = render('admin/repos/repo_add.html')

            form_result = _form.to_python(dict(request.POST))

            repo_model.update(repo_name, form_result)

            invalidate_cache('cached_repo_list')

            h.flash(_('Repository %s updated succesfully' % repo_name),

                    category='success')

            changed_name = form_result['repo_name']

            c.repo_info = repo_model.get(repo_name)

            c.users_array = repo_model.get_users_js()

            errors.value.update({'user':c.repo_info.user.username})

            return htmlfill.render(

                render('admin/repos/repo_edit.html'),

                defaults=errors.value,

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('repos'))

        try:

                              repo_name, '', self.sa)

            repo_model.delete(repo)            

            invalidate_cache('cached_repo_list')

            h.flash(_('deleted repository %s') % repo_name, category='success')

        except Exception, e:

        @param repo_name:

        """

        try:

            repo_model = RepoModel()

            repo_model.delete_perm_user(request.POST, repo_name)            

            h.flash(_('An error occured during deletion of repository user'),

                    category='error')

            raise HTTPInternalServerError()

    @HasPermissionAllDecorator('hg.admin')    

    def show(self, repo_name, format='html'):

                    h.flash(_('error occurred during updating application settings'),

                            category='error')

                    self.sa.rollback()

                return htmlfill.render(

                     render('admin/settings/settings.html'),

                     defaults=errors.value,

                     errors=errors.error_dict or {},

                     prefix_error=False,

                     encoding="UTF-8") 

                    h.flash(_('error occurred during updating application settings'),

                            category='error')

                    self.sa.rollback()

                return htmlfill.render(

                     render('admin/settings/settings.html'),

                     defaults=errors.value,

                     errors=errors.error_dict or {},

                     prefix_error=False,

                     encoding="UTF-8") 

        try:

            form_result = _form.to_python(dict(request.POST))

            user_model.update_my_account(uid, form_result)

            h.flash(_('Your account was updated succesfully'),

                    category='success')

            c.user = self.sa.query(User).get(c.rhodecode_user.user_id)

            c.user_repos = []

            for repo in c.cached_repo_list.values():

                if repo.dbrepo.user.username == c.user.username:

                    c.user_repos.append(repo)            

            return htmlfill.render(

        try:

            form_result = login_form.to_python(dict(request.POST))

            user_model.create(form_result)

            h.flash(_('created user %s') % form_result['username'],

                    category='success')

            #action_logger(self.rhodecode_user, 'new_user', '', '', self.sa)

            return htmlfill.render(

                render('admin/users/user_add.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8") 

        form_result = {}

        try:

            form_result = _form.to_python(dict(request.POST))

            user_model.update(id, form_result)

            h.flash(_('User updated succesfully'), category='success')

            return htmlfill.render(

                render('admin/users/user_edit.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8") 

        #           method='delete')

        # url('user', id=ID)

        user_model = UserModel()

        try:

            user_model.delete(id)

            h.flash(_('sucessfully deleted user'), category='success')

            h.flash(str(e), category='warning')

        except Exception:

            h.flash(_('An error occured during deletion of user'),

                    category='error')            

        return redirect(url('users'))

                if c.came_from:

                    return redirect(c.came_from)

                else:

                    return redirect(url('hg_home'))

                return htmlfill.render(

                    render('/login.html'),

                    defaults=errors.value,

                    errors=errors.error_dict or {},

                    prefix_error=False,

                    encoding="UTF-8")

                form_result['active'] = c.auto_active

                user_model.create_registration(form_result)

                h.flash(_('You have successfully registered into rhodecode'),

                            category='success')                

                return redirect(url('login_home'))

                return htmlfill.render(

                    render('/register.html'),

                    defaults=errors.value,

                    errors=errors.error_dict or {},

                    prefix_error=False,

                    encoding="UTF-8")

                form_result = password_reset_form.to_python(dict(request.POST))

                user_model.reset_password(form_result)

                h.flash(_('Your new password was sent'),

                            category='success')                 

                return redirect(url('login_home'))

                return htmlfill.render(

                    render('/password_reset.html'),

                    defaults=errors.value,

                    errors=errors.error_dict or {},

                    prefix_error=False,

                    encoding="UTF-8")

            form_result = _form.to_python(dict(request.POST))

            repo_model.update(repo_name, form_result)

            invalidate_cache('cached_repo_list')

            h.flash(_('Repository %s updated successfully' % repo_name),

                    category='success')

            changed_name = form_result['repo_name']               

            c.repo_info = repo_model.get(repo_name)

            c.users_array = repo_model.get_users_js()

            errors.value.update({'user':c.repo_info.user.username})

            return htmlfill.render(

                render('settings/repo_settings.html'),

                defaults=errors.value,

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('hg_home'))

        try:

                              repo_name, '', self.sa)            

            repo_model.delete(repo)            

            invalidate_cache('cached_repo_list')

            h.flash(_('deleted repository %s') % repo_name, category='success')

        except Exception:

            h.flash(_('An error occurred during deletion of %s') % repo_name,

            repo_model.create_fork(form_result, c.rhodecode_user)

            h.flash(_('fork %s repository as %s task added') \

                      % (repo_name, form_result['fork_name']),

                    category='success')

            action_logger(self.rhodecode_user, 'user_forked_repo',

                            repo_name, '', self.sa)                                                 

            c.new_repo = errors.value['fork_name']

            r = render('settings/repo_fork.html')

            return htmlfill.render(

                r,

                defaults=errors.value,

        meta.Session.remove()

    return user

def authfunc(environ, username, password):

    try:

        user = get_user_cached(username)

        log.error(e)

        user = None

    if user:

        if user.active:

            if user.username == username and check_password(password, user.password):

from rhodecode.lib.celerylib import run_task, locked_task

from rhodecode.lib.helpers import person

from rhodecode.lib.smtp_mailer import SmtpMailer

from rhodecode.lib.utils import OrderedDict

from time import mktime

from vcs.backends.hg import MercurialRepository

import traceback

try:

    from celeryconfig import PYLONS_CONFIG as config

    celery_on = True

except ImportError:

    #if celeryconfig is not present let's just load our pylons

    #config instead

    from pylons import config

from rhodecode import get_version

import sys

requirements = [

        "Pylons>=1.0.0",

        "SQLAlchemy>=0.6",

        "babel",

        "Mako>=0.3.2",

        "vcs>=0.1.7",

        "pygments>=1.3.0",

        "mercurial>=1.6",

        "whoosh==1.0.0",

        "py-bcrypt",

        "celery",

    ]

#additional files from project that goes somewhere in the filesystem

#relative to sys.prefix

data_files = []

#additional files that goes into package itself

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