browser/management tool with build in push/pull server and full text search.

It works on http/https, has build in permission/authentication system with 

ability to auth via LDAP. It's similar in some parts to github or bitbucket, 

but it's suppose to run as standalone hosted application, it's open source 

and donation ware and focuses more on providing customized, self administered 

interface for Mercurial(and soon GIT) repositories. It's powered by vcs_ 

library that me and Lukasz Balcerzak created to handle many various version 

control systems.

  and LDAP

- Intelligent cache with invalidation after push or project change, provides high 

- ssh based authentication with server side key management

- clone points and cloning from remote repositories into RhodeCode

``RhodeCode`` is released under GPL_ license.

.. _virtualenv: http://pypi.python.org/pypi/virtualenv

.. _python: http://www.python.org/

.. _django: http://www.djangoproject.com/

.. _mercurial: http://mercurial.selenic.com/

.. _subversion: http://subversion.tigris.org/

.. _git: http://git-scm.com/

.. _celery: http://celeryproject.org/

.. _Sphinx: http://sphinx.pocoo.org/

.. _GPL: http://www.gnu.org/licenses/gpl.html

.. _vcs: http://pypi.python.org/pypi/vcs

1.1.4 (**2011-02-19**)

======================

news

----

fixes

-----

- fixed formencode import problem on settings page, that caused server crash

  when that page was accessed as first after server start

- journal fixes

- fixed option to access repository just by entering http://server/<repo_name> 

Preferable method Would be to fork RhodeCode repository from bitbucket

https://bitbucket.org/marcinkuzminski/rhodecode and then open a pull request.

This way it's easier for me to merge.

To run RhodeCode in a development version You always need to install tip

version of RhodeCode and VCS library.

    easy_install rhodecode

    pip install rhodecode

http://pypi.python.org/pypi/rhodecode, decompress archive and run::

    python setup.py install

    virtualenv --no-site-packages /var/www/rhodecode-venv

.. note:: Using ``--no-site-packages`` when generating your

   virtualenv is *very important*. This flag provides the necessary

   isolation for running the set of packages required by

   RhodeCode.  If you do not specify ``--no-site-packages``,

   it's possible that RhodeCode will not install properly into

   the virtualenv, or, even if it does, may not run properly,

   depending on the packages you've already got installed into your

   Python's "main" site-packages dir.

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

.. note:: If you're on UNIX, *do not* use ``sudo`` to run the

   ``virtualenv`` script.  It's perfectly acceptable (and desirable)

   to create a virtualenv as a normal user.

    mkdir /var/www/rhodecode

    easy_install rhodecode 

First You'll need to create RhodeCode config file. Run the following command 

Next we need to create the database. I'll recommend to use sqlite (default) 

or postgresql. Make sure You properly adjust the db url in the .ini file to use

other than the default sqlite database

You are ready to use RhodeCode, to run it simply execute

Using RhodeCode with SSH

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

RhodeCode repository structures are kept in directories with the same name 

as the project, when using repository groups, each group is a a subdirectory.

This will allow You to use ssh for accessing repositories quite easy. There

are some exceptions when using ssh for accessing repositories.

You have to make sure that the webserver as well as the ssh users have unix

permission for directories. Secondly when using ssh rhodecode will not 

authenticate those requests and permissions set by the web interface will not

work on the repositories accessed via ssh. There is a solution to this to use 

auth hooks, that connects to rhodecode db, and runs check functions for

permissions.

if Your main directory (the same as set in RhodeCode settings) is for example 

set for to **/home/hg** and repository You are using is `rhodecode`

The command runned should look like this::

    hg clone ssh://user@server.com/home/hg/rhodecode

Using external tools such as mercurial server or using ssh key based auth is

fully supported.

Starting from version 1.1 whoosh index can be build using paster command.

You have to specify the config file that stores location of index, and

location of repositories (`--repo-location`).

There is possible also to pass `-f` to the options

incremental mode::

	paster make-index production.ini --repo-location=<location for repos> 

for full index rebuild You can use::

	paster make-index production.ini -f --repo-location=<location for repos>

In order to do periodical index builds and keep Your index always up to date.

It's recommended to do a crontab entry for incremental indexing. 

An example entry might look like this

When using incremental (default) mode whoosh will check last modification date 

to use LDAP, You have to install python-ldap_ package. This package is available

    server {

       listen          80;

       server_name     hg.myserver.com;

       access_log      /var/log/nginx/rhodecode.access.log;

       error_log       /var/log/nginx/rhodecode.error.log;

       location / {

               root /var/www/rhodecode/rhodecode/public/;

               if (!-f $request_filename){

                   proxy_pass      http://127.0.0.1:5000;

               }

               #this is important if You want to use https !!!

               proxy_set_header X-Url-Scheme $scheme;

               include         /etc/nginx/proxy.conf;  

       }

    }  

    proxy_buffer_size           16k;

    proxy_buffers               4 16k;

    [app:main]

      use = egg:rhodecode

      full_stack = true

      static_files = false

      lang=en

      cache_dir = %(here)s/data

Apache as subdirectory

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

Apache subdirectory part::

    <Location /rhodecode>

      ProxyPass http://127.0.0.1:59542/rhodecode

      ProxyPassReverse http://127.0.0.1:59542/rhodecode

      SetEnvIf X-Url-Scheme https HTTPS=1

    </Location> 

Besides the regular apache setup You'll need to add such part to .ini file::

    filter-with = proxy-prefix

Add the following at the end of the .ini file::

    [filter:proxy-prefix]

    use = egg:PasteDeploy#prefix

    prefix = /<someprefix> 

- Apache doesn't pass basicAuth on pull/push ?

 - Make sure You added `WSGIPassAuthorization true` 

.. _rabbitmq: http://www.rabbitmq.com/

.. _python-ldap: http://www.python-ldap.org/

.. note::

   The next steps only apply to upgrading from non bugfix releases eg. from

   any minor or major releases. Bugfix releases (eg. 1.1.2->1.1.3) will 

   not have any database schema changes or whoosh library updates

    paster upgrade-db production.ini

VERSION = (1, 1, 4)

    map.connect('summary_home_', '/{repo_name:.*}',

                controller='summary', conditions=dict(function=check_repo))

import formencode

from formencode import htmlfill

        return htmlfill.render(

            return htmlfill.render(

            return htmlfill.render(

        revs_limit = 5

        revs = action_params.split(',')

        cs_links = " " + ', '.join ([link(rev,

                url('changeset_home',

                repo_name=user_log.repository.repo_name,

                revision=rev)) for rev in revs[:revs_limit] ])

        if len(revs) > revs_limit:

            uniq_id = revs[0]

            html_tmpl = ('<span> %s '

            '<a class="show_more" id="_%s" href="#">%s</a> '

            '%s</span>')

            cs_links += html_tmpl % (_('and'), uniq_id, _('%s more') \

                                        % (len(revs) - revs_limit),

                                        _('revisions'))

            html_tmpl = '<span id="%s" style="display:none"> %s </span>'

            cs_links += html_tmpl % (uniq_id, ', '.join([link(rev,

                url('changeset_home',

                repo_name=user_log.repository.repo_name,

                revision=rev)) for rev in revs[revs_limit:] ]))

        return cs_links

           'user_forked_repo':(_('[forked] repository as'), get_fork_name),

           'push':(_('[pushed] '), get_cs_links),

           'pull':(_('[pulled] '), None),