Thomas Waldmann <tw-public@gmx.de>

    Lorenzo M. Catucci <lorenzo@sancho.ccd.uniroma2.it>

    Dmitri Kuznetsov

    Jared Bunting <jared.bunting@peachjean.com>

    Steve Romanow <slestak989@gmail.com>

    Augosto Hermann <augusto.herrmann@planejamento.gov.br>    

    Ankit Solanki <ankit.solanki@gmail.com>    

    Liad Shani <liadff@gmail.com>

recursive-include rhodecode/public/js *

- password: demo12

https://secure.rhodecode.org 

- Have built in users groups for easier permission management

- Repository groups let you group repos and manage them easier.

- Users can fork other users repo. RhodeCode have also compare view to see

  combined changeset for all changeset made within single push.

- Build in commit-api let's you add, edit and commit files right from RhodeCode

  interface using simple editor or upload form for binaries.

- Beautiful diffs, annotations and source code browsing all colored by pygments. 

  Raw diffs are made in git-diff format, including git_ binary-patches

- Server side forks. It is possible to fork a project and modify it freely 

  without breaking the main repository. You can even write Your own hooks 

  and install them

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

  high performance and always up to date data.

- Finer granular permissions per branch, repo group or subrepo

- pull requests and web based merges

- notification and message system 

- Redmine and other bugtrackers integration

- Other advancements as development continues (or you can of course make 

  additions and or requests)

pdebug = false

commit_parse_limit = 25

use_gravatar = true

#sqlalchemy.db1.url = sqlite:///%(here)s/rhodecode.db

sqlalchemy.db1.url = postgresql://postgres:qwe@localhost/rhodecode

sqlalchemy.db1.echo = false

level = DEBUG

level = DEBUG

datefmt = %Y-%m-%d %H:%M:%S

.. _api:

API

===

Starting from RhodeCode version 1.2 a simple API was implemented.

There's a single schema for calling all api methods. API is implemented

with JSON protocol both ways. An url to send API request in RhodeCode is 

<your_server>/_admin/api

All clients need to send JSON data in such format::

    {

        "api_key":"<api_key>",

        "method":"<method_name>",

        "args":{"<arg_key>":"<arg_val>"}

    }

Example call for autopulling remotes repos using curl::

    curl https://server.com/_admin/api -X POST -H 'content-type:text/plain' --data-binary '{"api_key":"xe7cdb2v278e4evbdf5vs04v832v0efvcbcve4a3","method":"pull","args":{"repo":"CPython"}}'

Simply provide 

 - *api_key* for access and permission validation.

 - *method* is name of method to call

 - *args* is an key:value list of arguments to pass to method

.. note::

    api_key can be found in your user account page    

RhodeCode API will return always a JSON formatted answer::

    {

        "result": "<result>", 

        "error": null

    }

All responses from API will be `HTTP/1.0 200 OK`, if there's an error while

calling api *error* key from response will contain failure description 

and result will be null.

API METHODS

+++++++++++

pull

----

Pulls given repo from remote location. Can be used to automatically keep 

remote repos up to date. This command can be executed only using api_key 

belonging to user with admin rights

INPUT::

    api_key:"<api_key>"

    method: "pull"

    args: {"repo":<repo_name>}

OUTPUT::

    result:"Pulled from <repo_name>"

    error:null

create_user

-----------

Creates new user in RhodeCode. This command can be executed only using api_key 

belonging to user with admin rights

INPUT::

    api_key:"<api_key>"

    method: "create_user"

    args: {"username": "<username>", 

           "password": "<password>", 

           "active":   "<bool>", 

           "admin":    "<bool>", 

           "name":     "<firstname>", 

           "lastname": "<lastname>", 

           "email":    "<useremail>"}

OUTPUT::

    result:{"id": <newuserid>,

            "msg":"created new user <username>"}

    error:null

create_users_group

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

creates new users group. This command can be executed only using api_key 

belonging to user with admin rights

INPUT::

    api_key:"<api_key>"

    method: "create_user"

    args: {"name":  "<groupname>", 

           "active":"<bool>"}

OUTPUT::

    result:{"id": <newusersgroupid>,

            "msg":"created new users group <groupname>"}

    error:null    

   api 

1.2.0 (**2011-10-07**)

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

news

----

- implemented #47 repository groups

- implemented #89 Can setup google analytics code from settings menu

- implemented #91 added nicer looking archive urls with more download options

  like tags, branches

- implemented #44 into file browsing, and added follow branch option

- implemented #84 downloads can be enabled/disabled for each repository

- anonymous repository can be cloned without having to pass default:default

  into clone url

- fixed #90 whoosh indexer can index chooses repositories passed in command 

  line

- extended journal with day aggregates and paging

- implemented #107 source code lines highlight ranges

- implemented #93 customizable changelog on combined revision ranges - 

  equivalent of githubs compare view 

- implemented #108 extended and more powerful LDAP configuration

- implemented #56 users groups

- major code rewrites optimized codes for speed and memory usage

- raw and diff downloads are now in git format

- setup command checks for write access to given path

- fixed many issues with international characters and unicode. It uses utf8

  decode with replace to provide less errors even with non utf8 encoded strings

- #125 added API KEY access to feeds

- #109 Repository can be created from external Mercurial link (aka. remote 

  repository, and manually updated (via pull) from admin panel

- beta git support - push/pull server + basic view for git repos

- added followers page and forks page

- server side file creation (with binary file upload interface) 

  and edition with commits powered by codemirror 

- #111 file browser file finder, quick lookup files on whole file tree 

- added quick login sliding menu into main page

- changelog uses lazy loading of affected files details, in some scenarios 

  this can improve speed of changelog page dramatically especially for 

  larger repositories.

- implements #214 added support for downloading subrepos in download menu.

- Added basic API for direct operations on rhodecode via JSON

- Implemented advanced hook management

fixes

-----

- fixed file browser bug, when switching into given form revision the url was 

  not changing

- fixed propagation to error controller on simplehg and simplegit middlewares

- fixed error when trying to make a download on empty repository

- fixed problem with '[' chars in commit messages in journal

- fixed #99 Unicode errors, on file node paths with non utf-8 characters

- journal fork fixes

- removed issue with space inside renamed repository after deletion

- fixed strange issue on formencode imports

- fixed #126 Deleting repository on Windows, rename used incompatible chars. 

- #150 fixes for errors on repositories mapped in db but corrupted in 

  filesystem

- fixed problem with ascendant characters in realm #181

- fixed problem with sqlite file based database connection pool

- whoosh indexer and code stats share the same dynamic extensions map

- fixes #188 - relationship delete of repo_to_perm entry on user removal

- fixes issue #189 Trending source files shows "show more" when no more exist

- fixes issue #197 Relative paths for pidlocks

- fixes issue #198 password will require only 3 chars now for login form

- fixes issue #199 wrong redirection for non admin users after creating a repository

- fixes issues #202, bad db constraint made impossible to attach same group 

  more than one time. Affects only mysql/postgres

- fixes #218 os.kill patch for windows was missing sig param

- improved rendering of dag (they are not trimmed anymore when number of 

  heads exceeds 5)

   usage/general

   usage/enable_git

   usage/statistics

   usage/backup

   usage/api_key_access

``RhodeCode`` is written entirely in Python. Before posting any issues make 

sure, your not missing any system libraries and using right version of 

libraries required by RhodeCode. There's also restriction in terms of mercurial

clients. Minimal version of hg client known working fine with RhodeCode is

**1.6**. If you're using older client, please upgrade.

For installing RhodeCode i highly recommend using separate virtualenv_. This

way many required by RhodeCode libraries will remain sandboxed from your main

python and making things less problematic when doing system python updates. 

- Assuming you have installed virtualenv_ create a new virtual environment 

  using virtualenv command:: 

- Make a folder for rhodecode data files, and configuration somewhere on the 

  filesystem. For example::

- Go into the created directory run this command to install rhodecode::

    easy_install rhodecode

  or::

    pip install rhodecode 

- This will install rhodecode together with pylons and all other required 

  python libraries into activated virtualenv

In order to gain maximum performance

there are some third-party you must install. When RhodeCode is used 

together with celery you have to install some kind of message broker,

recommended one is rabbitmq_ to make the async tasks work.

Of course RhodeCode works in sync mode also and then you do not have to install

any third party applications. However, using Celery_ will give you a large 

speed improvement when using many big repositories. If you plan to use 

RhodeCode for say 7 to 10 repositories, RhodeCode will perform perfectly well 

without celery running.

If you make the decision to run RhodeCode with celery make sure you run 

celeryd using paster and message broker together with the application. 

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

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

following command to do this::

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

  port, email settings, usage of static files, cache, celery settings and 

  logging.

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.

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

  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.

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

  to the web app.

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

into the root. Test that you can browse your repository from within RhodeCode 

and then try cloning your repository from RhodeCode with::

RhodeCode currently only hosts repositories using http and https. (The addition

of ssh hosting is a planned future feature.) However you can easily use ssh in

In order to use ssh you need to make sure that your web-server and the users 

login accounts have the correct permissions set on the appropriate directories.

(Note that these permissions are independent of any permissions you have set up

using the RhodeCode web interface.)

file that stores the location of the index. You may specify the location of the 

repositories (`--repo-location`).  If not specified, this value is retrieved 

from the RhodeCode database.  This was required prior to 1.2.  Starting from 

version 1.2 it is also possible to specify a comma separated list of 

repositories (`--index-only`) to build index only on chooses repositories 

skipping any other found in repos location

	paster make-index production.ini 

	paster make-index production.ini -f 

building index just for chosen repositories is possible with such command::

 paster make-index production.ini --index-only=vcs,rhodecode

    /path/to/python/bin/paster make-index /path/to/rhodecode/production.ini 

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

available via pypi, so you can install it by running

using easy_install::

    easy_install python-ldap

using pip::

    pip install python-ldap

LDAP settings are located in admin->ldap section,

 Connection settings

 Enable LDAP          = checked

 Host                 = host.example.org

 Port                 = 389

 Account              = <account>

 Password             = <password>

 Connection Security  = LDAPS connection

 Certificate Checks   = DEMAND

 Search settings

 Base DN              = CN=users,DC=host,DC=example,DC=org

 LDAP Filter          = (&(objectClass=user)(!(objectClass=computer)))

 LDAP Search Scope    = SUBTREE

 Attribute mappings

 Login Attribute      = uid

 First Name Attribute = firstName

 Last Name Attribute  = lastName

 E-mail Attribute     = mail

.. _enable_ldap:

Enable LDAP : required

    Whether to use LDAP for authenticating users.

.. _ldap_host:

Host : required

    LDAP server hostname or IP address.

.. _Port:

Port : required

    389 for un-encrypted LDAP, 636 for SSL-encrypted LDAP.

.. _ldap_account:

Account : optional

    Only required if the LDAP server does not allow anonymous browsing of

    records.  This should be a special account for record browsing.  This

    will require `LDAP Password`_ below.

.. _LDAP Password:

Password : optional

    Only required if the LDAP server does not allow anonymous browsing of

    records.

.. _Enable LDAPS:

Connection Security : required

    Defines the connection to LDAP server

    No encryption

        Plain non encrypted connection

    LDAPS connection

        Enable ldaps connection. It will likely require `Port`_ to be set to 

        a different value (standard LDAPS port is 636). When LDAPS is enabled 

        then `Certificate Checks`_ is required.

    START_TLS on LDAP connection

        START TLS connection

.. _Certificate Checks:

Certificate Checks : optional

    How SSL certificates verification is handled - this is only useful when

    `Enable LDAPS`_ is enabled.  Only DEMAND or HARD offer full SSL security 

    while the other options are susceptible to man-in-the-middle attacks.  SSL

    certificates can be installed to /etc/openldap/cacerts so that the

    DEMAND or HARD options can be used with self-signed certificates or

    certificates that do not have traceable certificates of authority.

    NEVER

        A serve certificate will never be requested or checked.

    ALLOW

        A server certificate is requested.  Failure to provide a

        certificate or providing a bad certificate will not terminate the

        session.

    TRY

        A server certificate is requested.  Failure to provide a

        certificate does not halt the session; providing a bad certificate

        halts the session.

    DEMAND

        A server certificate is requested and must be provided and

        authenticated for the session to proceed.

    HARD

        The same as DEMAND.

.. _Base DN:

Base DN : required

    The Distinguished Name (DN) where searches for users will be performed.

    Searches can be controlled by `LDAP Filter`_ and `LDAP Search Scope`_.

.. _LDAP Filter:

LDAP Filter : optional

    A LDAP filter defined by RFC 2254.  This is more useful when `LDAP

    Search Scope`_ is set to SUBTREE.  The filter is useful for limiting

    which LDAP objects are identified as representing Users for

    authentication.  The filter is augmented by `Login Attribute`_ below.

    This can commonly be left blank.

.. _LDAP Search Scope:

LDAP Search Scope : required

    This limits how far LDAP will search for a matching object.

    BASE

        Only allows searching of `Base DN`_ and is usually not what you

        want.

    ONELEVEL

        Searches all entries under `Base DN`_, but not Base DN itself.

    SUBTREE

        Searches all entries below `Base DN`_, but not Base DN itself.

        When using SUBTREE `LDAP Filter`_ is useful to limit object

        location.

.. _Login Attribute:

Login Attribute : required