whitespace cleanup

README.rst

@@ -1,179 +1,179 b''
 =========
 RhodeCode
 =========
 
 About
 -----
 
 ``RhodeCode`` is a fast and powerful management tool for Mercurial_ and GIT_ 
 with a built in push/pull server and full text search and code-review.
 It works on http/https and has a built in permission/authentication system with 
 the ability to authenticate via LDAP or ActiveDirectory. RhodeCode also provides
 simple API so it's easy integrable with existing external systems.
 
 RhodeCode is similar in some respects to github_ or bitbucket_, 
 however RhodeCode can be run as standalone hosted application on your own server.
 It is open source and donation ware and focuses more on providing a customized, 
 self administered interface for Mercurial_ and GIT_  repositories. 
 RhodeCode works on \*nix systems and Windows it is powered by a vcs_ library 
 that Lukasz Balcerzak and Marcin Kuzminski created to handle multiple 
 different version control systems.
 
 RhodeCode uses `PEP386 versioning <http://www.python.org/dev/peps/pep-0386/>`_
 
 Installation
 ------------
 Stable releases of RhodeCode are best installed via::
 
     easy_install rhodecode
 
 Or::
 
     pip install rhodecode 
 
 Detailed instructions and links may be found on the Installation page.
 
 Please visit http://packages.python.org/RhodeCode/installation.html for
 more details
 
 RhodeCode demo
 --------------
 
 http://demo.rhodecode.org
 
 The default access is anonymous but you can login to an administrative account
 using the following credentials:
 
 - username: demo
 - password: demo12
 
 Source code
 -----------
 
 The latest sources can be obtained from official RhodeCode instance
 https://secure.rhodecode.org 
 
 
 MIRRORS:
 
 Issue tracker and sources at bitbucket_
 
 http://bitbucket.org/marcinkuzminski/rhodecode
 
 Sources at github_
 
 https://github.com/marcinkuzminski/rhodecode
 
 
 RhodeCode Features
 ------------------
 
 - Has its own middleware to handle mercurial_ and git_ protocol requests. 
   Each request is authenticated and logged together with IP address.
 - Build for speed and performance. You can make multiple pulls/pushes simultaneous.
   Proven to work with 1000s of repositories and users
 - Supports http/https, LDAP, AD, proxy-pass authentication.
 - Full permissions (private/read/write/admin) together with IP restrictions for each repository,
   additional explicit forking and repository creation permissions.
 - Users groups for easier permission management
 - Repository groups let you group repos and manage them easier.
 - Users can fork other users repos, and compare them at any time.
 - Integrates easily with other systems, with custom created mappers you can connect it to almost
   any issue tracker, and with an JSON-RPC API you can make much more
 - Build in commit-api let's you add, edit and commit files right from RhodeCode
   web interface using simple editor or upload binary files using simple form.
 - Powerfull pull-request driven review system with inline commenting,
   changeset statuses, and notification system.
 - Importing and syncing repositories from remote locations for GIT_, Mercurial_ and  SVN.
 - Mako templates let's you customize the look and feel of the application.
 - Beautiful diffs, annotations and source code browsing all colored by pygments. 
   Raw diffs are made in git-diff format for both VCS systems, including GIT_ binary-patches
 - Mercurial_ and Git_ DAG graphs and yui-flot powered graphs with zooming and statistics
   to track activity for repositories
 - Admin interface with user/permission management. Admin activity journal, logs
   pulls, pushes, forks, registrations and other actions made by all users.
 - Server side forks. It is possible to fork a project and modify it freely 
   without breaking the main repository.
 - rst and markdown README support for repositories. 
 - Full text search powered by Whoosh on the source files, commit messages, and file names.
   Build in indexing daemons, with optional incremental index build
   (no external search servers required all in one application)
 - Setup project descriptions/tags and info inside built in db for easy, non 
   file-system operations.
 - Intelligent cache with invalidation after push or project change, provides 
   high performance and always up to date data.
 - RSS / Atom feeds, gravatar support, downloadable sources as zip/tar/gz
 - Optional async tasks for speed and performance using celery_  
 - Backup scripts can do backup of whole app and send it over scp to desired 
   location 
 - Based on pylons / sqlalchemy / sqlite / whoosh / vcs
 
     
 Incoming / Plans
 ----------------
 
 - Finer granular permissions per branch, or subrepo
 - Web based merges for pull requests
 - Tracking history for each lines in files
 - Simple issue tracker 
 - SSH based authentication with server side key management
 - Commit based built in wiki system
 - Gist server
 - More statistics and graph (global annotation + some more statistics)
 - Other advancements as development continues (or you can of course make 
   additions and or requests)
 
 License
 -------
 
 ``RhodeCode`` is released under the GPLv3 license.
 
 
 Getting help
 ------------
 
 Listed bellow are various support resources that should help.
 
 .. note::
    
    Please try to read the documentation before posting any issues, especially
    the **troubleshooting section**
  
 - Join the `Google group <http://groups.google.com/group/rhodecode>`_ and ask
   any questions.
 
 - Open an issue at `issue tracker <http://bitbucket.org/marcinkuzminski/rhodecode/issues>`_
 
 - Join #rhodecode on FreeNode (irc.freenode.net)
   or use http://webchat.freenode.net/?channels=rhodecode for web access to irc.
 
 - You can also follow me on twitter **@marcinkuzminski** where i often post some
   news about RhodeCode
 
 
 Online documentation
 --------------------
 
 Online documentation for the current version of RhodeCode is available at
  - http://packages.python.org/RhodeCode/
  - http://rhodecode.readthedocs.org/en/latest/index.html
 
 You may also build the documentation for yourself - go into ``docs/`` and run::
 
    make html
 
 (You need to have sphinx_ installed to build the documentation. If you don't
 have sphinx_ installed you can install it via the command: 
 ``easy_install sphinx``)
  
 .. _virtualenv: http://pypi.python.org/pypi/virtualenv
 .. _python: http://www.python.org/
 .. _sphinx: http://sphinx.pocoo.org/
 .. _mercurial: http://mercurial.selenic.com/
 .. _bitbucket: http://bitbucket.org/
 .. _github: http://github.com/
 .. _subversion: http://subversion.tigris.org/
 .. _git: http://git-scm.com/
 .. _celery: http://celeryproject.org/
 .. _Sphinx: http://sphinx.pocoo.org/
-.. _vcs: http://pypi.python.org/pypi/vcs
  No newline at end of file
+.. _vcs: http://pypi.python.org/pypi/vcs

docs/api/api.rst

@@ -1,959 +1,959 b''
 .. _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 to RhodeCode is
 <your_server>/_admin/api
 
 API ACCESS FOR WEB VIEWS
 ++++++++++++++++++++++++
 
 API access can also be turned on for each web view in RhodeCode that is 
 decorated with `@LoginRequired` decorator. To enable API access simple change 
 the standard login decorator to `@LoginRequired(api_access=True)`. 
 After this change, a rhodecode view can be accessed without login by adding a 
 GET parameter `?api_key=<api_key>` to url. By default this is only
 enabled on RSS/ATOM feed views.
 
 
 API ACCESS
 ++++++++++
 
 All clients are required to send JSON-RPC spec JSON data::
 
     {   
         "id:"<id>",
         "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 '{"id":1,"api_key":"xe7cdb2v278e4evbdf5vs04v832v0efvcbcve4a3","method":"pull","args":{"repo":"CPython"}}'
 
 Simply provide
  - *id* A value of any type, which is used to match the response with the request that it is replying to.
  - *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-RPC response::
 
     {   
         "id":<id>, # matching id sent by request
         "result": "<result>"|null, # JSON formatted result, null if any errors
         "error": "null"|<error_message> # JSON formatted error (if any)
     }
 
 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 CLIENT
 ++++++++++
 
 From version 1.4 RhodeCode adds a script that allows to easily
 communicate with API. After installing RhodeCode a `rhodecode-api` script
 will be available.
 
 To get started quickly simply run::
 
   rhodecode-api _create_config --apikey=<youapikey> --apihost=<rhodecode host>
  
 This will create a file named .config in the directory you executed it storing
 json config file with credentials. You can skip this step and always provide
 both of the arguments to be able to communicate with server
 
 
 after that simply run any api command for example get_repo::
  
  rhodecode-api get_repo
 
  calling {"api_key": "<apikey>", "id": 75, "args": {}, "method": "get_repo"} to http://127.0.0.1:5000
  rhodecode said:
  {'error': 'Missing non optional `repoid` arg in JSON DATA',
   'id': 75,
   'result': None}
 
 Ups looks like we forgot to add an argument
 
 Let's try again now giving the repoid as parameters::
 
     rhodecode-api get_repo repoid:rhodecode   
  
     calling {"api_key": "<apikey>", "id": 39, "args": {"repoid": "rhodecode"}, "method": "get_repo"} to http://127.0.0.1:5000
     rhodecode said:
     {'error': None,
      'id': 39,
      'result': <json data...>}
 
 
 
 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::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method :  "pull"
     args :    {
                 "repoid" : "<reponame or repo_id>"
               }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result : "Pulled from `<reponame>`"
     error :  null
 
 
 rescan_repos
 ------------
 
 Dispatch rescan repositories action. If remove_obsolete is set
 RhodeCode will delete repos that are in database but not in the filesystem.
 This command can be executed only using api_key belonging to user with admin 
 rights.
 
 INPUT::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method :  "rescan_repos"
     args :    {
                 "remove_obsolete" : "<boolean = Optional(False)>"
               }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result : "{'added': [<list of names of added repos>], 
                'removed': [<list of names of removed repos>]}"
     error :  null
 
 
 lock
 ----
 
 Set locking state on given repository by given user. If userid param is skipped
 , then it is set to id of user whos calling this method.
 This command can be executed only using api_key belonging to user with admin 
 rights or regular user that have admin or write access to repository.
 
 INPUT::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method :  "lock"
     args :    {
                 "repoid" : "<reponame or repo_id>"
                 "userid" : "<user_id or username = Optional(=apiuser)>",
                 "locked" : "<bool true|false>"
               }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result : "User `<username>` set lock state for repo `<reponame>` to `true|false`"
     error :  null
 
 
 show_ip
 -------
 
 Shows IP address as seen from RhodeCode server, together with all
 defined IP addresses for given user.
 This command can be executed only using api_key belonging to user with admin 
 rights.
 
 INPUT::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method :  "show_ip"
     args :    {
                 "userid" : "<user_id or username>",
               }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result : {
                  "ip_addr_server": <ip_from_clien>",
                  "user_ips": [
                                 {
                                    "ip_addr": "<ip_with_mask>",
                                    "ip_range": ["<start_ip>", "<end_ip>"],
                                 },
                                 ...
                              ]
              }
     
     error :  null
 
 
 get_user
 --------
 
 Get's an user by username or user_id, Returns empty result if user is not found.
 If userid param is skipped it is set to id of user who is calling this method.
 This command can be executed only using api_key belonging to user with admin 
 rights, or regular users that cannot specify different userid than theirs
 
 
 INPUT::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method :  "get_user"
     args :    { 
                 "userid" : "<username or user_id Optional(=apiuser)>"
               }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result: None if user does not exist or 
             {
                 "user_id" :     "<user_id>",
                 "api_key" :     "<api_key>",
                 "username" :    "<username>",
                 "firstname":    "<firstname>",
                 "lastname" :    "<lastname>",
                 "email" :       "<email>",
                 "emails":       "<list_of_all_additional_emails>",
                 "ip_addresses": "<list_of_ip_addresses_for_user>",
                 "active" :      "<bool>",
                 "admin" :       "<bool>",
                 "ldap_dn" :     "<ldap_dn>",
                 "last_login":   "<last_login>",
                 "permissions": {
                     "global": ["hg.create.repository",
                                "repository.read",
                                "hg.register.manual_activate"],
                     "repositories": {"repo1": "repository.none"},
                     "repositories_groups": {"Group1": "group.read"}
                  },
             }
 
     error:  null
 
 
 get_users
 ---------
 
 Lists all existing users. This command can be executed only using api_key
 belonging to user with admin rights.
 
 
 INPUT::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method :  "get_users"
     args :    { }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result: [
               {
                 "user_id" :     "<user_id>",
                 "username" :    "<username>",
                 "firstname":    "<firstname>",
                 "lastname" :    "<lastname>",
                 "email" :       "<email>",
                 "emails":       "<list_of_all_additional_emails>",
                 "ip_addresses": "<list_of_ip_addresses_for_user>",
                 "active" :      "<bool>",
                 "admin" :       "<bool>",
                 "ldap_dn" :     "<ldap_dn>",
                 "last_login":   "<last_login>",
               },
     	      …
             ]
     error:  null
 
 
 create_user
 -----------
 
 Creates new user. This command can 
 be executed only using api_key belonging to user with admin rights.
 
 
 INPUT::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method :  "create_user"
     args :    {
                 "username" :  "<username>",
                 "email" :     "<useremail>",
                 "password" :  "<password>",
                 "firstname" : "<firstname> = Optional(None)",
                 "lastname" :  "<lastname> = Optional(None)",
                 "active" :    "<bool> = Optional(True)",
                 "admin" :     "<bool> = Optional(False)",
                 "ldap_dn" :   "<ldap_dn> = Optional(None)"
               }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result: {
               "msg" : "created new user `<username>`",
               "user": {
                 "user_id" :  "<user_id>",
                 "username" : "<username>",
                 "firstname": "<firstname>",
                 "lastname" : "<lastname>",
                 "email" :    "<email>",
                 "emails":    "<list_of_all_additional_emails>",
                 "active" :   "<bool>",
                 "admin" :    "<bool>",
                 "ldap_dn" :  "<ldap_dn>",
                 "last_login": "<last_login>",
               },
             }
     error:  null
 
 
 update_user
 -----------
 
 updates given user if such user exists. This command can 
 be executed only using api_key belonging to user with admin rights.
 
 
 INPUT::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method :  "update_user"
     args :    {
                 "userid" : "<user_id or username>",
                 "username" :  "<username> = Optional(None)",
                 "email" :     "<useremail> = Optional(None)",
                 "password" :  "<password> = Optional(None)",
                 "firstname" : "<firstname> = Optional(None)",
                 "lastname" :  "<lastname> = Optional(None)",
                 "active" :    "<bool> = Optional(None)",
                 "admin" :     "<bool> = Optional(None)",
                 "ldap_dn" :   "<ldap_dn> = Optional(None)"
               }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result: {
               "msg" : "updated user ID:<userid> <username>",
               "user": {
                 "user_id" :  "<user_id>",
                 "username" : "<username>",
                 "firstname": "<firstname>",
                 "lastname" : "<lastname>",
                 "email" :    "<email>",
                 "emails":    "<list_of_all_additional_emails>",
                 "active" :   "<bool>",
                 "admin" :    "<bool>",
                 "ldap_dn" :  "<ldap_dn>",
                 "last_login": "<last_login>",
               },              
             }
     error:  null
 
 
 delete_user
 -----------
 
 
 deletes givenuser if such user exists. This command can 
 be executed only using api_key belonging to user with admin rights.
 
 
 INPUT::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method :  "delete_user"
     args :    {
                 "userid" : "<user_id or username>",
               }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result: {
               "msg" : "deleted user ID:<userid> <username>",
               "user": null
             }
     error:  null
 
 
 get_users_group
 ---------------
 
 Gets an existing users group. This command can be executed only using api_key
 belonging to user with admin rights.
 
 
 INPUT::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method :  "get_users_group"
     args :    {
                 "usersgroupid" : "<users group id or name>"
               }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result : None if group not exist
              {
                "users_group_id" : "<id>",
                "group_name" :     "<groupname>",
                "active":          "<bool>",
                "members" :  [
                               { 
                                 "user_id" :  "<user_id>",
                                 "username" : "<username>",
                                 "firstname": "<firstname>",
                                 "lastname" : "<lastname>",
                                 "email" :    "<email>",
                                 "emails":    "<list_of_all_additional_emails>",
                                 "active" :   "<bool>",
                                 "admin" :    "<bool>",
                                 "ldap_dn" :  "<ldap_dn>",
                                 "last_login": "<last_login>",
                               },
                               …
                             ]
              }
     error : null
 
 
 get_users_groups
 ----------------
 
 Lists all existing users groups. This command can be executed only using 
 api_key belonging to user with admin rights.
 
 
 INPUT::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method :  "get_users_groups"
     args :    { }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result : [
                {
                "users_group_id" : "<id>",
                "group_name" :     "<groupname>",
                "active":          "<bool>",
                },
                …
               ]
     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::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method :  "create_users_group"
     args:     {
                 "group_name":  "<groupname>",
                 "active":"<bool> = Optional(True)"
               }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result: {
               "msg": "created new users group `<groupname>`",
               "users_group": {
                      "users_group_id" : "<id>",
                      "group_name" :     "<groupname>",
                      "active":          "<bool>",
                },
             }
     error:  null
 
 
 add_user_to_users_group
 -----------------------
 
 Adds a user to a users group. If user exists in that group success will be 
 `false`. This command can be executed only using api_key
 belonging to user with admin rights
 
 
 INPUT::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method :  "add_user_users_group"
     args:     {
                 "usersgroupid" : "<users group id or name>",
                 "userid" : "<user_id or username>",
               }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result: {
               "success": True|False # depends on if member is in group
               "msg": "added member `<username>` to users group `<groupname>` | 
                       User is already in that group"
             }
     error:  null
 
 
 remove_user_from_users_group
 ----------------------------
 
 Removes a user from a users group. If user is not in given group success will
 be `false`. This command can be executed only 
 using api_key belonging to user with admin rights
 
 
 INPUT::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method :  "remove_user_from_users_group"
     args:     {
                 "usersgroupid" : "<users group id or name>",
                 "userid" : "<user_id or username>",
               }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result: {
               "success":  True|False,  # depends on if member is in group
               "msg": "removed member <username> from users group <groupname> | 
                       User wasn't in group"
             }
     error:  null
 
 
 get_repo
 --------
 
 Gets an existing repository by it's name or repository_id. Members will return
 either users_group or user associated to that repository. This command can be 
 executed only using api_key belonging to user with admin 
 rights or regular user that have at least read access to repository.
 
 
 INPUT::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method :  "get_repo"
     args:     {
                 "repoid" : "<reponame or repo_id>"
               }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result: None if repository does not exist or
             {
                 "repo_id" :          "<repo_id>",
                 "repo_name" :        "<reponame>"
                 "repo_type" :        "<repo_type>",
                 "clone_uri" :        "<clone_uri>",
                 "enable_downloads":  "<bool>",
                 "enable_locking":    "<bool>",
                 "enable_statistics": "<bool>",                
                 "private":           "<bool>",
                 "created_on" :       "<date_time_created>",                
                 "description" :      "<description>",
                 "landing_rev":       "<landing_rev>",
                 "last_changeset":    {
                                        "author":   "<full_author>",
                                        "date":     "<date_time_of_commit>",
                                        "message":  "<commit_message>",
                                        "raw_id":   "<raw_id>",
                                        "revision": "<numeric_revision>",
                                        "short_id": "<short_id>"
                                      }
                 "owner":             "<repo_owner>",
                 "fork_of":           "<name_of_fork_parent>",
                 "members" :     [
                                   { 
                                     "type":        "user",
                                     "user_id" :    "<user_id>",
                                     "username" :   "<username>",
                                     "firstname":   "<firstname>",
                                     "lastname" :   "<lastname>",
                                     "email" :      "<email>",
                                     "emails":      "<list_of_all_additional_emails>",
                                     "active" :     "<bool>",
                                     "admin" :      "<bool>",
                                     "ldap_dn" :    "<ldap_dn>",
                                     "last_login":  "<last_login>",
                                     "permission" : "repository.(read|write|admin)"
                                   },
                                   …
                                   { 
                                     "type":      "users_group",
                                     "id" :       "<usersgroupid>",
                                     "name" :     "<usersgroupname>",
                                     "active":    "<bool>",
                                     "permission" : "repository.(read|write|admin)"
                                   },
                                   …
                                 ]
                  "followers":   [
                                   {
                                     "user_id" :     "<user_id>",
                                     "username" :    "<username>",
                                     "firstname":    "<firstname>",
                                     "lastname" :    "<lastname>",
                                     "email" :       "<email>",
                                     "emails":       "<list_of_all_additional_emails>",
                                     "ip_addresses": "<list_of_ip_addresses_for_user>",
                                     "active" :      "<bool>",
                                     "admin" :       "<bool>",
                                     "ldap_dn" :     "<ldap_dn>",
                                     "last_login":   "<last_login>",                                    
                                   },
                                   …           
                  ]
             }
     error:  null
 
 
 get_repos
 ---------
 
 Lists all existing repositories. This command can be executed only using 
 api_key belonging to user with admin rights or regular user that have 
 admin, write or read access to repository.
 
 
 INPUT::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method :  "get_repos"
     args:     { }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result: [
               {
                 "repo_id" :          "<repo_id>",
                 "repo_name" :        "<reponame>"
                 "repo_type" :        "<repo_type>",
                 "clone_uri" :        "<clone_uri>",
                 "private": :         "<bool>",
                 "created_on" :       "<datetimecreated>",                
                 "description" :      "<description>",
                 "landing_rev":       "<landing_rev>",
                 "owner":             "<repo_owner>",
                 "fork_of":           "<name_of_fork_parent>",
                 "enable_downloads":  "<bool>",
                 "enable_locking":    "<bool>",
                 "enable_statistics": "<bool>",                   
               },
               …
             ]
     error:  null
 
 
 get_repo_nodes
 --------------
 
 returns a list of nodes and it's children in a flat list for a given path 
 at given revision. It's possible to specify ret_type to show only `files` or 
 `dirs`. This command can be executed only using api_key belonging to user 
 with admin rights
 
 
 INPUT::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method :  "get_repo_nodes"
     args:     {
                 "repoid" : "<reponame or repo_id>"
                 "revision"  : "<revision>",
                 "root_path" : "<root_path>",
                 "ret_type"  : "<ret_type> = Optional('all')"
               }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result: [
               {
                 "name" :        "<name>"
                 "type" :        "<type>",
               },
               …
             ]
     error:  null
 
 
 create_repo
 -----------
 
 Creates a repository. If repository name contains "/", all needed repository
 groups will be created. For example "foo/bar/baz" will create groups 
 "foo", "bar" (with "foo" as parent), and create "baz" repository with 
 "bar" as group. This command can be executed only using api_key belonging to user with admin 
 rights or regular user that have create repository permission. Regular users
 cannot specify owner parameter
 
 
 INPUT::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method :  "create_repo"
     args:     {
                 "repo_name" :        "<reponame>",
                 "owner" :            "<onwer_name_or_id = Optional(=apiuser)>",
                 "repo_type" :        "<repo_type> = Optional('hg')",
                 "description" :      "<description> = Optional('')",
                 "private" :          "<bool> = Optional(False)",
                 "clone_uri" :        "<clone_uri> = Optional(None)",
                 "landing_rev" :      "<landing_rev> = Optional('tip')",
                 "enable_downloads":  "<bool> = Optional(False)",
                 "enable_locking":    "<bool> = Optional(False)",
                 "enable_statistics": "<bool> = Optional(False)",
               }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result: {
               "msg": "Created new repository `<reponame>`",
               "repo": {
                 "repo_id" :          "<repo_id>",
                 "repo_name" :        "<reponame>"
                 "repo_type" :        "<repo_type>",
                 "clone_uri" :        "<clone_uri>",
                 "private": :         "<bool>",
                 "created_on" :       "<datetimecreated>",                
                 "description" :      "<description>",
                 "landing_rev":       "<landing_rev>",
                 "owner":             "<username or user_id>",
                 "fork_of":           "<name_of_fork_parent>",
                 "enable_downloads":  "<bool>",
                 "enable_locking":    "<bool>",
                 "enable_statistics": "<bool>",                     
               },
             }
     error:  null
 
 
 fork_repo
 ---------
 
 Creates a fork of given repo. In case of using celery this will
 immidiatelly return success message, while fork is going to be created
 asynchronous. This command can be executed only using api_key belonging to
 user with admin rights or regular user that have fork permission, and at least
 read access to forking repository. Regular users cannot specify owner parameter.
 
 
 INPUT::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method :  "fork_repo"
     args:     {
                 "repoid" :          "<reponame or repo_id>",
                 "fork_name":        "<forkname>",
                 "owner":            "<username or user_id = Optional(=apiuser)>",
                 "description":      "<description>",
                 "copy_permissions": "<bool>",
                 "private":          "<bool>",
                 "landing_rev":      "<landing_rev>"
                                 
               }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result: {
               "msg": "Created fork of `<reponame>` as `<forkname>`",
               "success": true
             }
     error:  null
 
 
 delete_repo
 -----------
 
 Deletes a repository. This command can be executed only using api_key belonging to user with admin 
 rights or regular user that have admin access to repository.
 
 
 INPUT::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method :  "delete_repo"
     args:     {
                 "repoid" : "<reponame or repo_id>"
               }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result: {
               "msg": "Deleted repository `<reponame>`",
               "success": true
             }
     error:  null
 
 
 grant_user_permission
 ---------------------
 
 Grant permission for user on given repository, or update existing one
 if found. This command can be executed only using api_key belonging to user 
 with admin rights.
 
 
 INPUT::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method :  "grant_user_permission"
     args:     {
                 "repoid" : "<reponame or repo_id>"
                 "userid" : "<username or user_id>"
                 "perm" :       "(repository.(none|read|write|admin))",
               }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result: {
               "msg" : "Granted perm: `<perm>` for user: `<username>` in repo: `<reponame>`",
               "success": true
             }
     error:  null
 
 
 revoke_user_permission
 ----------------------
 
 Revoke permission for user on given repository. This command can be executed 
 only using api_key belonging to user with admin rights.
 
 
 INPUT::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method  : "revoke_user_permission"
     args:     {
                 "repoid" : "<reponame or repo_id>"
                 "userid" : "<username or user_id>"
               }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result: {
               "msg" : "Revoked perm for user: `<username>` in repo: `<reponame>`",
               "success": true
             }
     error:  null
 
 
 grant_users_group_permission
 ----------------------------
 
 Grant permission for users group on given repository, or update
 existing one if found. This command can be executed only using 
 api_key belonging to user with admin rights.
 
 
 INPUT::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method :  "grant_users_group_permission"
     args:     {
                 "repoid" : "<reponame or repo_id>"
                 "usersgroupid" : "<users group id or name>"
                 "perm" : "(repository.(none|read|write|admin))",
               }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result: {
               "msg" : "Granted perm: `<perm>` for group: `<usersgroupname>` in repo: `<reponame>`",
               "success": true
             }
     error:  null
     
     
 revoke_users_group_permission
 -----------------------------
 
 Revoke permission for users group on given repository.This command can be 
 executed only using api_key belonging to user with admin rights.
 
 INPUT::
 
     id : <id_for_response>
     api_key : "<api_key>"
     method  : "revoke_users_group_permission"
     args:     {
                 "repoid" : "<reponame or repo_id>"
                 "usersgroupid" : "<users group id or name>"
               }
 
 OUTPUT::
 
     id : <id_given_in_input>
     result: {
               "msg" : "Revoked perm for group: `<usersgroupname>` in repo: `<reponame>`",
               "success": true
             }
-    error:  null
  No newline at end of file
+    error:  null

docs/api/models.rst

@@ -1,35 +1,35 b''
 .. _models:
 
 ========================
 The :mod:`models` Module
 ========================
 
 .. automodule:: rhodecode.model
    :members:
    
 .. automodule:: rhodecode.model.comment
    :members:
   
 .. automodule:: rhodecode.model.notification
    :members:   
 
 .. automodule:: rhodecode.model.permission
    :members:
 
 .. automodule:: rhodecode.model.repo_permission
    :members:      
 
 .. automodule:: rhodecode.model.repo
    :members:   
 
 .. automodule:: rhodecode.model.repos_group
    :members:
    
 .. automodule:: rhodecode.model.scm
    :members:
    
 .. automodule:: rhodecode.model.user
    :members:      
    
 .. automodule:: rhodecode.model.users_group
-   :members:   
  No newline at end of file
+   :members:

docs/index.rst

@@ -1,64 +1,64 b''
 .. _index:
 
 .. include:: ./../README.rst
 
 Users Guide
 -----------
 
 **Installation:**
 
 .. toctree::
    :maxdepth: 1
 
    installation
    setup
    upgrade
    
 **Usage**
 
 .. toctree::
    :maxdepth: 1
 
    usage/general
    usage/git_support
    usage/performance
    usage/locking
    usage/statistics
    usage/backup
    usage/subrepos
    usage/debugging
    usage/troubleshooting
 
 **Develop**
 
 .. toctree::
    :maxdepth: 1
    
    contributing
    changelog
 
 **API**
 
 .. toctree::
    :maxdepth: 1
 
    api/api
    api/models
    
 
 Other topics
 ------------
 
 * :ref:`genindex`
 * :ref:`search`
 
 .. _virtualenv: http://pypi.python.org/pypi/virtualenv
 .. _python: http://www.python.org/
 .. _django: http://www.djangoproject.com/
 .. _mercurial: http://mercurial.selenic.com/
 .. _bitbucket: http://bitbucket.org/
 .. _subversion: http://subversion.tigris.org/
 .. _git: http://git-scm.com/
 .. _celery: http://celeryproject.org/
 .. _Sphinx: http://sphinx.pocoo.org/
-.. _vcs: http://pypi.python.org/pypi/vcs
  No newline at end of file
+.. _vcs: http://pypi.python.org/pypi/vcs

docs/installation_win.rst

@@ -1,250 +1,250 b''
 .. _installation_win:
 
 
 Step by step Installation for Windows
 =====================================
 
 
 RhodeCode step-by-step install Guide for Windows  
 
 Target OS: Windows XP SP3 32bit English (Clean installation) 
 + All Windows Updates until 24-may-2012 
 
 .. note::
     
    This installation is for 32bit systems, for 64bit windows you might need
    to download proper 64bit version of "Windows Installer" and Win32py
    extensions
 
 Step1 - Install Visual Studio 2008 Express
 ------------------------------------------
 
  
 Optional: You can also install MingW, but VS2008 installation is easier 
 
 Download "Visual C++ 2008 Express Edition with SP1" from: 
 http://www.microsoft.com/visualstudio/en-us/products/2008-editions/express 
 (if not found or relocated, google for "visual studio 2008 express" for 
 updated link) 
 
 You can also download full ISO file for offline installation, just 
 choose "All - Offline Install ISO image file" in the previous page and 
 choose "Visual C++ 2008 Express" when installing. 
 
 
 .. note::
 
   Silverlight Runtime and SQL Server 2008 Express Edition are not 
   required, you can uncheck them 
 
 
 Step2 - Install Python
 ----------------------
 
 Install Python 2.x.y (x >= 5) x86 version (32bit). DO NOT USE A 3.x version.
 Download Python 2.x.y from: 
 http://www.python.org/download/ 
 
 Choose "Windows Installer" (32bit version) not "Windows X86-64 
 Installer". While writing this guide, the latest version was v2.7.3. 
 Remember the specific major and minor version installed, because it will 
 be needed in the next step. In this case, it is "2.7". 
 
 
 Step3 - Install Win32py extensions
 ----------------------------------
  
 Download pywin32 from: 
 http://sourceforge.net/projects/pywin32/files/ 
 
 - Click on "pywin32" folder 
 - Click on the first folder (in this case, Build 217, maybe newer when you try) 
 - Choose the file ending with ".win32-py2.x.exe" -> x being the minor 
   version of Python you installed (in this case, 7) 
   When writing this guide, the file was: 
   http://sourceforge.net/projects/pywin32/files/pywin32/Build%20217/pywin32-217.win32-py2.7.exe/download 
 
 
 Step4 - Python BIN
 ------------------
 
 Add Python BIN folder to the path 
 
 You have to add the Python folder to the path, you can do it manually 
 (editing "PATH" environment variable) or using Windows Support Tools 
 that came preinstalled in Vista/7 and can be installed in Windows XP. 
 
 - Using support tools on WINDOWS XP: 
   If you use Windows XP you can install them using Windows XP CD and 
   navigating to \SUPPORT\TOOLS. There, execute Setup.EXE (not MSI). 
   Afterwards, open a CMD and type::
  
     SETX PATH "%PATH%;[your-python-path]" -M 
 
   Close CMD (the path variable will be updated then) 
 
 - Using support tools on WINDOWS Vista/7: 
 
   Open a CMD and type::
 
     SETX PATH "%PATH%;[your-python-path]" /M 
 
   Please substitute [your-python-path] with your Python installation path. 
   Typically: C:\\Python27 
 
 
 Step5 - RhodeCode folder structure
 ----------------------------------
 
 Create a RhodeCode folder structure 
 
 This is only a example to install RhodeCode, you can of course change 
 it. However, this guide will follow the proposed structure, so please 
 later adapt the paths if you change them. My recommendation is to use 
 folders with NO SPACES. But you can try if you are brave... 
 
 Create the following folder structure::
 
   C:\RhodeCode 
   C:\RhodeCode\Bin 
   C:\RhodeCode\Env 
   C:\RhodeCode\Repos 
 
 
 Step6 - Install virtualenv
 ---------------------------
 
 Install Virtual Env for Python 
 
 Navigate to: http://www.virtualenv.org/en/latest/index.html#installation 
 Right click on "virtualenv.py" file and choose "Save link as...". 
 Download to C:\\RhodeCode (or whatever you want) 
 (the file is located at 
 https://raw.github.com/pypa/virtualenv/master/virtualenv.py) 
 
 Create a virtual Python environment in C:\\RhodeCode\\Env (or similar). To 
 do so, open a CMD (Python Path should be included in Step3), navigate 
 where you downloaded "virtualenv.py", and write:: 
 
  python virtualenv.py C:\RhodeCode\Env 
 
 (--no-site-packages is now the default behaviour of virtualenv, no need 
 to include it) 
 
 
 Step7 - Install RhodeCode
 -------------------------
 
 Finally, install RhodeCode 
 
 Close previously opened command prompt/s, and open a Visual Studio 2008 
 Command Prompt (**IMPORTANT!!**). To do so, go to Start Menu, and then open 
 "Microsoft Visual C++ 2008 Express Edition" -> "Visual Studio Tools" -> 
 "Visual Studio 2008 Command Prompt" 
 
 In that CMD (loaded with VS2008 PATHs) type::
  
   cd C:\RhodeCode\Env\Scripts (or similar) 
   activate 
 
 The prompt will change into "(Env) C:\\RhodeCode\\Env\\Scripts" or similar 
 (depending of your folder structure). Then type:: 
 
  pip install rhodecode 
 
 (long step, please wait until fully complete) 
 
 Some warnings will appear, don't worry as they are normal.
 
 
 Step8 - Configuring RhodeCode
 -----------------------------
 
 
 steps taken from http://packages.python.org/RhodeCode/setup.html 
 
 You have to use the same Visual Studio 2008 command prompt as Step7, so 
 if you closed it reopen it following the same commands (including the 
 "activate" one). When ready, just type::
  
   cd C:\RhodeCode\Bin 
   paster make-config RhodeCode production.ini 
 
 Then, you must edit production.ini to fit your needs (ip address, ip 
 port, mail settings, database, whatever). I recommend using NotePad++ 
 (free) or similar text editor, as it handles well the EndOfLine 
 character differences between Unix and Windows 
 (http://notepad-plus-plus.org/) 
 
 For the sake of simplicity lets run it with the default settings. After 
 your edits (if any), in the previous Command Prompt, type:: 
  
  paster setup-rhodecode production.ini 
 
 (this time a NEW database will be installed, you must follow a different 
 step to later UPGRADE to a newer RhodeCode version) 
 
 The script will ask you for confirmation about creating a NEW database, 
 answer yes (y) 
 The script will ask you for repository path, answer C:\\RhodeCode\\Repos 
 (or similar) 
 The script will ask you for admin username and password, answer "admin" 
 + "123456" (or whatever you want) 
 The script will ask you for admin mail, answer "[e-mail]" (or 
 whatever you want) 
 
 If you make some mistake and the script does not end, don't worry, start 
 it again. 
 
 
 Step9 - Running RhodeCode
 -------------------------
 
 
 In the previous command prompt, being in the C:\\RhodeCode\\Bin folder, 
 just type::
  
  paster serve production.ini 
 
 Open yout web server, and go to http://127.0.0.1:5000 
 
 It works!! :-) 
 
 Remark: 
 If it does not work first time, just Ctrl-C the CMD process and start it 
 again. Don't forget the "http://" in Internet Explorer 
 
 
 
 What this Guide does not cover:
 
 - Installing Celery 
 - Running RhodeCode as Windows Service. You can investigate here:
  
   - http://pypi.python.org/pypi/wsgisvc 
   - http://ryrobes.com/python/running-python-scripts-as-a-windows-service/     
   - http://wiki.pylonshq.com/display/pylonscookbook/How+to+run+Pylons+as+a+Windows+service 
 
 - Using Apache. You can investigate here:
 
   - https://groups.google.com/group/rhodecode/msg/c433074e813ffdc4 
 
 
 Upgrading
 =========
  
 Stop running RhodeCode 
 Open a CommandPrompt like in Step7 (VS2008 path + activate) and type::
  
  easy_install -U rhodecode 
  cd \RhodeCode\Bin 
 
 { backup your production.ini file now} :: 
 
  paster make-config RhodeCode production.ini 
 
 (check changes and update your production.ini accordingly) ::
  
  paster upgrade-db production.ini (update database)
 
-Full steps in http://packages.python.org/RhodeCode/upgrade.html 
  No newline at end of file
+Full steps in http://packages.python.org/RhodeCode/upgrade.html

docs/setup.rst

@@ -1,725 +1,725 b''
 .. _setup:
 
 =====
 Setup
 =====
 
 
 Setting up RhodeCode
 --------------------
 
 First, you will need to create a RhodeCode configuration file. Run the 
 following command to do this::
  
     paster make-config RhodeCode production.ini
 
 - This will create the file `production.ini` in the current directory. This
   configuration file contains the various settings for RhodeCode, e.g proxy 
   port, email settings, usage of static files, cache, celery settings and 
   logging.
 
 
 Next, you need to create the databases used by RhodeCode. I recommend that you
 use postgresql or sqlite (default). 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. RhodeCode currently supports
 postgresql, sqlite and mysql databases. Create the database by running
 the following command::
 
     paster setup-rhodecode production.ini
 
 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-rhodecode`` will also prompt you for a username 
 and password for the initial admin account which ``setup-rhodecode`` sets 
 up for you.
 
 setup process can be fully automated, example for lazy::
 
     paster setup-rhodecode production.ini --user=marcink --password=secret --email=[e-mail] --repos=/home/marcink/my_repos
     
 
 - The ``setup-rhodecode`` 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::
  
     paster serve production.ini
  
 - This command runs the RhodeCode server. The web app should be available at the 
   127.0.0.1:5000. This ip and port is configurable via the production.ini 
   file created in previous step
 - Use the admin account you created above when running ``setup-rhodecode`` 
   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
 
 Optionally users can create `rcextensions` package that extends RhodeCode
 functionality. To do this simply execute::
 
     paster make-rcext production.ini
 
 This will create `rcextensions` package in the same place that your `ini` file
 lives. With `rcextensions` it's possible to add additional mapping for whoosh, 
 stats and add additional code into the push/pull/create/delete repo hooks.
 For example for sending signals to build-bots such as jenkins.
 Please see the `__init__.py` file inside `rcextensions` package 
 for more details.
 
 
 Using RhodeCode with SSH
 ------------------------
 
 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
 parallel with RhodeCode. (Repository access via ssh is a standard "out of
 the box" feature of mercurial_ and you can use this to access any of the
 repositories that RhodeCode is hosting. See PublishingRepositories_)
 
 RhodeCode repository structures are kept in directories with the same name 
 as the project. When using repository groups, each group is a subdirectory.
 This allows you to easily use ssh for accessing repositories.
 
 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.)
 
 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::
 
     hg clone ssh://[e-mail]/home/hg/rhodecode
 
 Using other external tools such as mercurial-server_ or using ssh key based
 authentication is fully supported.
 
 Note: In an advanced setup, in order for your ssh access to use the same
 permissions as set up via the RhodeCode web interface, you can create an
 authentication hook to connect to the rhodecode db and runs check functions for
 permissions against that.
     
 Setting up Whoosh full text search
 ----------------------------------
 
 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. 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
 
 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::
 
 	paster make-index production.ini 
 
 For a full index rebuild use::
 
 	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
 
 
 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::
  
     /path/to/python/bin/paster make-index /path/to/rhodecode/production.ini 
   
 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.
 
 
 Setting up LDAP support
 -----------------------
 
 RhodeCode starting from version 1.1 supports ldap authentication. In order
 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
 
 .. note::
    python-ldap requires some certain libs on your system, so before installing 
    it check that you have at least `openldap`, and `sasl` libraries.
 
 LDAP settings are located in admin->ldap section,
 
 Here's a typical ldap setup::
 
  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. Can be also a comma separated
     list of servers to support LDAP fail-over.
 
 .. _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        
     The LDAP record attribute that will be matched as the USERNAME or
     ACCOUNT used to connect to RhodeCode.  This will be added to `LDAP
     Filter`_ for locating the User object.  If `LDAP Filter`_ is specified as
     "LDAPFILTER", `Login Attribute`_ is specified as "uid" and the user has
     connected as "jsmith" then the `LDAP Filter`_ will be augmented as below
     ::
 
         (&(LDAPFILTER)(uid=jsmith))
 
 .. _ldap_attr_firstname:
 
 First Name Attribute : required
     The LDAP record attribute which represents the user's first name.
 
 .. _ldap_attr_lastname:
 
 Last Name Attribute : required
     The LDAP record attribute which represents the user's last name.
 
 .. _ldap_attr_email:
 
 Email Attribute : required
     The LDAP record attribute which represents the user's email address.
 
 If all data are entered correctly, and python-ldap_ is properly installed
 users should be granted access to RhodeCode with ldap accounts.  At this
 time user information is copied from LDAP into the RhodeCode user database.
 This means that updates of an LDAP user object may not be reflected as a
 user update in RhodeCode.
 
 If You have problems with LDAP access and believe You entered correct
 information check out the RhodeCode logs, any error messages sent from LDAP
 will be saved there.
 
 Active Directory
 ''''''''''''''''
 
 RhodeCode can use Microsoft Active Directory for user authentication.  This
 is done through an LDAP or LDAPS connection to Active Directory.  The
 following LDAP configuration settings are typical for using Active
 Directory ::
 
  Base DN              = OU=SBSUsers,OU=Users,OU=MyBusiness,DC=v3sys,DC=local
  Login Attribute      = sAMAccountName
  First Name Attribute = givenName
  Last Name Attribute  = sn
  E-mail Attribute     = mail
 
 All other LDAP settings will likely be site-specific and should be
 appropriately configured.
 
 
 Authentication by container or reverse-proxy
 --------------------------------------------
 
 Starting with version 1.3, RhodeCode supports delegating the authentication
 of users to its WSGI container, or to a reverse-proxy server through which all
 clients access the application.
 
 When these authentication methods are enabled in RhodeCode, it uses the
 username that the container/proxy (Apache/Nginx/etc) authenticated and doesn't
 perform the authentication itself. The authorization, however, is still done by
 RhodeCode according to its settings.
 
 When a user logs in for the first time using these authentication methods,
 a matching user account is created in RhodeCode with default permissions. An
 administrator can then modify it using RhodeCode's admin interface.
 It's also possible for an administrator to create accounts and configure their
 permissions before the user logs in for the first time.
 
 Container-based authentication
 ''''''''''''''''''''''''''''''
 
 In a container-based authentication setup, RhodeCode reads the user name from
 the ``REMOTE_USER`` server variable provided by the WSGI container.
 
 After setting up your container (see `Apache's WSGI config`_), you'd need
 to configure it to require authentication on the location configured for
 RhodeCode.
 
 In order for RhodeCode to start using the provided username, you should set the
 following in the [app:main] section of your .ini file::
 
     container_auth_enabled = true
 
 
 Proxy pass-through authentication
 '''''''''''''''''''''''''''''''''
 
 In a proxy pass-through authentication setup, RhodeCode reads the user name
 from the ``X-Forwarded-User`` request header, which should be configured to be
 sent by the reverse-proxy server.
 
 After setting up your proxy solution (see `Apache virtual host reverse proxy example`_,
 `Apache as subdirectory`_ or `Nginx virtual host example`_), you'd need to
 configure the authentication and add the username in a request header named
 ``X-Forwarded-User``.
 
 For example, the following config section for Apache sets a subdirectory in a
 reverse-proxy setup with basic auth::
 
     <Location /<someprefix> >
       ProxyPass http://127.0.0.1:5000/<someprefix>
       ProxyPassReverse http://127.0.0.1:5000/<someprefix>
       SetEnvIf X-Url-Scheme https HTTPS=1
 
       AuthType Basic
       AuthName "RhodeCode authentication"
       AuthUserFile /home/web/rhodecode/.htpasswd
       require valid-user
 
       RequestHeader unset X-Forwarded-User
 
       RewriteEngine On
       RewriteCond %{LA-U:REMOTE_USER} (.+)
       RewriteRule .* - [E=RU:%1]
       RequestHeader set X-Forwarded-User %{RU}e
     </Location> 
 
 In order for RhodeCode to start using the forwarded username, you should set
 the following in the [app:main] section of your .ini file::
 
     proxypass_auth_enabled = true
 
 .. note::
    If you enable proxy pass-through authentication, make sure your server is
    only accessible through the proxy. Otherwise, any client would be able to
    forge the authentication header and could effectively become authenticated
    using any account of their liking.
 
 Integration with Issue trackers
 -------------------------------
 
 RhodeCode provides a simple integration with issue trackers. It's possible
 to define a regular expression that will fetch issue id stored in commit
 messages and replace that with an url to this issue. To enable this simply
 uncomment following variables in the ini file::
 
     url_pat = (?:^#|\s#)(\w+)
     issue_server_link = https://myissueserver.com/{repo}/issue/{id}
     issue_prefix = #
 
 `url_pat` is the regular expression that will fetch issues from commit messages.
 Default regex will match issues in format of #<number> eg. #300.
  
 Matched issues will be replace with the link specified as `issue_server_link` 
 {id} will be replaced with issue id, and {repo} with repository name.
 Since the # is striped `issue_prefix` is added as a prefix to url. 
 `issue_prefix` can be something different than # if you pass 
 ISSUE- as issue prefix this will generate an url in format::
  
   <a href="https://myissueserver.com/example_repo/issue/300">ISSUE-300</a>  
 
 Hook management
 ---------------
 
 Hooks can be managed in similar way to this used in .hgrc files.
 To access hooks setting click `advanced setup` on Hooks section of Mercurial
 Settings in Admin. 
 
 There are 4 built in hooks that cannot be changed (only enable/disable by
 checkboxes on previos section).
 To add another custom hook simply fill in first section with 
 <name>.<hook_type> and the second one with hook path. Example hooks
 can be found at *rhodecode.lib.hooks*. 
 
 
 Changing default encoding
 -------------------------
 
 By default RhodeCode uses utf8 encoding, starting from 1.3 series this
 can be changed, simply edit default_encoding in .ini file to desired one.
 This affects many parts in rhodecode including commiters names, filenames,
 encoding of commit messages. In addition RhodeCode can detect if `chardet`
 library is installed. If `chardet` is detected RhodeCode will fallback to it
 when there are encode/decode errors.
 
 
 Setting Up Celery
 -----------------
 
 Since version 1.1 celery is configured by the rhodecode ini configuration files.
 Simply set use_celery=true in the ini file then add / change the configuration 
 variables inside the ini file.
 
 Remember that the ini files use the format with '.' not with '_' like celery.
 So for example setting `BROKER_HOST` in celery means setting `broker.host` in
 the config file.
 
 In order to start using celery run::
 
  paster celeryd <configfile.ini>
 
 
 .. note::
    Make sure you run this command from the same virtualenv, and with the same 
    user that rhodecode runs.
    
 HTTPS support
 -------------
 
 There are two ways to enable https:
 
 - Set HTTP_X_URL_SCHEME in your http server headers, than rhodecode will
   recognize this headers and make proper https redirections
 - Alternatively, change the `force_https = true` flag in the ini configuration 
   to force using https, no headers are needed than to enable https
 
 
 Nginx virtual host example
 --------------------------
 
 Sample config for nginx using proxy::
 
     upstream rc {
         server 127.0.0.1:5000;
         # add more instances for load balancing
         #server 127.0.0.1:5001;
         #server 127.0.0.1:5002;
     }
     
     server {
        listen          80;
        server_name     hg.myserver.com;
        access_log      /var/log/nginx/rhodecode.access.log;
        error_log       /var/log/nginx/rhodecode.error.log;
 
        # uncomment if you have nginx with chunking module compiled
        # fixes the issues of having to put postBuffer data for large git
        # pushes       
        #chunkin on;
        #error_page 411 = @my_411_error;
        #location @my_411_error {
        #    chunkin_resume;
        #}
        
        # uncomment if you want to serve static files by nginx
        #root /path/to/installation/rhodecode/public;
        
        location / {
             try_files $uri @rhode;
        }
     
        location @rhode {
             proxy_pass      http://rc;
             include         /etc/nginx/proxy.conf;
        }
 
     }  
   
 Here's the proxy.conf. It's tuned so it will not timeout on long
 pushes or large pushes::
     
     proxy_redirect              off;
     proxy_set_header            Host $host;
     proxy_set_header            X-Url-Scheme $scheme;
     proxy_set_header            X-Host $http_host;
     proxy_set_header            X-Real-IP $remote_addr;
     proxy_set_header            X-Forwarded-For $proxy_add_x_forwarded_for;
     proxy_set_header            Proxy-host $proxy_host;
     client_max_body_size        400m;
     client_body_buffer_size     128k;
     proxy_buffering             off;
     proxy_connect_timeout       7200;
     proxy_send_timeout          7200;
     proxy_read_timeout          7200;
     proxy_buffers               8 32k;
  
 Also, when using root path with nginx you might set the static files to false
 in the production.ini file::
 
     [app:main]
       use = egg:rhodecode
       full_stack = true
       static_files = false
       lang=en
       cache_dir = %(here)s/data
 
 In order to not have the statics served by the application. This improves speed.
 
 
 Apache virtual host reverse proxy example
 -----------------------------------------
 
 Here is a sample configuration file for apache using proxy::
 
     <VirtualHost *:80>
             ServerName hg.myserver.com
             ServerAlias hg.myserver.com
     
             <Proxy *>
               Order allow,deny
               Allow from all
             </Proxy>
     
             #important !
             #Directive to properly generate url (clone url) for pylons
             ProxyPreserveHost On
     
             #rhodecode instance
             ProxyPass / http://127.0.0.1:5000/
             ProxyPassReverse / http://127.0.0.1:5000/
             
             #to enable https use line below
             #SetEnvIf X-Url-Scheme https HTTPS=1
             
     </VirtualHost> 
 
 
 Additional tutorial
 http://wiki.pylonshq.com/display/pylonscookbook/Apache+as+a+reverse+proxy+for+Pylons
 
 
 Apache as subdirectory
 ----------------------
 
 Apache subdirectory part::
 
     <Location /<someprefix> >
       ProxyPass http://127.0.0.1:5000/<someprefix>
       ProxyPassReverse http://127.0.0.1:5000/<someprefix>
       SetEnvIf X-Url-Scheme https HTTPS=1
     </Location> 
 
 Besides the regular apache setup you will need to add the following line
 into [app:main] section of your .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> 
 
 
 then change <someprefix> into your choosen prefix
 
 Apache's WSGI config
 --------------------
 
 Alternatively, RhodeCode can be set up with Apache under mod_wsgi. For
 that, you'll need to:
 
 - Install mod_wsgi. If using a Debian-based distro, you can install
   the package libapache2-mod-wsgi::
 
     aptitude install libapache2-mod-wsgi
 
 - Enable mod_wsgi::
 
     a2enmod wsgi
 
 - Create a wsgi dispatch script, like the one below. Make sure you
   check the paths correctly point to where you installed RhodeCode
   and its Python Virtual Environment.
 - Enable the WSGIScriptAlias directive for the wsgi dispatch script,
   as in the following example. Once again, check the paths are
   correctly specified.
 
 Here is a sample excerpt from an Apache Virtual Host configuration file::
 
     WSGIDaemonProcess pylons \
         threads=4 \
         python-path=/home/web/rhodecode/pyenv/lib/python2.6/site-packages
     WSGIScriptAlias / /home/web/rhodecode/dispatch.wsgi
     WSGIPassAuthorization On
 
 .. note::
    when running apache as root please add: `user=www-data group=www-data` 
    into above configuration
 
 .. note::
    RhodeCode cannot be runned in multiprocess mode in apache, make sure
    you don't specify `processes=num` directive in the config
 
 
 Example wsgi dispatch script::
 
     import os
     os.environ["HGENCODING"] = "UTF-8"
     os.environ['PYTHON_EGG_CACHE'] = '/home/web/rhodecode/.egg-cache'
     
     # sometimes it's needed to set the curent dir
     os.chdir('/home/web/rhodecode/') 
 
     import site
     site.addsitedir("/home/web/rhodecode/pyenv/lib/python2.6/site-packages")
     
     from paste.deploy import loadapp
     from paste.script.util.logging_config import fileConfig
 
     fileConfig('/home/web/rhodecode/production.ini')
     application = loadapp('config:/home/web/rhodecode/production.ini')
 
 Note: when using mod_wsgi you'll need to install the same version of
 Mercurial that's inside RhodeCode's virtualenv also on the system's Python
 environment.
 
 
 Other configuration files
 -------------------------
 
 Some example init.d scripts can be found in init.d directory::
 
   https://secure.rhodecode.org/rhodecode/files/beta/init.d
 
 .. _virtualenv: http://pypi.python.org/pypi/virtualenv
 .. _python: http://www.python.org/
 .. _mercurial: http://mercurial.selenic.com/
 .. _celery: http://celeryproject.org/
 .. _rabbitmq: http://www.rabbitmq.com/
 .. _python-ldap: http://www.python-ldap.org/
 .. _mercurial-server: http://www.lshift.net/mercurial-server.html
 .. _PublishingRepositories: http://mercurial.selenic.com/wiki/PublishingRepositories
 .. _Issues tracker: https://bitbucket.org/marcinkuzminski/rhodecode/issues
-.. _google group rhodecode: http://groups.google.com/group/rhodecode
  No newline at end of file
+.. _google group rhodecode: http://groups.google.com/group/rhodecode

docs/usage/backup.rst

@@ -1,26 +1,26 b''
 .. _backup:
 
 ====================
 Backing up RhodeCode
 ====================
 
 
 Settings
 --------
 
 Just copy your .ini file, it contains all RhodeCode settings.
 
 Whoosh index
 ------------
 
 Whoosh index is located in **/data/index** directory where you installed
 RhodeCode ie. the same place where the ini file is located
 
 
 Database
 --------
 
 When using sqlite just copy rhodecode.db.
 Any other database engine requires a manual backup operation.
 
-Database backup will contain all gathered statistics
  No newline at end of file
+Database backup will contain all gathered statistics

docs/usage/git_support.rst

@@ -1,55 +1,55 b''
 .. _git_support:
 
 ===========
 GIT support
 ===========
 
 
 Git support in RhodeCode 1.3 was enabled by default. You need to have a git
 client installed on the machine to make git fully work.
 
 Although There is one limitation on git usage.
 
 - large pushes requires a http server with chunked encoding support.
  
 if you plan to use git you need to run RhodeCode with some
 http server that supports chunked encoding which git http protocol uses, 
 i recommend using waitress_ or gunicorn_ (linux only) for `paste` wsgi app 
 replacement. Starting from version 1.4 waitress_ is the default wsgi server
 used in RhodeCode.
 
 To use, simply change change the following in the .ini file::
 
     use = egg:Paste#http
 
 to::
     
     use = egg:waitress#main
 
 or::
 
     use = egg:gunicorn#main
     
     
 And comment out bellow options::
 
     threadpool_workers = 
     threadpool_max_requests = 
     use_threadpool = 
     
 
 You can simply run `paster serve` as usual.
 
   
 You can always disable git/hg support by editing a 
 file **rhodecode/__init__.py** and commenting out backends
 
 .. code-block:: python
  
    BACKENDS = {
        'hg': 'Mercurial repository',
        #'git': 'Git repository',
    }
 
 .. _waitress: http://pypi.python.org/pypi/waitress
-.. _gunicorn: http://pypi.python.org/pypi/gunicorn
  No newline at end of file
+.. _gunicorn: http://pypi.python.org/pypi/gunicorn

docs/usage/locking.rst

@@ -1,41 +1,41 b''
 .. _locking:
 
 ===================================
 RhodeCode repository locking system
 ===================================
 
 
 | Repos with **locking function=disabled** is the default, that's how repos work 
   today.
 | Repos with **locking function=enabled** behaves like follows:
 
 Repos have a state called `locked` that can be true or false.
 The hg/git commands `hg/git clone`, `hg/git pull`, and `hg/git push` 
 influence this state:
 
 - The command `hg/git pull <repo>` will lock that repo (locked=true) 
   if the user has write/admin permissions on this repo
 
 - The command `hg/git clone <repo>` will lock that repo (locked=true) if the 
   user has write/admin permissions on this repo
 
 
 RhodeCode will remember the user id who locked the repo
 only this specific user can unlock the repo (locked=false) by calling 
 
 - `hg/git push <repo>` 
 
 every other command on that repo from this user and 
 every command from any other user will result in http return code 423 (locked)
 
 
 additionally the http error includes the <user> that locked the repo 
 (e.g. “repository <repo> locked by user <user>”)
 
 
 So the scenario of use for repos with `locking function` enabled is that 
 every initial clone and every pull gives users (with write permission)
 the exclusive right to do a push.
 
 
-Each repo can be manually unlocked by admin from the repo settings menu.
  No newline at end of file
+Each repo can be manually unlocked by admin from the repo settings menu.

docs/usage/performance.rst

@@ -1,50 +1,50 b''
 .. _performance:
 
 ================================
 Optimizing RhodeCode Performance
 ================================
 
 When serving large amount of big repositories RhodeCode can start
 performing slower than expected. Because of demanding nature of handling large
 amount of data from version control systems here are some tips how to get
 the best performance.
 
 * RhodeCode will perform better on machines with faster disks (SSD/SAN). It's
   more important to have faster disk than faster CPU.
 
 * Slowness on initial page can be easily fixed by grouping repositories, and/or
   increasing cache size (see below)
 
 
 Follow these few steps to improve performance of RhodeCode system.
 
 
 1. Increase cache
 
     in the .ini file::
        
      beaker.cache.sql_cache_long.expire=3600 <-- set this to higher number
 
     This option affects the cache expiration time for main page. Having
     few hundreds of repositories on main page can sometimes make the system
     to behave slow when cache expires for all of them. Increasing `expire`
     option to day (86400) or a week (604800) will improve general response
     times for the main page. RhodeCode has an intelligent cache expiration
     system and it will expire cache for repositories that had been changed.
 
 2. Switch from sqlite to postgres or mysql
     
     sqlite is a good option when having small load on the system. But due to
     locking issues with sqlite, it's not recommended to use it for larger
     setup. Switching to mysql or postgres will result in a immediate
     performance increase.
     
 3. Scale RhodeCode horizontally
 
     - running two or more instances on the same server can speed up things a lot
     - load balance using round robin or ip hash
     - you need to handle consistent user session storage by switching to 
       db sessions, client side sessions or sharing session data folder across 
       instances. See http://beaker.readthedocs.org/ docs for details.
     - remember that each instance needs it's own .ini file and unique
-      `instance_id` set in them
  No newline at end of file
+      `instance_id` set in them

docs/usage/subrepos.rst

@@ -1,37 +1,37 b''
 .. _subrepos:
 
 =============================================
 working with RhodeCode and mercurial subrepos
 =============================================
 
 example usage of Subrepos with RhodeCode::
     
     ## init a simple repo
     hg init repo1                                                                                                                                                                                         
     cd repo1
     echo "file1" > file1
     hg add file1 
     hg ci --message "initial file 1"
         
     #clone subrepo we want to add
     hg clone http://rc.local/subrepo
 
     ## use path like url to existing repo in RhodeCode
     echo "subrepo = http://rc.local/subrepo" > .hgsub
 
     hg add .hgsub
     hg ci --message "added remote subrepo"
 
     
 
 In file list of repo1 you will see a connected subrepo at revision it was
 during cloning.
 Clicking in subrepos link should send you to proper repository in RhodeCode
 
 cloning repo1 will also clone attached subrepository.
 
 Next we can edit the subrepo data, and push back to RhodeCode. This will update
 both of repositories.
 
 see http://mercurial.aragost.com/kick-start/en/subrepositories/ for more
-information about subrepositories   
  No newline at end of file
+information about subrepositories

docs/usage/troubleshooting.rst

@@ -1,70 +1,70 b''
 .. _troubleshooting:
 
 
 ===============
 Troubleshooting
 ===============
 
 :Q: **Missing static files?**
 :A: Make sure either to set the `static_files = true` in the .ini file or
    double check the root path for your http setup. It should point to 
    for example:
    /home/my-virtual-python/lib/python2.6/site-packages/rhodecode/public
    
 | 
 
 :Q: **Can't install celery/rabbitmq?**
 :A: Don't worry RhodeCode works without them too. No extra setup is required.
     Try out great celery docs for further help.
 
 |
  
 :Q: **Long lasting push timeouts?**
 :A: Make sure you set a longer timeouts in your proxy/fcgi settings, timeouts
     are caused by https server and not RhodeCode.
     
 | 
 
 :Q: **Large pushes timeouts?**
 :A: Make sure you set a proper max_body_size for the http server. Very often
     Apache, Nginx or other http servers kill the connection due to to large
     body.
 
 |
 
 :Q: **Apache doesn't pass basicAuth on pull/push?**
 :A: Make sure you added `WSGIPassAuthorization true`.
 
 |
 
 :Q: **Git fails on push/pull?**
 :A: Make sure you're using an wsgi http server that can handle chunked encoding
     such as `waitress` or `gunicorn`
 
 |
 
 :Q: **How i use hooks in RhodeCode?**
 :A: It's easy if they are python hooks just use advanced link in hooks section
     in Admin panel, that works only for Mercurial. If you want to use githooks,
     just install proper one in repository eg. create file in 
     `/gitrepo/hooks/pre-receive`. You can also use RhodeCode-extensions to
     connect to callback hooks, for both Git and Mercurial.
 
 |
 
 :Q: **RhodeCode is slow for me, how can i make it faster?**
 :A: See the :ref:`performance` section
 
 For further questions search the `Issues tracker`_, or post a message in the 
 `google group rhodecode`_
 
 .. _virtualenv: http://pypi.python.org/pypi/virtualenv
 .. _python: http://www.python.org/
 .. _mercurial: http://mercurial.selenic.com/
 .. _celery: http://celeryproject.org/
 .. _rabbitmq: http://www.rabbitmq.com/
 .. _python-ldap: http://www.python-ldap.org/
 .. _mercurial-server: http://www.lshift.net/mercurial-server.html
 .. _PublishingRepositories: http://mercurial.selenic.com/wiki/PublishingRepositories
 .. _Issues tracker: https://bitbucket.org/marcinkuzminski/rhodecode/issues
-.. _google group rhodecode: http://groups.google.com/group/rhodecode
  No newline at end of file
+.. _google group rhodecode: http://groups.google.com/group/rhodecode