Setting up RhodeCode

First, you will need to create a RhodeCode configuration file. Run the following

command to do this::

- This will create the file `production.ini` in the current directory. This

  configuration file contains the various settings for RhodeCode, e.g proxy port,

Next, you need to create the databases used by RhodeCode. I recommend that you

use sqlite (default) or postgresql. If you choose a database other than the

default ensure you properly adjust the db url in your production.ini

configuration file to use this other database. Create the databases by running

the following command::

This will prompt you for a "root" path. This "root" path is the location where

RhodeCode will store all of its repositories on the current machine. After

entering this "root" path ``setup-app`` will also prompt you for a username and password

for the initial admin account which ``setup-app`` sets up for you.

- The ``setup-app`` command will create all of the needed tables and an admin

  account. When choosing a root path You can either use a new empty location, or a

  location which already contains existing repositories. If you choose a location

  which contains existing repositories RhodeCode will simply add all of the

  repositories at the chosen location to it's database. (Note: make sure you

  specify the correct path to the root).

- Note: the given path for mercurial_ repositories **must** be write accessible

  for the application. It's very important since the RhodeCode web interface will

  work without write access, but when trying to do a push it will eventually fail

  with permission denied errors unless it has write access.

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

- This command runs the RhodeCode server. The web app should be available at the 

- Use the admin account you created above when running ``setup-app`` to login to the web app.

- The default permissions on each repository is read, and the owner is admin. 

  Remember to update these if needed.

- In the admin panel You can toggle ldap, anonymous, permissions settings. As

  well as edit more advanced options on users and repositories

Try copying your own mercurial repository into the "root" directory you are

using, then from within the RhodeCode web application choose Admin >

repositories. Then choose Add New Repository. Add the repository you copied into

the root. Test that you can browse your repository from within RhodCode and then

try cloning your repository from RhodeCode with::

  hg clone http://127.0.0.1:5000/<repository name>

where *repository name* is replaced by the name of your repository.

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

This will allow you to use ssh for accessing repositories quite easily. There

You have to make sure that the web-server as well as the ssh users have unix

permission for the appropriate 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

If your main directory (the same as set in RhodeCode settings) is for example

set to **/home/hg** and the repository you are using is named `rhodecode`, then

to clone via ssh you should run::

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

authentication is fully supported.

Starting from version 1.1 the whoosh index can be build by using the paster

command ``make-index``. To use ``make-index`` You must specify the configuration

file that stores the location of the index, and the location of the repositories

(`--repo-location`).

You may optionally pass the option `-f` to enable a full index rebuild. Without

the `-f` option, indexing will run always in "incremental" mode.

For an incremental index build use::

For a full index rebuild use::

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

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

An example entry might look like this::

When using incremental mode (the default) whoosh will check the last

modification date of each file and add it to be reindexed if a newer file is

available. The indexing daemon checks for any removed files and removes them

from index.

If you want to rebuild index from scratch, you can use the `-f` flag as above,

or in the admin panel you can check `build from scratch` flag.

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

via pypi, so you can install it by running

   python-ldap requires some certain libs on your system, so before installing 

   it check that you have at least `openldap`, and `sasl` libraries.

authentication so those are credentials to access your ldap, if it doesn't 

Base DN must have %(user)s template inside, it's a placer where your uid used

so you can control over permissions even on ldap users. If such user exists 

If you have problems with ldap access and believe you entered correct 

   Make sure you run this command from same virtualenv, and with the same user

your http server headers, than rhodecode will recognise this headers and make

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

Also when using root path with nginx you might set the static files to false

Besides the regular apache setup you will need to add such part to .ini file::

   double check the root path for your http setup. It should point to 

 - make sure you set a longer timeouts in your proxy/fcgi settings, timeouts

 - make sure you set a proper max_body_size for the http server

 - Make sure you added `WSGIPassAuthorization true`