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

- Run paster serve production.ini - or you can use sample init.d scripts.

  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. 

  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 

        # url('new_permission')

    def update(self, id):

        """PUT /permissions/id: Update an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="PUT" />

        # Or using helpers:

        #    h.form(url('permission', id=ID),

        #           method='put')

        # url('permission', id=ID)

        permission_model = PermissionModel()

        _form = DefaultPermissionsForm([x[0] for x in self.perms_choices],

                                       [x[0] for x in self.register_choices],

                                       [x[0] for x in self.create_choices])()

        try:

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

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8") 

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occured during update of permissions'),

                    category='error')

        return redirect(url('edit_permission', id=id))

    def delete(self, id):

        """DELETE /permissions/id: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

    @HasPermissionAllDecorator('hg.admin')            

    def index(self, format='html'):

        """GET /repos: All items in the collection"""

        # url('repos')

        cached_repo_list = HgModel().get_repos()

        c.repos_list = sorted(cached_repo_list, key=itemgetter('name_sort'))

        return render('admin/repos/repos.html')

    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')

    def create(self):

        """POST /repos: Create a new item"""

        # url('repos')

        repo_model = RepoModel()

        _form = RepoForm()()

        form_result = {}

        try:

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

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

            return htmlfill.render(

                r,

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")      

        except Exception:

            log.error(traceback.format_exc())

            msg = _('error occured during creation of repository %s') \

                    % form_result.get('repo_name')

            h.flash(msg, category='error')

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

            return redirect(url('hg_home'))    

        return redirect(url('repos'))

    @HasPermissionAllDecorator('hg.admin')

        c.new_repo = h.repo_name_slug(new_repo)

        return render('admin/repos/repo_add.html')

    @HasPermissionAllDecorator('hg.admin')

    def update(self, repo_name):

        """PUT /repos/repo_name: Update an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="PUT" />

        # Or using helpers:

        #    h.form(url('repo', repo_name=ID),

        #           method='put')

        # url('repo', repo_name=ID)

        repo_model = RepoModel()

        changed_name = repo_name

        _form = RepoForm(edit=True, old_data={'repo_name':repo_name})()

        try:

            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,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occured during update of repository %s') \

                    % repo_name, category='error')

        return redirect(url('edit_repo', repo_name=changed_name))

    @HasPermissionAllDecorator('hg.admin')

    def delete(self, repo_name):

        """DELETE /repos/repo_name: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('repo', repo_name=ID),

        #           method='delete')

        # url('repo', repo_name=ID)

        repo_model = RepoModel()

        repo = repo_model.get(repo_name)

        if not repo:

            h.flash(_('%s repository is not mapped to db perhaps' 

                      ' it was moved or renamed  from the filesystem'

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

            log.error(traceback.format_exc())

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

                    category='error')

        return redirect(url('repos'))

    @HasPermissionAllDecorator('hg.admin')        

    def delete_perm_user(self, repo_name):

        """

        DELETE an existing repository permission user

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

        """GET /repos/repo_name: Show a specific item"""

        # url('repo', repo_name=ID)

    @HasPermissionAllDecorator('hg.admin')    

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

        """GET /repos/repo_name/edit: Form to edit an existing item"""

        # url('edit_repo', repo_name=ID)

        repo_model = RepoModel()

        c.repo_info = repo = repo_model.get(repo_name)

        if not repo:

            h.flash(_('%s repository is not mapped to db perhaps' 

                      ' it was created or renamed from the filesystem'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('repos'))        

        defaults = c.repo_info.__dict__

                    hgsettings1 = self.sa.query(RhodeCodeSettings)\

                    .filter(RhodeCodeSettings.app_settings_name == 'title').one()

                    hgsettings1.app_settings_value = form_result['rhodecode_title'] 

                    hgsettings2 = self.sa.query(RhodeCodeSettings)\

                    .filter(RhodeCodeSettings.app_settings_name == 'realm').one()

                    hgsettings2.app_settings_value = form_result['rhodecode_realm'] 

                    self.sa.add(hgsettings1)

                    self.sa.add(hgsettings2)

                    self.sa.commit()

                    set_rhodecode_config(config)

                    h.flash(_('Updated application settings'),

                            category='success')

                except:

                    log.error(traceback.format_exc())

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

        if setting_id == 'mercurial':

            application_form = ApplicationUiSettingsForm()()

            try:

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

                try:

                    hgsettings1 = self.sa.query(RhodeCodeUi)\

                    .filter(RhodeCodeUi.ui_key == 'push_ssl').one()

                    hgsettings1.ui_value = form_result['web_push_ssl']

                    hgsettings2 = self.sa.query(RhodeCodeUi)\

                    .filter(RhodeCodeUi.ui_key == '/').one()

                    hgsettings2.ui_value = form_result['paths_root_path']                    

                    #HOOKS

                    hgsettings4 = self.sa.query(RhodeCodeUi)\

                    .filter(RhodeCodeUi.ui_key == 'changegroup.repo_size').one()

                    hgsettings4.ui_active = bool(form_result['hooks_changegroup_repo_size'])                                          

                    self.sa.add(hgsettings1)

                    self.sa.add(hgsettings2)

                    self.sa.add(hgsettings3)

                    self.sa.add(hgsettings4)

                    self.sa.commit()

                    h.flash(_('Updated mercurial settings'),

                            category='success')

                except:

                    log.error(traceback.format_exc())

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

        return redirect(url('admin_settings'))

    @HasPermissionAllDecorator('hg.admin')

    def delete(self, setting_id):

        """DELETE /admin/settings/setting_id: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('admin_setting', setting_id=ID),

        #           method='delete')

        # url('admin_setting', setting_id=ID)

    @HasPermissionAllDecorator('hg.admin')

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

        """GET /admin/settings/setting_id: Show a specific item"""

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        ) 

    def my_account_update(self):

        """PUT /_admin/my_account_update: Update an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="PUT" />

        # Or using helpers:

        #    h.form(url('admin_settings_my_account_update'),

        #           method='put')

        # url('admin_settings_my_account_update', id=ID)

        user_model = UserModel()

        uid = c.rhodecode_user.user_id

        _form = UserForm(edit=True, old_data={'user_id':uid,

                                              'email':c.rhodecode_user.email})()

        form_result = {}

        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(

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

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occured during update of user %s') \

                    % form_result.get('username'), category='error')

        return redirect(url('my_account'))

    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')

    def create_repository(self):

        """GET /_admin/create_repository: Form to create a new item"""

        new_repo = request.GET.get('repo', '')

        c.new_repo = h.repo_name_slug(new_repo)

        c.admin_user = session.get('admin_user')

        c.admin_username = session.get('admin_username')

        super(UsersController, self).__before__()

    def index(self, format='html'):

        """GET /users: All items in the collection"""

        # url('users')

        c.users_list = self.sa.query(User).all()     

        return render('admin/users/users.html')

    def create(self):

        """POST /users: Create a new item"""

        # url('users')

        user_model = UserModel()

        login_form = UserForm()()

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

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occured during creation of user %s') \

                    % request.POST.get('username'), category='error')            

        return redirect(url('users'))

    def new(self, format='html'):

        """GET /users/new: Form to create a new item"""

        # url('new_user')

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

    def update(self, id):

        """PUT /users/id: Update an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="PUT" />

        # Or using helpers:

        #    h.form(url('user', id=ID),

        #           method='put')

        # url('user', id=ID)

        user_model = UserModel()

        c.user = user_model.get_user(id)

        _form = UserForm(edit=True, old_data={'user_id':id,

                                              'email':c.user.email})()

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

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occured during update of user %s') \

                    % form_result.get('username'), category='error')

        return redirect(url('users'))

    def delete(self, id):

        """DELETE /users/id: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('user', id=ID),

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

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

        """GET /users/id: Show a specific item"""

        # url('user', id=ID)

    def edit(self, id, format='html'):

        """GET /users/id/edit: Form to edit an existing item"""

        # url('edit_user', id=ID)

        c.user = self.sa.query(User).get(id)

        if not c.user:

            return redirect(url('users'))

        if c.user.username == 'default':

            h.flash(_("You can't edit this user since it's" 

              " crucial for entire application"), category='warning')

            return redirect(url('users'))

        defaults = c.user.__dict__

        return htmlfill.render(

            #import Login Form validator class

            login_form = LoginForm()

            try:

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

                username = c.form_result['username']

                user = UserModel().get_user_by_name(username)

                auth_user = AuthUser()

                auth_user.username = user.username

                auth_user.is_authenticated = True

                auth_user.is_admin = user.admin

                auth_user.user_id = user.user_id

                auth_user.name = user.name

                auth_user.lastname = user.lastname

                session['rhodecode_user'] = auth_user

                session.save()

                log.info('user %s is now authenticated', username)

                user.update_lastlogin()

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

        return render('/login.html')

    @HasPermissionAnyDecorator('hg.admin', 'hg.register.auto_activate',

                               'hg.register.manual_activate')

    def register(self):

        user_model = UserModel()

        c.auto_active = False

        for perm in user_model.get_default().user_perms:

            if perm.permission.permission_name == 'hg.register.auto_activate':

                c.auto_active = True

                break

        if request.POST:

            register_form = RegisterForm()()

            try:

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

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

        return render('/register.html')

    def password_reset(self):

        user_model = UserModel()

        if request.POST:

            password_reset_form = PasswordResetForm()()

            try:

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

        return render('/password_reset.html')

    def logout(self):

        session['rhodecode_user'] = AuthUser()

        session.save()

        log.info('Logging out and setting user as Empty')

        redirect(url('hg_home'))

        c.users_array = repo_model.get_users_js()

        for p in c.repo_info.repo_to_perm:

            defaults.update({'perm_%s' % p.user.username: 

                             p.permission.permission_name})

        return htmlfill.render(

            render('settings/repo_settings.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )  

    def update(self, repo_name):

        repo_model = RepoModel()

        changed_name = repo_name

        _form = RepoSettingsForm(edit=True, old_data={'repo_name':repo_name})()

        try:

            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,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8") 

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occured during update of repository %s') \

                    % repo_name, category='error')

        return redirect(url('repo_settings_home', repo_name=changed_name))

    def delete(self, repo_name):    

        """DELETE /repos/repo_name: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('repo_settings_delete', repo_name=ID),

        #           method='delete')

        # url('repo_settings_delete', repo_name=ID)

        repo_model = RepoModel()

        repo = repo_model.get(repo_name)

        if not repo:

            h.flash(_('%s repository is not mapped to db perhaps' 

                      ' it was moved or renamed  from the filesystem'

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

                    category='error')

        return redirect(url('hg_home'))

    def fork(self, repo_name):

        repo_model = RepoModel()

        c.repo_info = repo = repo_model.get(repo_name)

        if not repo:

            h.flash(_('%s repository is not mapped to db perhaps' 

                      ' it was created or renamed from the filesystem'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('hg_home'))

        return render('settings/repo_fork.html')

    def fork_create(self, repo_name):

        repo_model = RepoModel()

        c.repo_info = repo_model.get(repo_name)

        _form = RepoForkForm()()

        form_result = {}

        try:

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

            form_result.update({'repo_name':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')