release: Merge default into stable for release preparation

docs/_templates/footer.html

@@ -0,0 +1,6 b''
+{% extends "!footer.html" %}
+
+{% block extrafooter %}
+<br/>
+Documentation defects and suggestions can be submitted <a href="https://issues.rhodecode.com/projects/documentation">here</a>
+{% endblock %}

docs/api/methods/deprecated-methods.rst

@@ -0,0 +1,77 b''
+.. _deprecated-methods-ref:
+
+deprecated methods
+=================
+
+changeset_comment 
+-----------------
+
+.. py:function:: changeset_comment(apiuser, repoid, revision, message, userid=<Optional:<OptionalAttr:apiuser>>, status=<Optional:None>)
+
+   .. deprecated:: 3.4.0
+
+          Please use method `comment_commit` instead.
+
+
+   Set a changeset comment, and optionally change the status of the
+   changeset.
+
+   This command can only be run using an |authtoken| with admin
+   permissions on the |repo|.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: Set the repository name or repository ID.
+   :type repoid: str or int
+   :param revision: Specify the revision for which to set a comment.
+   :type revision: str
+   :param message: The comment text.
+   :type message: str
+   :param userid: Set the user name of the comment creator.
+   :type userid: Optional(str or int)
+   :param status: Set the comment status. The following are valid options:
+       * not_reviewed
+       * approved
+       * rejected
+       * under_review
+   :type status: str
+
+   Example error output:
+
+   .. code-block:: json
+
+       {
+           "id" : <id_given_in_input>,
+           "result" : {
+               "msg": "Commented on commit `<revision>` for repository `<repoid>`",
+               "status_change": null or <status>,
+               "success": true
+           },
+           "error" : null
+       }
+
+
+get_locks 
+---------
+
+.. py:function:: get_locks(apiuser, userid=<Optional:<OptionalAttr:apiuser>>)
+
+   .. deprecated:: 4.0.0
+
+      Please use method `get_user_locks` instead.
+
+   None
+
+
+show_ip 
+-------
+
+.. py:function:: show_ip(apiuser, userid=<Optional:<OptionalAttr:apiuser>>)
+
+   .. deprecated:: 4.0.0
+
+      Please use method `get_ip` instead.
+
+   None
+
+

docs/api/methods/gist-methods.rst

@@ -0,0 +1,121 b''
+.. _gist-methods-ref:
+
+gist methods
+=================
+
+create_gist 
+-----------
+
+.. py:function:: create_gist(apiuser, files, gistid=<Optional:None>, owner=<Optional:<OptionalAttr:apiuser>>, gist_type=<Optional:u'public'>, lifetime=<Optional:-1>, acl_level=<Optional:u'acl_public'>, description=<Optional:''>)
+
+   Creates a new Gist.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param files: files to be added to the gist. The data structure has
+       to match the following example::
+
+         {'filename1': {'content':'...'}, 'filename2': {'content':'...'}}
+
+   :type files: dict
+   :param gistid: Set a custom id for the gist
+   :type gistid: Optional(str)
+   :param owner: Set the gist owner, defaults to api method caller
+   :type owner: Optional(str or int)
+   :param gist_type: type of gist ``public`` or ``private``
+   :type gist_type: Optional(str)
+   :param lifetime: time in minutes of gist lifetime
+   :type lifetime: Optional(int)
+   :param acl_level: acl level for this gist, can be
+       ``acl_public`` or ``acl_private`` If the value is set to
+       ``acl_private`` only logged in users are able to access this gist.
+       If not set it defaults to ``acl_public``.
+   :type acl_level: Optional(str)
+   :param description: gist description
+   :type description: Optional(str)
+
+   Example  output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : {
+       "msg": "created new gist",
+       "gist": {}
+     }
+     error :  null
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : null
+     error :  {
+       "failed to create gist"
+     }
+
+
+delete_gist 
+-----------
+
+.. py:function:: delete_gist(apiuser, gistid)
+
+   Deletes existing gist
+
+   :param apiuser: filled automatically from apikey
+   :type apiuser: AuthUser
+   :param gistid: id of gist to delete
+   :type gistid: str
+
+   Example output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : {
+       "deleted gist ID: <gist_id>",
+       "gist": null
+     }
+     error :  null
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : null
+     error :  {
+       "failed to delete gist ID:<gist_id>"
+     }
+
+
+get_gist 
+--------
+
+.. py:function:: get_gist(apiuser, gistid, content=<Optional:False>)
+
+   Get the specified gist, based on the gist ID.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param gistid: Set the id of the private or public gist
+   :type gistid: str
+   :param content: Return the gist content. Default is false.
+   :type content: Optional(bool)
+
+
+get_gists 
+---------
+
+.. py:function:: get_gists(apiuser, userid=<Optional:<OptionalAttr:apiuser>>)
+
+   Get all gists for given user. If userid is empty returned gists
+   are for user who called the api
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param userid: user to get gists for
+   :type userid: Optional(str or int)
+
+

docs/api/methods/license-methods.rst

@@ -0,0 +1,71 b''
+.. _license-methods-ref:
+
+license methods
+=================
+
+get_license_info (EE only)
+----------------
+
+.. py:function:: get_license_info(apiuser)
+
+   Returns the |RCE| license information.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+
+   Example output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : {
+       'rhodecode_version': <rhodecode version>,
+       'token': <license token>,
+       'issued_to': <license owner>,
+       'issued_on': <license issue date>,
+       'expires_on': <license expiration date>,
+       'type': <license type>,
+       'users_limit': <license users limit>,
+       'key': <license key>
+     }
+     error :  null
+
+
+set_license_key (EE only)
+---------------
+
+.. py:function:: set_license_key(apiuser, key)
+
+   Sets the |RCE| license key.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param key: This is the license key to be set.
+   :type key: str
+
+   Example output:
+
+   .. code-block:: bash
+
+       id : <id_given_in_input>
+       result: {
+                 "msg" : "updated license information",
+                 "key": <key>
+               }
+       error:  null
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : null
+     error :  {
+       "license key is not valid"
+       or
+       "trial licenses cannot be uploaded"
+       or
+       "error occurred while updating license"
+     }
+
+

docs/api/methods/pull-request-methods.rst

@@ -0,0 +1,344 b''
+.. _pull-request-methods-ref:
+
+pull_request methods
+=================
+
+close_pull_request 
+------------------
+
+.. py:function:: close_pull_request(apiuser, repoid, pullrequestid, userid=<Optional:<OptionalAttr:apiuser>>)
+
+   Close the pull request specified by `pullrequestid`.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: Repository name or repository ID to which the pull
+       request belongs.
+   :type repoid: str or int
+   :param pullrequestid: ID of the pull request to be closed.
+   :type pullrequestid: int
+   :param userid: Close the pull request as this user.
+   :type userid: Optional(str or int)
+
+   Example output:
+
+   .. code-block:: bash
+
+     "id": <id_given_in_input>,
+     "result":
+       {
+           "pull_request_id":  "<int>",
+           "closed":           "<bool>"
+       },
+     "error": null
+
+
+comment_pull_request 
+--------------------
+
+.. py:function:: comment_pull_request(apiuser, repoid, pullrequestid, message=<Optional:None>, status=<Optional:None>, userid=<Optional:<OptionalAttr:apiuser>>)
+
+   Comment on the pull request specified with the `pullrequestid`,
+   in the |repo| specified by the `repoid`, and optionally change the
+   review status.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: The repository name or repository ID.
+   :type repoid: str or int
+   :param pullrequestid: The pull request ID.
+   :type pullrequestid: int
+   :param message: The text content of the comment.
+   :type message: str
+   :param status: (**Optional**) Set the approval status of the pull
+       request. Valid options are:
+       * not_reviewed
+       * approved
+       * rejected
+       * under_review
+   :type status: str
+   :param userid: Comment on the pull request as this user
+   :type userid: Optional(str or int)
+
+   Example output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result :
+       {
+           "pull_request_id":  "<Integer>",
+           "comment_id":       "<Integer>"
+       }
+     error :  null
+
+
+create_pull_request 
+-------------------
+
+.. py:function:: create_pull_request(apiuser, source_repo, target_repo, source_ref, target_ref, title, description=<Optional:''>, reviewers=<Optional:None>)
+
+   Creates a new pull request.
+
+   Accepts refs in the following formats:
+
+       * branch:<branch_name>:<sha>
+       * branch:<branch_name>
+       * bookmark:<bookmark_name>:<sha> (Mercurial only)
+       * bookmark:<bookmark_name> (Mercurial only)
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param source_repo: Set the source repository name.
+   :type source_repo: str
+   :param target_repo: Set the target repository name.
+   :type target_repo: str
+   :param source_ref: Set the source ref name.
+   :type source_ref: str
+   :param target_ref: Set the target ref name.
+   :type target_ref: str
+   :param title: Set the pull request title.
+   :type title: str
+   :param description: Set the pull request description.
+   :type description: Optional(str)
+   :param reviewers: Set the new pull request reviewers list.
+   :type reviewers: Optional(list)
+
+
+get_pull_request 
+----------------
+
+.. py:function:: get_pull_request(apiuser, repoid, pullrequestid)
+
+   Get a pull request based on the given ID.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: Repository name or repository ID from where the pull
+       request was opened.
+   :type repoid: str or int
+   :param pullrequestid: ID of the requested pull request.
+   :type pullrequestid: int
+
+   Example output:
+
+   .. code-block:: bash
+
+     "id": <id_given_in_input>,
+     "result":
+       {
+           "pull_request_id":   "<pull_request_id>",
+           "url":               "<url>",
+           "title":             "<title>",
+           "description":       "<description>",
+           "status" :           "<status>",
+           "created_on":        "<date_time_created>",
+           "updated_on":        "<date_time_updated>",
+           "commit_ids":        [
+                                    ...
+                                    "<commit_id>",
+                                    "<commit_id>",
+                                    ...
+                                ],
+           "review_status":    "<review_status>",
+           "mergeable":         {
+                                    "status":  "<bool>",
+                                    "message": "<message>",
+                                },
+           "source":            {
+                                    "clone_url":     "<clone_url>",
+                                    "repository":    "<repository_name>",
+                                    "reference":
+                                    {
+                                        "name":      "<name>",
+                                        "type":      "<type>",
+                                        "commit_id": "<commit_id>",
+                                    }
+                                },
+           "target":            {
+                                    "clone_url":   "<clone_url>",
+                                    "repository":    "<repository_name>",
+                                    "reference":
+                                    {
+                                        "name":      "<name>",
+                                        "type":      "<type>",
+                                        "commit_id": "<commit_id>",
+                                    }
+                                },
+          "author":             <user_obj>,
+          "reviewers":          [
+                                    ...
+                                    {
+                                       "user":          "<user_obj>",
+                                       "review_status": "<review_status>",
+                                    }
+                                    ...
+                                ]
+       },
+      "error": null
+
+
+get_pull_requests 
+-----------------
+
+.. py:function:: get_pull_requests(apiuser, repoid, status=<Optional:'new'>)
+
+   Get all pull requests from the repository specified in `repoid`.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: Repository name or repository ID.
+   :type repoid: str or int
+   :param status: Only return pull requests with the specified status.
+       Valid options are.
+       * ``new`` (default)
+       * ``open``
+       * ``closed``
+   :type status: str
+
+   Example output:
+
+   .. code-block:: bash
+
+     "id": <id_given_in_input>,
+     "result":
+       [
+           ...
+           {
+               "pull_request_id":   "<pull_request_id>",
+               "url":               "<url>",
+               "title" :            "<title>",
+               "description":       "<description>",
+               "status":            "<status>",
+               "created_on":        "<date_time_created>",
+               "updated_on":        "<date_time_updated>",
+               "commit_ids":        [
+                                        ...
+                                        "<commit_id>",
+                                        "<commit_id>",
+                                        ...
+                                    ],
+               "review_status":    "<review_status>",
+               "mergeable":         {
+                                       "status":      "<bool>",
+                                       "message:      "<message>",
+                                    },
+               "source":            {
+                                        "clone_url":     "<clone_url>",
+                                        "reference":
+                                        {
+                                            "name":      "<name>",
+                                            "type":      "<type>",
+                                            "commit_id": "<commit_id>",
+                                        }
+                                    },
+               "target":            {
+                                        "clone_url":   "<clone_url>",
+                                        "reference":
+                                        {
+                                            "name":      "<name>",
+                                            "type":      "<type>",
+                                            "commit_id": "<commit_id>",
+                                        }
+                                    },
+              "author":             <user_obj>,
+              "reviewers":          [
+                                        ...
+                                        {
+                                           "user":          "<user_obj>",
+                                           "review_status": "<review_status>",
+                                        }
+                                        ...
+                                    ]
+           }
+           ...
+       ],
+     "error": null
+
+
+merge_pull_request 
+------------------
+
+.. py:function:: merge_pull_request(apiuser, repoid, pullrequestid, userid=<Optional:<OptionalAttr:apiuser>>)
+
+   Merge the pull request specified by `pullrequestid` into its target
+   repository.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: The Repository name or repository ID of the
+       target repository to which the |pr| is to be merged.
+   :type repoid: str or int
+   :param pullrequestid: ID of the pull request which shall be merged.
+   :type pullrequestid: int
+   :param userid: Merge the pull request as this user.
+   :type userid: Optional(str or int)
+
+   Example output:
+
+   .. code-block:: bash
+
+     "id": <id_given_in_input>,
+     "result":
+       {
+           "executed":         "<bool>",
+           "failure_reason":   "<int>",
+           "merge_commit_id":  "<merge_commit_id>",
+           "possible":         "<bool>"
+       },
+     "error": null
+
+
+update_pull_request 
+-------------------
+
+.. py:function:: update_pull_request(apiuser, repoid, pullrequestid, title=<Optional:''>, description=<Optional:''>, reviewers=<Optional:None>, update_commits=<Optional:None>, close_pull_request=<Optional:None>)
+
+   Updates a pull request.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: The repository name or repository ID.
+   :type repoid: str or int
+   :param pullrequestid: The pull request ID.
+   :type pullrequestid: int
+   :param title: Set the pull request title.
+   :type title: str
+   :param description: Update pull request description.
+   :type description: Optional(str)
+   :param reviewers: Update pull request reviewers list with new value.
+   :type reviewers: Optional(list)
+   :param update_commits: Trigger update of commits for this pull request
+   :type: update_commits: Optional(bool)
+   :param close_pull_request: Close this pull request with rejected state
+   :type: close_pull_request: Optional(bool)
+
+   Example output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result :
+       {
+           "msg": "Updated pull request `63`",
+           "pull_request": <pull_request_object>,
+           "updated_reviewers": {
+             "added": [
+               "username"
+             ],
+             "removed": []
+           },
+           "updated_commits": {
+             "added": [
+               "<sha1_hash>"
+             ],
+             "common": [
+               "<sha1_hash>",
+               "<sha1_hash>",
+             ],
+             "removed": []
+           }
+       }
+     error :  null
+
+

docs/api/methods/repo-group-methods.rst

@@ -0,0 +1,350 b''
+.. _repo-group-methods-ref:
+
+repo_group methods
+=================
+
+create_repo_group 
+-----------------
+
+.. py:function:: create_repo_group(apiuser, group_name, description=<Optional:''>, owner=<Optional:<OptionalAttr:apiuser>>, copy_permissions=<Optional:False>)
+
+   Creates a repository group.
+
+   * If the repository group name contains "/", all the required repository
+     groups will be created.
+
+     For example "foo/bar/baz" will create |repo| groups "foo" and "bar"
+     (with "foo" as parent). It will also create the "baz" repository
+     with "bar" as |repo| group.
+
+   This command can only be run using an |authtoken| with admin
+   permissions.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param group_name: Set the repository group name.
+   :type group_name: str
+   :param description: Set the |repo| group description.
+   :type description: str
+   :param owner: Set the |repo| group owner.
+   :type owner: str
+   :param copy_permissions:
+   :type copy_permissions:
+
+   Example output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : {
+         "msg": "Created new repo group `<repo_group_name>`"
+         "repo_group": <repogroup_object>
+     }
+     error :  null
+
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : null
+     error :  {
+       failed to create repo group `<repogroupid>`
+     }
+
+
+delete_repo_group 
+-----------------
+
+.. py:function:: delete_repo_group(apiuser, repogroupid)
+
+   Deletes a |repo| group.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repogroupid: Set the name or ID of repository group to be
+       deleted.
+   :type repogroupid: str or int
+
+   Example output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : {
+       'msg': 'deleted repo group ID:<repogroupid> <repogroupname>
+       'repo_group': null
+     }
+     error :  null
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : null
+     error :  {
+       "failed to delete repo group ID:<repogroupid> <repogroupname>"
+     }
+
+
+get_repo_group 
+--------------
+
+.. py:function:: get_repo_group(apiuser, repogroupid)
+
+   Return the specified |repo| group, along with permissions,
+   and repositories inside the group
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repogroupid: Specify the name of ID of the repository group.
+   :type repogroupid: str or int
+
+
+   Example output:
+
+   .. code-block:: bash
+
+       {
+         "error": null,
+         "id": repo-group-id,
+         "result": {
+           "group_description": "repo group description",
+           "group_id": 14,
+           "group_name": "group name",
+           "members": [
+             {
+               "name": "super-admin-username",
+               "origin": "super-admin",
+               "permission": "group.admin",
+               "type": "user"
+             },
+             {
+               "name": "owner-name",
+               "origin": "owner",
+               "permission": "group.admin",
+               "type": "user"
+             },
+             {
+               "name": "user-group-name",
+               "origin": "permission",
+               "permission": "group.write",
+               "type": "user_group"
+             }
+           ],
+           "owner": "owner-name",
+           "parent_group": null,
+           "repositories": [ repo-list ]
+         }
+       }
+
+
+get_repo_groups 
+---------------
+
+.. py:function:: get_repo_groups(apiuser)
+
+   Returns all repository groups.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+
+
+grant_user_group_permission_to_repo_group 
+-----------------------------------------
+
+.. py:function:: grant_user_group_permission_to_repo_group(apiuser, repogroupid, usergroupid, perm, apply_to_children=<Optional:'none'>)
+
+   Grant permission for a user group on given repository group, or update
+   existing permissions if found.
+
+   This command can only be run using an |authtoken| with admin
+   permissions on the |repo| group.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repogroupid: Set the name or id of repository group
+   :type repogroupid: str or int
+   :param usergroupid: id of usergroup
+   :type usergroupid: str or int
+   :param perm: (group.(none|read|write|admin))
+   :type perm: str
+   :param apply_to_children: 'none', 'repos', 'groups', 'all'
+   :type apply_to_children: str
+
+   Example output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : {
+       "msg" : "Granted perm: `<perm>` (recursive:<apply_to_children>) for user group: `<usersgroupname>` in repo group: `<repo_group_name>`",
+       "success": true
+
+     }
+     error :  null
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : null
+     error :  {
+       "failed to edit permission for user group: `<usergroup>` in repo group: `<repo_group_name>`"
+     }
+
+
+grant_user_permission_to_repo_group 
+-----------------------------------
+
+.. py:function:: grant_user_permission_to_repo_group(apiuser, repogroupid, userid, perm, apply_to_children=<Optional:'none'>)
+
+   Grant permission for a user on the given repository group, or update
+   existing permissions if found.
+
+   This command can only be run using an |authtoken| with admin
+   permissions.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repogroupid: Set the name or ID of repository group.
+   :type repogroupid: str or int
+   :param userid: Set the user name.
+   :type userid: str
+   :param perm: (group.(none|read|write|admin))
+   :type perm: str
+   :param apply_to_children: 'none', 'repos', 'groups', 'all'
+   :type apply_to_children: str
+
+   Example output:
+
+   .. code-block:: bash
+
+       id : <id_given_in_input>
+       result: {
+                 "msg" : "Granted perm: `<perm>` (recursive:<apply_to_children>) for user: `<username>` in repo group: `<repo_group_name>`",
+                 "success": true
+               }
+       error:  null
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : null
+     error :  {
+       "failed to edit permission for user: `<userid>` in repo group: `<repo_group_name>`"
+     }
+
+
+revoke_user_group_permission_from_repo_group 
+--------------------------------------------
+
+.. py:function:: revoke_user_group_permission_from_repo_group(apiuser, repogroupid, usergroupid, apply_to_children=<Optional:'none'>)
+
+   Revoke permission for user group on given repository.
+
+   This command can only be run using an |authtoken| with admin
+   permissions on the |repo| group.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repogroupid: name or id of repository group
+   :type repogroupid: str or int
+   :param usergroupid:
+   :param apply_to_children: 'none', 'repos', 'groups', 'all'
+   :type apply_to_children: str
+
+   Example output:
+
+   .. code-block:: bash
+
+       id : <id_given_in_input>
+       result: {
+                 "msg" : "Revoked perm (recursive:<apply_to_children>) for user group: `<usersgroupname>` in repo group: `<repo_group_name>`",
+                 "success": true
+               }
+       error:  null
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : null
+     error :  {
+       "failed to edit permission for user group: `<usergroup>` in repo group: `<repo_group_name>`"
+     }
+
+
+revoke_user_permission_from_repo_group 
+--------------------------------------
+
+.. py:function:: revoke_user_permission_from_repo_group(apiuser, repogroupid, userid, apply_to_children=<Optional:'none'>)
+
+   Revoke permission for a user in a given repository group.
+
+   This command can only be run using an |authtoken| with admin
+   permissions on the |repo| group.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repogroupid: Set the name or ID of the repository group.
+   :type repogroupid: str or int
+   :param userid: Set the user name to revoke.
+   :type userid: str
+   :param apply_to_children: 'none', 'repos', 'groups', 'all'
+   :type apply_to_children: str
+
+   Example output:
+
+   .. code-block:: bash
+
+       id : <id_given_in_input>
+       result: {
+                 "msg" : "Revoked perm (recursive:<apply_to_children>) for user: `<username>` in repo group: `<repo_group_name>`",
+                 "success": true
+               }
+       error:  null
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : null
+     error :  {
+       "failed to edit permission for user: `<userid>` in repo group: `<repo_group_name>`"
+     }
+
+
+update_repo_group 
+-----------------
+
+.. py:function:: update_repo_group(apiuser, repogroupid, group_name=<Optional:''>, description=<Optional:''>, owner=<Optional:<OptionalAttr:apiuser>>, parent=<Optional:None>, enable_locking=<Optional:False>)
+
+   Updates repository group with the details given.
+
+   This command can only be run using an |authtoken| with admin
+   permissions.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repogroupid: Set the ID of repository group.
+   :type repogroupid: str or int
+   :param group_name: Set the name of the |repo| group.
+   :type group_name: str
+   :param description: Set a description for the group.
+   :type description: str
+   :param owner: Set the |repo| group owner.
+   :type owner: str
+   :param parent: Set the |repo| group parent.
+   :type parent: str or int
+   :param enable_locking: Enable |repo| locking. The default is false.
+   :type enable_locking: bool
+
+

docs/api/methods/repo-methods.rst

@@ -0,0 +1,967 b''
+.. _repo-methods-ref:
+
+repo methods
+=================
+
+add_field_to_repo 
+-----------------
+
+.. py:function:: add_field_to_repo(apiuser, repoid, key, label=<Optional:''>, description=<Optional:''>)
+
+   Adds an extra field to a repository.
+
+   This command can only be run using an |authtoken| with at least
+   write permissions to the |repo|.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: Set the repository name or repository id.
+   :type repoid: str or int
+   :param key: Create a unique field key for this repository.
+   :type key: str
+   :param label:
+   :type label: Optional(str)
+   :param description:
+   :type description: Optional(str)
+
+
+comment_commit 
+--------------
+
+.. py:function:: comment_commit(apiuser, repoid, commit_id, message, userid=<Optional:<OptionalAttr:apiuser>>, status=<Optional:None>)
+
+   Set a commit comment, and optionally change the status of the commit.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: Set the repository name or repository ID.
+   :type repoid: str or int
+   :param commit_id: Specify the commit_id for which to set a comment.
+   :type commit_id: str
+   :param message: The comment text.
+   :type message: str
+   :param userid: Set the user name of the comment creator.
+   :type userid: Optional(str or int)
+   :param status: status, one of 'not_reviewed', 'approved', 'rejected',
+      'under_review'
+   :type status: str
+
+   Example error output:
+
+   .. code-block:: json
+
+       {
+           "id" : <id_given_in_input>,
+           "result" : {
+               "msg": "Commented on commit `<commit_id>` for repository `<repoid>`",
+               "status_change": null or <status>,
+               "success": true
+           },
+           "error" :  null
+       }
+
+
+create_repo 
+-----------
+
+.. py:function:: create_repo(apiuser, repo_name, repo_type, owner=<Optional:<OptionalAttr:apiuser>>, description=<Optional:''>, private=<Optional:False>, clone_uri=<Optional:None>, landing_rev=<Optional:'rev:tip'>, enable_statistics=<Optional:False>, enable_locking=<Optional:False>, enable_downloads=<Optional:False>, copy_permissions=<Optional:False>)
+
+   Creates a repository.
+
+   * If the repository name contains "/", all the required repository
+     groups will be created.
+
+     For example "foo/bar/baz" will create |repo| groups "foo" and "bar"
+     (with "foo" as parent). It will also create the "baz" repository
+     with "bar" as |repo| group.
+
+   This command can only be run using an |authtoken| with at least
+   write permissions to the |repo|.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repo_name: Set the repository name.
+   :type repo_name: str
+   :param repo_type: Set the repository type; 'hg','git', or 'svn'.
+   :type repo_type: str
+   :param owner: user_id or username
+   :type owner: Optional(str)
+   :param description: Set the repository description.
+   :type description: Optional(str)
+   :param private:
+   :type private: bool
+   :param clone_uri:
+   :type clone_uri: str
+   :param landing_rev: <rev_type>:<rev>
+   :type landing_rev: str
+   :param enable_locking:
+   :type enable_locking: bool
+   :param enable_downloads:
+   :type enable_downloads: bool
+   :param enable_statistics:
+   :type enable_statistics: bool
+   :param copy_permissions: Copy permission from group in which the
+       repository is being created.
+   :type copy_permissions: bool
+
+
+   Example output:
+
+   .. code-block:: bash
+
+       id : <id_given_in_input>
+       result: {
+                 "msg": "Created new repository `<reponame>`",
+                 "success": true,
+                 "task": "<celery task id or None if done sync>"
+               }
+       error:  null
+
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : null
+     error :  {
+        'failed to create repository `<repo_name>`
+     }
+
+
+delete_repo 
+-----------
+
+.. py:function:: delete_repo(apiuser, repoid, forks=<Optional:''>)
+
+   Deletes a repository.
+
+   * When the `forks` parameter is set it's possible to detach or delete
+     forks of deleted repository.
+
+   This command can only be run using an |authtoken| with admin
+   permissions on the |repo|.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: Set the repository name or repository ID.
+   :type repoid: str or int
+   :param forks: Set to `detach` or `delete` forks from the |repo|.
+   :type forks: Optional(str)
+
+   Example error output:
+
+   .. code-block:: bash
+
+       id : <id_given_in_input>
+       result: {
+                 "msg": "Deleted repository `<reponame>`",
+                 "success": true
+               }
+       error:  null
+
+
+fork_repo 
+---------
+
+.. py:function:: fork_repo(apiuser, repoid, fork_name, owner=<Optional:<OptionalAttr:apiuser>>, description=<Optional:''>, copy_permissions=<Optional:False>, private=<Optional:False>, landing_rev=<Optional:'rev:tip'>)
+
+   Creates a fork of the specified |repo|.
+
+   * If using |RCE| with Celery this will immediately return a success
+     message, even though the fork will be created asynchronously.
+
+   This command can only be run using an |authtoken| with fork
+   permissions on the |repo|.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: Set repository name or repository ID.
+   :type repoid: str or int
+   :param fork_name: Set the fork name.
+   :type fork_name: str
+   :param owner: Set the fork owner.
+   :type owner: str
+   :param description: Set the fork descripton.
+   :type description: str
+   :param copy_permissions: Copy permissions from parent |repo|. The
+       default is False.
+   :type copy_permissions: bool
+   :param private: Make the fork private. The default is False.
+   :type private: bool
+   :param landing_rev: Set the landing revision. The default is tip.
+
+   Example output:
+
+   .. code-block:: bash
+
+       id : <id_for_response>
+       api_key : "<api_key>"
+       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>"
+                 }
+
+   Example error output:
+
+   .. code-block:: bash
+
+       id : <id_given_in_input>
+       result: {
+                 "msg": "Created fork of `<reponame>` as `<forkname>`",
+                 "success": true,
+                 "task": "<celery task id or None if done sync>"
+               }
+       error:  null
+
+
+get_repo 
+--------
+
+.. py:function:: get_repo(apiuser, repoid, cache=<Optional:True>)
+
+   Gets an existing repository by its name or repository_id.
+
+   The members section so the output returns users groups or users
+   associated with that repository.
+
+   This command can only be run using an |authtoken| with admin rights,
+   or users with at least read rights to the |repo|.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: The repository name or repository id.
+   :type repoid: str or int
+   :param cache: use the cached value for last changeset
+   :type: cache: Optional(bool)
+
+   Example output:
+
+   .. code-block:: bash
+
+       {
+         "error": null,
+         "id": <repo_id>,
+         "result": {
+           "clone_uri": null,
+           "created_on": "timestamp",
+           "description": "repo description",
+           "enable_downloads": false,
+           "enable_locking": false,
+           "enable_statistics": false,
+           "followers": [
+             {
+               "active": true,
+               "admin": false,
+               "api_key": "****************************************",
+               "api_keys": [
+                 "****************************************"
+               ],
+               "email": "[e-mail]",
+               "emails": [
+                 "[e-mail]"
+               ],
+               "extern_name": "rhodecode",
+               "extern_type": "rhodecode",
+               "firstname": "username",
+               "ip_addresses": [],
+               "language": null,
+               "last_login": "2015-09-16T17:16:35.854",
+               "lastname": "surname",
+               "user_id": <user_id>,
+               "username": "name"
+             }
+           ],
+           "fork_of": "parent-repo",
+           "landing_rev": [
+             "rev",
+             "tip"
+           ],
+           "last_changeset": {
+             "author": "User <[e-mail]>",
+             "branch": "default",
+             "date": "timestamp",
+             "message": "last commit message",
+             "parents": [
+               {
+                 "raw_id": "commit-id"
+               }
+             ],
+             "raw_id": "commit-id",
+             "revision": <revision number>,
+             "short_id": "short id"
+           },
+           "lock_reason": null,
+           "locked_by": null,
+           "locked_date": null,
+           "members": [
+             {
+               "name": "super-admin-name",
+               "origin": "super-admin",
+               "permission": "repository.admin",
+               "type": "user"
+             },
+             {
+               "name": "owner-name",
+               "origin": "owner",
+               "permission": "repository.admin",
+               "type": "user"
+             },
+             {
+               "name": "user-group-name",
+               "origin": "permission",
+               "permission": "repository.write",
+               "type": "user_group"
+             }
+           ],
+           "owner": "owner-name",
+           "permissions": [
+             {
+               "name": "super-admin-name",
+               "origin": "super-admin",
+               "permission": "repository.admin",
+               "type": "user"
+             },
+             {
+               "name": "owner-name",
+               "origin": "owner",
+               "permission": "repository.admin",
+               "type": "user"
+             },
+             {
+               "name": "user-group-name",
+               "origin": "permission",
+               "permission": "repository.write",
+               "type": "user_group"
+             }
+           ],
+           "private": true,
+           "repo_id": 676,
+           "repo_name": "user-group/repo-name",
+           "repo_type": "hg"
+         }
+       }
+
+
+get_repo_changeset 
+------------------
+
+.. py:function:: get_repo_changeset(apiuser, repoid, revision, details=<Optional:'basic'>)
+
+   Returns information about a changeset.
+
+   Additionally parameters define the amount of details returned by
+   this function.
+
+   This command can only be run using an |authtoken| with admin rights,
+   or users with at least read rights to the |repo|.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: The repository name or repository id
+   :type repoid: str or int
+   :param revision: revision for which listing should be done
+   :type revision: str
+   :param details: details can be 'basic|extended|full' full gives diff
+       info details like the diff itself, and number of changed files etc.
+   :type details: Optional(str)
+
+
+get_repo_changesets 
+-------------------
+
+.. py:function:: get_repo_changesets(apiuser, repoid, start_rev, limit, details=<Optional:'basic'>)
+
+   Returns a set of commits limited by the number starting
+   from the `start_rev` option.
+
+   Additional parameters define the amount of details returned by this
+   function.
+
+   This command can only be run using an |authtoken| with admin rights,
+   or users with at least read rights to |repos|.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: The repository name or repository ID.
+   :type repoid: str or int
+   :param start_rev: The starting revision from where to get changesets.
+   :type start_rev: str
+   :param limit: Limit the number of commits to this amount
+   :type limit: str or int
+   :param details: Set the level of detail returned. Valid option are:
+       ``basic``, ``extended`` and ``full``.
+   :type details: Optional(str)
+
+   .. note::
+
+      Setting the parameter `details` to the value ``full`` is extensive
+      and returns details like the diff itself, and the number
+      of changed files.
+
+
+get_repo_nodes 
+--------------
+
+.. py:function:: get_repo_nodes(apiuser, repoid, revision, root_path, ret_type=<Optional:'all'>, details=<Optional:'basic'>, max_file_bytes=<Optional:None>)
+
+   Returns a list of nodes and 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 only be run using an |authtoken| with admin rights,
+   or users with at least read rights to |repos|.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: The repository name or repository ID.
+   :type repoid: str or int
+   :param revision: The revision for which listing should be done.
+   :type revision: str
+   :param root_path: The path from which to start displaying.
+   :type root_path: str
+   :param ret_type: Set the return type. Valid options are
+       ``all`` (default), ``files`` and ``dirs``.
+   :type ret_type: Optional(str)
+   :param details: Returns extended information about nodes, such as
+       md5, binary, and or content.  The valid options are ``basic`` and
+       ``full``.
+   :type details: Optional(str)
+   :param max_file_bytes: Only return file content under this file size bytes
+   :type details: Optional(int)
+
+   Example output:
+
+   .. code-block:: bash
+
+       id : <id_given_in_input>
+       result: [
+                 {
+                   "name" : "<name>"
+                   "type" : "<type>",
+                   "binary": "<true|false>" (only in extended mode)
+                   "md5"  : "<md5 of file content>" (only in extended mode)
+                 },
+                 ...
+               ]
+       error:  null
+
+
+get_repo_refs 
+-------------
+
+.. py:function:: get_repo_refs(apiuser, repoid)
+
+   Returns a dictionary of current references. It returns
+   bookmarks, branches, closed_branches, and tags for given repository
+
+   It's possible to specify ret_type to show only `files` or `dirs`.
+
+   This command can only be run using an |authtoken| with admin rights,
+   or users with at least read rights to |repos|.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: The repository name or repository ID.
+   :type repoid: str or int
+
+   Example output:
+
+   .. code-block:: bash
+
+       id : <id_given_in_input>
+       result: [
+                 TODO...
+               ]
+       error:  null
+
+
+get_repo_settings 
+-----------------
+
+.. py:function:: get_repo_settings(apiuser, repoid, key=<Optional:None>)
+
+   Returns all settings for a repository. If key is given it only returns the
+   setting identified by the key or null.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: The repository name or repository id.
+   :type repoid: str or int
+   :param key: Key of the setting to return.
+   :type: key: Optional(str)
+
+   Example output:
+
+   .. code-block:: bash
+
+       {
+           "error": null,
+           "id": 237,
+           "result": {
+               "extensions_largefiles": true,
+               "hooks_changegroup_push_logger": true,
+               "hooks_changegroup_repo_size": false,
+               "hooks_outgoing_pull_logger": true,
+               "phases_publish": "True",
+               "rhodecode_hg_use_rebase_for_merging": true,
+               "rhodecode_pr_merge_enabled": true,
+               "rhodecode_use_outdated_comments": true
+           }
+       }
+
+
+get_repos 
+---------
+
+.. py:function:: get_repos(apiuser)
+
+   Lists all existing repositories.
+
+   This command can only be run using an |authtoken| with admin rights,
+   or users with at least read rights to |repos|.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+
+   Example output:
+
+   .. code-block:: bash
+
+       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
+
+
+grant_user_group_permission 
+---------------------------
+
+.. py:function:: grant_user_group_permission(apiuser, repoid, usergroupid, perm)
+
+   Grant permission for a user group on the specified repository,
+   or update existing permissions.
+
+   This command can only be run using an |authtoken| with admin
+   permissions on the |repo|.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: Set the repository name or repository ID.
+   :type repoid: str or int
+   :param usergroupid: Specify the ID of the user group.
+   :type usergroupid: str or int
+   :param perm: Set the user group permissions using the following
+       format: (repository.(none|read|write|admin))
+   :type perm: str
+
+   Example output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : {
+       "msg" : "Granted perm: `<perm>` for group: `<usersgroupname>` in repo: `<reponame>`",
+       "success": true
+
+     }
+     error :  null
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : null
+     error :  {
+       "failed to edit permission for user group: `<usergroup>` in repo `<repo>`'
+     }
+
+
+grant_user_permission 
+---------------------
+
+.. py:function:: grant_user_permission(apiuser, repoid, userid, perm)
+
+   Grant permissions for the specified user on the given repository,
+   or update existing permissions if found.
+
+   This command can only be run using an |authtoken| with admin
+   permissions on the |repo|.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: Set the repository name or repository ID.
+   :type repoid: str or int
+   :param userid: Set the user name.
+   :type userid: str
+   :param perm: Set the user permissions, using the following format
+       ``(repository.(none|read|write|admin))``
+   :type perm: str
+
+   Example output:
+
+   .. code-block:: bash
+
+       id : <id_given_in_input>
+       result: {
+                 "msg" : "Granted perm: `<perm>` for user: `<username>` in repo: `<reponame>`",
+                 "success": true
+               }
+       error:  null
+
+
+invalidate_cache 
+----------------
+
+.. py:function:: invalidate_cache(apiuser, repoid, delete_keys=<Optional:False>)
+
+   Invalidates the cache for the specified repository.
+
+   This command can only be run using an |authtoken| with admin rights to
+   the specified repository.
+
+   This command takes the following options:
+
+   :param apiuser: This is filled automatically from |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: Sets the repository name or repository ID.
+   :type repoid: str or int
+   :param delete_keys: This deletes the invalidated keys instead of
+       just flagging them.
+   :type delete_keys: Optional(``True`` | ``False``)
+
+   Example output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : {
+       'msg': Cache for repository `<repository name>` was invalidated,
+       'repository': <repository name>
+     }
+     error :  null
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : null
+     error : {
+        'Error occurred during cache invalidation action'
+     }
+
+
+lock 
+----
+
+.. py:function:: lock(apiuser, repoid, locked=<Optional:None>, userid=<Optional:<OptionalAttr:apiuser>>)
+
+   Sets the lock state of the specified |repo| by the given user.
+   From more information, see :ref:`repo-locking`.
+
+   * If the ``userid`` option is not set, the repository is locked to the
+     user who called the method.
+   * If the ``locked`` parameter is not set, the current lock state of the
+     repository is displayed.
+
+   This command can only be run using an |authtoken| with admin rights to
+   the specified repository.
+
+   This command takes the following options:
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: Sets the repository name or repository ID.
+   :type repoid: str or int
+   :param locked: Sets the lock state.
+   :type locked: Optional(``True`` | ``False``)
+   :param userid: Set the repository lock to this user.
+   :type userid: Optional(str or int)
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : {
+       'repo': '<reponame>',
+       'locked': <bool: lock state>,
+       'locked_since': <int: lock timestamp>,
+       'locked_by': <username of person who made the lock>,
+       'lock_reason': <str: reason for locking>,
+       'lock_state_changed': <bool: True if lock state has been changed in this request>,
+       'msg': 'Repo `<reponame>` locked by `<username>` on <timestamp>.'
+       or
+       'msg': 'Repo `<repository name>` not locked.'
+       or
+       'msg': 'User `<user name>` set lock state for repo `<repository name>` to `<new lock state>`'
+     }
+     error :  null
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : null
+     error :  {
+       'Error occurred locking repository `<reponame>`
+     }
+
+
+pull 
+----
+
+.. py:function:: pull(apiuser, repoid)
+
+   Triggers a pull on the given repository from a remote location. You
+   can use this to keep remote repositories up-to-date.
+
+   This command can only be run using an |authtoken| with admin
+   rights to the specified repository. For more information,
+   see :ref:`config-token-ref`.
+
+   This command takes the following options:
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: The repository name or repository ID.
+   :type repoid: str or int
+
+   Example output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : {
+       "msg": "Pulled from `<repository name>`"
+       "repository": "<repository name>"
+     }
+     error :  null
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : null
+     error :  {
+       "Unable to pull changes from `<reponame>`"
+     }
+
+
+remove_field_from_repo 
+----------------------
+
+.. py:function:: remove_field_from_repo(apiuser, repoid, key)
+
+   Removes an extra field from a repository.
+
+   This command can only be run using an |authtoken| with at least
+   write permissions to the |repo|.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: Set the repository name or repository ID.
+   :type repoid: str or int
+   :param key: Set the unique field key for this repository.
+   :type key: str
+
+
+revoke_user_group_permission 
+----------------------------
+
+.. py:function:: revoke_user_group_permission(apiuser, repoid, usergroupid)
+
+   Revoke the permissions of a user group on a given repository.
+
+   This command can only be run using an |authtoken| with admin
+   permissions on the |repo|.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: Set the repository name or repository ID.
+   :type repoid: str or int
+   :param usergroupid: Specify the user group ID.
+   :type usergroupid: str or int
+
+   Example output:
+
+   .. code-block:: bash
+
+       id : <id_given_in_input>
+       result: {
+                 "msg" : "Revoked perm for group: `<usersgroupname>` in repo: `<reponame>`",
+                 "success": true
+               }
+       error:  null
+
+
+revoke_user_permission 
+----------------------
+
+.. py:function:: revoke_user_permission(apiuser, repoid, userid)
+
+   Revoke permission for a user on the specified repository.
+
+   This command can only be run using an |authtoken| with admin
+   permissions on the |repo|.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: Set the repository name or repository ID.
+   :type repoid: str or int
+   :param userid: Set the user name of revoked user.
+   :type userid: str or int
+
+   Example error output:
+
+   .. code-block:: bash
+
+       id : <id_given_in_input>
+       result: {
+                 "msg" : "Revoked perm for user: `<username>` in repo: `<reponame>`",
+                 "success": true
+               }
+       error:  null
+
+
+set_repo_settings 
+-----------------
+
+.. py:function:: set_repo_settings(apiuser, repoid, settings)
+
+   Update repository settings. Returns true on success.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: The repository name or repository id.
+   :type repoid: str or int
+   :param settings: The new settings for the repository.
+   :type: settings: dict
+
+   Example output:
+
+   .. code-block:: bash
+
+       {
+           "error": null,
+           "id": 237,
+           "result": true
+       }
+
+
+strip 
+-----
+
+.. py:function:: strip(apiuser, repoid, revision, branch)
+
+   Strips the given revision from the specified repository.
+
+   * This will remove the revision and all of its decendants.
+
+   This command can only be run using an |authtoken| with admin rights to
+   the specified repository.
+
+   This command takes the following options:
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: The repository name or repository ID.
+   :type repoid: str or int
+   :param revision: The revision you wish to strip.
+   :type revision: str
+   :param branch: The branch from which to strip the revision.
+   :type branch: str
+
+   Example output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : {
+       "msg": "'Stripped commit <commit_hash> from repo `<repository name>`'"
+       "repository": "<repository name>"
+     }
+     error :  null
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : null
+     error :  {
+       "Unable to strip commit <commit_hash> from repo `<repository name>`"
+     }
+
+
+update_repo 
+-----------
+
+.. py:function:: update_repo(apiuser, repoid, name=<Optional:None>, owner=<Optional:<OptionalAttr:apiuser>>, group=<Optional:None>, fork_of=<Optional:None>, description=<Optional:''>, private=<Optional:False>, clone_uri=<Optional:None>, landing_rev=<Optional:'rev:tip'>, enable_statistics=<Optional:False>, enable_locking=<Optional:False>, enable_downloads=<Optional:False>, fields=<Optional:''>)
+
+   Updates a repository with the given information.
+
+   This command can only be run using an |authtoken| with at least
+   write permissions to the |repo|.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param repoid: repository name or repository ID.
+   :type repoid: str or int
+   :param name: Update the |repo| name.
+   :type name: str
+   :param owner: Set the |repo| owner.
+   :type owner: str
+   :param group: Set the |repo| group the |repo| belongs to.
+   :type group: str
+   :param fork_of: Set the master |repo| name.
+   :type fork_of: str
+   :param description: Update the |repo| description.
+   :type description: str
+   :param private: Set the |repo| as private. (True | False)
+   :type private: bool
+   :param clone_uri: Update the |repo| clone URI.
+   :type clone_uri: str
+   :param landing_rev: Set the |repo| landing revision. Default is
+       ``tip``.
+   :type landing_rev: str
+   :param enable_statistics: Enable statistics on the |repo|,
+       (True | False).
+   :type enable_statistics: bool
+   :param enable_locking: Enable |repo| locking.
+   :type enable_locking: bool
+   :param enable_downloads: Enable downloads from the |repo|,
+       (True | False).
+   :type enable_downloads: bool
+   :param fields: Add extra fields to the |repo|. Use the following
+       example format: ``field_key=field_val,field_key2=fieldval2``.
+       Escape ', ' with \,
+   :type fields: str
+
+

docs/api/methods/server-methods.rst

@@ -0,0 +1,115 b''
+.. _server-methods-ref:
+
+server methods
+=================
+
+get_ip 
+------
+
+.. py:function:: get_ip(apiuser, userid=<Optional:<OptionalAttr:apiuser>>)
+
+   Displays the IP Address as seen from the |RCE| server.
+
+   * This command displays the IP Address, as well as all the defined IP
+     addresses for the specified user. If the ``userid`` is not set, the
+     data returned is for the user calling the method.
+
+   This command can only be run using an |authtoken| with admin rights to
+   the specified repository.
+
+   This command takes the following options:
+
+   :param apiuser: This is filled automatically from |authtoken|.
+   :type apiuser: AuthUser
+   :param userid: Sets the userid for which associated IP Address data
+       is returned.
+   :type userid: Optional(str or int)
+
+   Example output:
+
+   .. code-block:: bash
+
+       id : <id_given_in_input>
+       result : {
+                    "server_ip_addr": "<ip_from_clien>",
+                    "user_ips": [
+                                   {
+                                      "ip_addr": "<ip_with_mask>",
+                                      "ip_range": ["<start_ip>", "<end_ip>"],
+                                   },
+                                   ...
+                                ]
+       }
+
+
+get_server_info 
+---------------
+
+.. py:function:: get_server_info(apiuser)
+
+   Returns the |RCE| server information.
+
+   This includes the running version of |RCE| and all installed
+   packages. This command takes the following options:
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+
+   Example output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : {
+       'modules': [<module name>,...]
+       'py_version': <python version>,
+       'platform': <platform type>,
+       'rhodecode_version': <rhodecode version>
+     }
+     error :  null
+
+
+rescan_repos 
+------------
+
+.. py:function:: rescan_repos(apiuser, remove_obsolete=<Optional:False>)
+
+   Triggers a rescan of the specified repositories.
+
+   * If the ``remove_obsolete`` option is set, it also deletes repositories
+     that are found in the database but not on the file system, so called
+     "clean zombies".
+
+   This command can only be run using an |authtoken| with admin rights to
+   the specified repository.
+
+   This command takes the following options:
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param remove_obsolete: Deletes repositories from the database that
+       are not found on the filesystem.
+   :type remove_obsolete: Optional(``True`` | ``False``)
+
+   Example output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : {
+       'added': [<added repository name>,...]
+       'removed': [<removed repository name>,...]
+     }
+     error :  null
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : null
+     error :  {
+       'Error occurred during rescan repositories action'
+     }
+
+

docs/api/methods/user-group-methods.rst

@@ -0,0 +1,406 b''
+.. _user-group-methods-ref:
+
+user_group methods
+=================
+
+add_user_to_user_group 
+----------------------
+
+.. py:function:: add_user_to_user_group(apiuser, usergroupid, userid)
+
+   Adds a user to a `user group`. If the user already exists in the group
+   this command will return false.
+
+   This command can only be run using an |authtoken| with admin rights to
+   the specified user group.
+
+   This command takes the following options:
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param usergroupid: Set the name of the `user group` to which a
+       user will be added.
+   :type usergroupid: int
+   :param userid: Set the `user_id` of the user to add to the group.
+   :type userid: int
+
+   Example output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : {
+         "success": True|False # depends on if member is in group
+         "msg": "added member `<username>` to user group `<groupname>` |
+                 User is already in that group"
+
+     }
+     error :  null
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : null
+     error :  {
+       "failed to add member to user group `<user_group_name>`"
+     }
+
+
+create_user_group 
+-----------------
+
+.. py:function:: create_user_group(apiuser, group_name, description=<Optional:''>, owner=<Optional:<OptionalAttr:apiuser>>, active=<Optional:True>)
+
+   Creates a new user group.
+
+   This command can only be run using an |authtoken| with admin rights to
+   the specified repository.
+
+   This command takes the following options:
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param group_name: Set the name of the new user group.
+   :type group_name: str
+   :param description: Give a description of the new user group.
+   :type description: str
+   :param owner: Set the owner of the new user group.
+       If not set, the owner is the |authtoken| user.
+   :type owner: Optional(str or int)
+   :param active: Set this group as active.
+   :type active: Optional(``True`` | ``False``)
+
+   Example output:
+
+   .. code-block:: bash
+
+       id : <id_given_in_input>
+       result: {
+                 "msg": "created new user group `<groupname>`",
+                 "user_group": <user_group_object>
+               }
+       error:  null
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : null
+     error :  {
+       "user group `<group name>` already exist"
+       or
+       "failed to create group `<group name>`"
+     }
+
+
+delete_user_group 
+-----------------
+
+.. py:function:: delete_user_group(apiuser, usergroupid)
+
+   Deletes the specified `user group`.
+
+   This command can only be run using an |authtoken| with admin rights to
+   the specified repository.
+
+   This command takes the following options:
+
+   :param apiuser: filled automatically from apikey
+   :type apiuser: AuthUser
+   :param usergroupid:
+   :type usergroupid: int
+
+   Example output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : {
+       "msg": "deleted user group ID:<user_group_id> <user_group_name>"
+     }
+     error :  null
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : null
+     error :  {
+       "failed to delete user group ID:<user_group_id> <user_group_name>"
+       or
+       "RepoGroup assigned to <repo_groups_list>"
+     }
+
+
+get_user_group 
+--------------
+
+.. py:function:: get_user_group(apiuser, usergroupid)
+
+   Returns the data of an existing user group.
+
+   This command can only be run using an |authtoken| with admin rights to
+   the specified repository.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param usergroupid: Set the user group from which to return data.
+   :type usergroupid: str or int
+
+   Example error output:
+
+   .. code-block:: bash
+
+       {
+         "error": null,
+         "id": <id>,
+         "result": {
+           "active": true,
+           "group_description": "group description",
+           "group_name": "group name",
+           "members": [
+             {
+               "name": "owner-name",
+               "origin": "owner",
+               "permission": "usergroup.admin",
+               "type": "user"
+             },
+             {
+             {
+               "name": "user name",
+               "origin": "permission",
+               "permission": "usergroup.admin",
+               "type": "user"
+             },
+             {
+               "name": "user group name",
+               "origin": "permission",
+               "permission": "usergroup.write",
+               "type": "user_group"
+             }
+           ],
+           "owner": "owner name",
+           "users": [],
+           "users_group_id": 2
+         }
+       }
+
+
+get_user_groups 
+---------------
+
+.. py:function:: get_user_groups(apiuser)
+
+   Lists all the existing user groups within RhodeCode.
+
+   This command can only be run using an |authtoken| with admin rights to
+   the specified repository.
+
+   This command takes the following options:
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+
+   Example error output:
+
+   .. code-block:: bash
+
+       id : <id_given_in_input>
+       result : [<user_group_obj>,...]
+       error : null
+
+
+grant_user_group_permission_to_user_group 
+-----------------------------------------
+
+.. py:function:: grant_user_group_permission_to_user_group(apiuser, usergroupid, sourceusergroupid, perm)
+
+   Give one user group permissions to another user group.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param usergroupid: Set the user group on which to edit permissions.
+   :type usergroupid: str or int
+   :param sourceusergroupid: Set the source user group to which
+       access/permissions will be granted.
+   :type sourceusergroupid: str or int
+   :param perm: (usergroup.(none|read|write|admin))
+   :type perm: str
+
+   Example output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : {
+       "msg": "Granted perm: `<perm_name>` for user group: `<source_user_group_name>` in user group: `<user_group_name>`",
+       "success": true
+     }
+     error :  null
+
+
+grant_user_permission_to_user_group 
+-----------------------------------
+
+.. py:function:: grant_user_permission_to_user_group(apiuser, usergroupid, userid, perm)
+
+   Set permissions for a user in a user group.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param usergroupid: Set the user group to edit permissions on.
+   :type usergroupid: str or int
+   :param userid: Set the user from whom you wish to set permissions.
+   :type userid: str
+   :param perm: (usergroup.(none|read|write|admin))
+   :type perm: str
+
+   Example output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : {
+       "msg": "Granted perm: `<perm_name>` for user: `<username>` in user group: `<user_group_name>`",
+       "success": true
+     }
+     error :  null
+
+
+remove_user_from_user_group 
+---------------------------
+
+.. py:function:: remove_user_from_user_group(apiuser, usergroupid, userid)
+
+   Removes a user from a user group.
+
+   * If the specified user is not in the group, this command will return
+     `false`.
+
+   This command can only be run using an |authtoken| with admin rights to
+   the specified user group.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param usergroupid: Sets the user group name.
+   :type usergroupid: str or int
+   :param userid: The user you wish to remove from |RCE|.
+   :type userid: str or int
+
+   Example output:
+
+   .. code-block:: bash
+
+       id : <id_given_in_input>
+       result: {
+                 "success":  True|False,  # depends on if member is in group
+                 "msg": "removed member <username> from user group <groupname> |
+                         User wasn't in group"
+               }
+       error:  null
+
+
+revoke_user_group_permission_from_user_group 
+--------------------------------------------
+
+.. py:function:: revoke_user_group_permission_from_user_group(apiuser, usergroupid, sourceusergroupid)
+
+   Revoke the permissions that one user group has to another.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param usergroupid: Set the user group on which to edit permissions.
+   :type usergroupid: str or int
+   :param sourceusergroupid: Set the user group from which permissions
+       are revoked.
+   :type sourceusergroupid: str or int
+
+   Example output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : {
+       "msg": "Revoked perm for user group: `<user_group_name>` in user group: `<target_user_group_name>`",
+       "success": true
+     }
+     error :  null
+
+
+revoke_user_permission_from_user_group 
+--------------------------------------
+
+.. py:function:: revoke_user_permission_from_user_group(apiuser, usergroupid, userid)
+
+   Revoke a users permissions in a user group.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param usergroupid: Set the user group from which to revoke the user
+       permissions.
+   :type: usergroupid: str or int
+   :param userid: Set the userid of the user whose permissions will be
+       revoked.
+   :type userid: str
+
+   Example output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : {
+       "msg": "Revoked perm for user: `<username>` in user group: `<user_group_name>`",
+       "success": true
+     }
+     error :  null
+
+
+update_user_group 
+-----------------
+
+.. py:function:: update_user_group(apiuser, usergroupid, group_name=<Optional:''>, description=<Optional:''>, owner=<Optional:None>, active=<Optional:True>)
+
+   Updates the specified `user group` with the details provided.
+
+   This command can only be run using an |authtoken| with admin rights to
+   the specified repository.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param usergroupid: Set the id of the `user group` to update.
+   :type usergroupid: str or int
+   :param group_name: Set the new name the `user group`
+   :type group_name: str
+   :param description: Give a description for the `user group`
+   :type description: str
+   :param owner: Set the owner of the `user group`.
+   :type owner: Optional(str or int)
+   :param active: Set the group as active.
+   :type active: Optional(``True`` | ``False``)
+
+   Example output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : {
+       "msg": 'updated user group ID:<user group id> <user group name>',
+       "user_group": <user_group_object>
+     }
+     error :  null
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : null
+     error :  {
+       "failed to update user group `<user group name>`"
+     }
+
+

docs/api/methods/user-methods.rst

@@ -0,0 +1,295 b''
+.. _user-methods-ref:
+
+user methods
+=================
+
+create_user 
+-----------
+
+.. py:function:: create_user(apiuser, username, email, password=<Optional:''>, firstname=<Optional:''>, lastname=<Optional:''>, active=<Optional:True>, admin=<Optional:False>, extern_name=<Optional:'rhodecode'>, extern_type=<Optional:'rhodecode'>, force_password_change=<Optional:False>)
+
+   Creates a new user and returns the new user object.
+
+   This command can only be run using an |authtoken| with admin rights to
+   the specified repository.
+
+   This command takes the following options:
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param username: Set the new username.
+   :type username: str or int
+   :param email: Set the user email address.
+   :type email: str
+   :param password: Set the new user password.
+   :type password: Optional(str)
+   :param firstname: Set the new user firstname.
+   :type firstname: Optional(str)
+   :param lastname: Set the new user surname.
+   :type lastname: Optional(str)
+   :param active: Set the user as active.
+   :type active: Optional(``True`` | ``False``)
+   :param admin: Give the new user admin rights.
+   :type admin: Optional(``True`` | ``False``)
+   :param extern_name: Set the authentication plugin name.
+       Using LDAP this is filled with LDAP UID.
+   :type extern_name: Optional(str)
+   :param extern_type: Set the new user authentication plugin.
+   :type extern_type: Optional(str)
+   :param force_password_change: Force the new user to change password
+       on next login.
+   :type force_password_change: Optional(``True`` | ``False``)
+
+   Example output:
+
+   .. code-block:: bash
+
+       id : <id_given_in_input>
+       result: {
+                 "msg" : "created new user `<username>`",
+                 "user": <user_obj>
+               }
+       error:  null
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : null
+     error :  {
+       "user `<username>` already exist"
+       or
+       "email `<email>` already exist"
+       or
+       "failed to create user `<username>`"
+     }
+
+
+delete_user 
+-----------
+
+.. py:function:: delete_user(apiuser, userid)
+
+   Deletes the specified user from the |RCE| user database.
+
+   This command can only be run using an |authtoken| with admin rights to
+   the specified repository.
+
+   .. important::
+
+      Ensure all open pull requests and open code review
+      requests to this user are close.
+
+      Also ensure all repositories, or repository groups owned by this
+      user are reassigned before deletion.
+
+   This command takes the following options:
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param userid: Set the user to delete.
+   :type userid: str or int
+
+   Example output:
+
+   .. code-block:: bash
+
+       id : <id_given_in_input>
+       result: {
+                 "msg" : "deleted user ID:<userid> <username>",
+                 "user": null
+               }
+       error:  null
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : null
+     error :  {
+       "failed to delete user ID:<userid> <username>"
+     }
+
+
+get_user 
+--------
+
+.. py:function:: get_user(apiuser, userid=<Optional:<OptionalAttr:apiuser>>)
+
+   Returns the information associated with a username or userid.
+
+   * If the ``userid`` is not set, this command returns the information
+     for the ``userid`` calling the method.
+
+   .. note::
+
+      Normal users may only run this command against their ``userid``. For
+      full privileges you must run this command using an |authtoken| with
+      admin rights.
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param userid: Sets the userid for which data will be returned.
+   :type userid: Optional(str or int)
+
+   Example output:
+
+   .. code-block:: bash
+
+       {
+         "error": null,
+         "id": <id>,
+         "result": {
+           "active": true,
+           "admin": false,
+           "api_key": "api-key",
+           "api_keys": [ list of keys ],
+           "email": "[e-mail]",
+           "emails": [
+             "[e-mail]"
+           ],
+           "extern_name": "rhodecode",
+           "extern_type": "rhodecode",
+           "firstname": "username",
+           "ip_addresses": [],
+           "language": null,
+           "last_login": "Timestamp",
+           "lastname": "surnae",
+           "permissions": {
+             "global": [
+               "hg.inherit_default_perms.true",
+               "usergroup.read",
+               "hg.repogroup.create.false",
+               "hg.create.none",
+               "hg.extern_activate.manual",
+               "hg.create.write_on_repogroup.false",
+               "hg.usergroup.create.false",
+               "group.none",
+               "repository.none",
+               "hg.register.none",
+               "hg.fork.repository"
+             ],
+             "repositories": { "username/example": "repository.write"},
+             "repositories_groups": { "user-group/repo": "group.none" },
+             "user_groups": { "user_group_name": "usergroup.read" }
+           },
+           "user_id": 32,
+           "username": "username"
+         }
+       }
+
+
+get_user_locks 
+--------------
+
+.. py:function:: get_user_locks(apiuser, userid=<Optional:<OptionalAttr:apiuser>>)
+
+   Displays all repositories locked by the specified user.
+
+   * If this command is run by a non-admin user, it returns
+     a list of |repos| locked by that user.
+
+   This command takes the following options:
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+   :param userid: Sets the userid whose list of locked |repos| will be
+       displayed.
+   :type userid: Optional(str or int)
+
+   Example output:
+
+   .. code-block:: bash
+
+       id : <id_given_in_input>
+       result : {
+           [repo_object, repo_object,...]
+       }
+       error :  null
+
+
+get_users 
+---------
+
+.. py:function:: get_users(apiuser)
+
+   Lists all users in the |RCE| user database.
+
+   This command can only be run using an |authtoken| with admin rights to
+   the specified repository.
+
+   This command takes the following options:
+
+   :param apiuser: This is filled automatically from the |authtoken|.
+   :type apiuser: AuthUser
+
+   Example output:
+
+   .. code-block:: bash
+
+       id : <id_given_in_input>
+           result: [<user_object>, ...]
+       error:  null
+
+
+update_user 
+-----------
+
+.. py:function:: update_user(apiuser, userid, username=<Optional:None>, email=<Optional:None>, password=<Optional:None>, firstname=<Optional:None>, lastname=<Optional:None>, active=<Optional:None>, admin=<Optional:None>, extern_type=<Optional:None>, extern_name=<Optional:None>)
+
+   Updates the details for the specified user, if that user exists.
+
+   This command can only be run using an |authtoken| with admin rights to
+   the specified repository.
+
+   This command takes the following options:
+
+   :param apiuser: This is filled automatically from |authtoken|.
+   :type apiuser: AuthUser
+   :param userid: Set the ``userid`` to update.
+   :type userid: str or int
+   :param username: Set the new username.
+   :type username: str or int
+   :param email: Set the new email.
+   :type email: str
+   :param password: Set the new password.
+   :type password: Optional(str)
+   :param firstname: Set the new first name.
+   :type firstname: Optional(str)
+   :param lastname: Set the new surname.
+   :type lastname: Optional(str)
+   :param active: Set the new user as active.
+   :type active: Optional(``True`` | ``False``)
+   :param admin: Give the user admin rights.
+   :type admin: Optional(``True`` | ``False``)
+   :param extern_name: Set the authentication plugin user name.
+       Using LDAP this is filled with LDAP UID.
+   :type extern_name: Optional(str)
+   :param extern_type: Set the authentication plugin type.
+   :type extern_type: Optional(str)
+
+
+   Example output:
+
+   .. code-block:: bash
+
+       id : <id_given_in_input>
+       result: {
+                 "msg" : "updated user ID:<userid> <username>",
+                 "user": <user_object>,
+               }
+       error:  null
+
+   Example error output:
+
+   .. code-block:: bash
+
+     id : <id_given_in_input>
+     result : null
+     error :  {
+       "failed to update user `<username>`"
+     }
+
+

docs/extensions/extensions-hooks.rst

@@ -0,0 +1,25 b''
+.. _extensions-hooks-ref:
+
+Extensions & Hooks
+==================
+
+The extensions & hooks section references three concepts regularly,
+so to clarify what is meant each time, read the following definitions:
+
+* **Plugin**: A Plugin is software that adds a specific feature to
+  an existing software application.
+* **Extension**: An extension extends the capabilities of,
+  or the data available to, an existing software application.
+* **Hook**: A hook intercepts function calls, messages, or events passed
+  between software components and can be used to trigger plugins, or their
+  extensions.
+
+.. toctree::
+
+   rcx
+   install-ext
+   config-ext
+   extensions
+   hooks
+   full-blown-example
+   int-slack

docs/integrations/email.rst

@@ -0,0 +1,23 b''
+.. _integrations-email:
+
+Email integration
+=================
+
+The email integration allows you to send the summary of repo pushes to a
+list of email recipients in the format:
+
+An example::
+
+    User: johndoe
+    Branches: default
+    Repository: http://rhodecode.company.com/repo
+    Commit: 8eab60a44a612e331edfcd59b8d96b2f6a935cd9
+    URL: http://rhodecode.company.com/repo/changeset/8eab60a44a612e331edfcd59b8d96b2f6a935cd9
+    Author: John Doe
+    Date: 2016-03-01 11:20:44
+    Commit Message:
+
+    fixed bug with thing
+
+
+To create one, create a ``email`` integration in `creating-integrations`.

docs/integrations/hipchat.rst

@@ -0,0 +1,14 b''
+.. _integrations-hipchat:
+
+Hipchat integration
+===================
+
+In order to set a Hipchat integration up, it is necessary to obtain the Hipchat
+service url by:
+
+1. Log into Hipchat (https://your-hipchat.hipchat.com/)
+2. Go to *Integrations* -> *Build your own*
+3. Select a room to post notifications to and save it
+
+Hipchat will create a URL for you to use in your integration as outlined in
+:ref:`creating-integrations`.
  No newline at end of file

docs/integrations/jira.rst

@@ -0,0 +1,27 b''
+.. _integrations-jira:
+
+JIRA integration
+================
+
+.. important::
+
+    JIRA integration is only available in |RCEE|.
+
+
+.. important::
+
+    In order to make issue numbers clickable in commit messages, see the
+    :ref:`rhodecode-issue-trackers-ref` section. The JIRA integration
+    only deals with altering JIRA issues.
+
+
+The JIRA integration allows you to reference and change issue statuses in
+JIRA directly from commit messages using commit message patterns such as
+``fixes #JIRA-235`` in order to change the status of issue JIRA-235 to
+eg. "Resolved".
+
+In order to apply a status to a JIRA issue, it is necessary to find the
+transition status id in the *Workflow* section of JIRA.
+
+Once you have the transition status id, you can create a JIRA integration
+as outlined in :ref:`creating-integrations`.

docs/integrations/redmine.rst

@@ -0,0 +1,28 b''
+.. _integrations-redmine:
+
+Redmine integration
+===================
+
+.. important::
+
+    Redmine integration is only available in |RCEE|.
+
+
+.. important::
+
+    In order to make issue numbers clickable in commit messages, see the section
+    :ref:`rhodecode-issue-trackers-ref`. Redmine integration is specifically for
+    altering Redmine issues.
+
+
+Redmine integration allows you to reference and change issue statuses in
+Redmine directly from commit messages, using commit message patterns such as
+``fixes #235`` in order to change the status of issue 235 to eg. "Resolved".
+
+To set a Redmine integration up, it is first necessary to obtain a Redmine API
+key. This can be found under *My Account* in the Redmine application.
+You may have to enable API Access in Redmine settings if it is not already
+available.
+
+Once you have the API key, create a Redmine integration as outlined in
+:ref:`creating-integrations`.

docs/integrations/slack.rst

@@ -0,0 +1,21 b''
+.. _integrations-slack:
+
+Slack integration
+=================
+
+To set a Slack integration up, it is first necessary to set up a Slack webhook
+API endpoint for your Slack channel. This can be done at:
+
+https://my.slack.com/services/new/incoming-webhook/
+
+Select the channel you would like to use, and Slack will provide you with the
+webhook URL for configuration.
+
+You can now create a Slack integration as outlined in
+:ref:`creating-integrations`.
+
+.. note::
+    Some settings in the RhodeCode admin are identical to the options within the
+    Slack integration. For example, if notifications are to be sent in a private
+    chat, leave the "Channel" field blank. Likewise, the Emoji option within
+    RhodeCode can override the one set in the Slack admin.
  No newline at end of file

docs/integrations/webhook.rst

@@ -0,0 +1,12 b''
+.. _integrations-webhook:
+
+Webhook integration
+===================
+
+The Webhook integration allows you to POST events such as repository pushes
+or pull requests to a custom http endpoint as a json dict with details of the
+event.
+
+To create a webhook integration, select "webhook" in the integration settings
+and use the url and key from your custom webhook. See
+:ref:`creating-integrations` for additional instructions.
  No newline at end of file

docs/release-notes/release-notes-4.3.0.rst

@@ -0,0 +1,121 b''
+|RCE| 4.3.0 |RNS|
+-----------------
+
+Release Date
+^^^^^^^^^^^^
+
+- 2016-08-12
+
+
+General
+^^^^^^^
+
+- Subversion: detect requests also based on magic path.
+  This adds subversion 1.9 support for SVN backend.
+- Summary/changelog: unified how data is displayed for those pages.
+    * use consistent order of columns
+    * fix the link to commit status
+    * fix order of displaying comments
+- Live-chat: refactor live chat system for code review based on
+  latest channelstream changes.
+- SVN: Add template to generate the apache mod_dav_svn config for all
+  repository groups. Repository groups can now be automatically mapped to be
+  supported by SVN backend. Set `svn.proxy.generate_config = true` and similar
+  options found inside .ini config.
+- Readme/markup: improved order of generating readme files. Fixes #4050
+    * we now use order based on default system renderer
+    * having multiple readme files will pick correct one as set renderer
+- Api: add a max_file_bytes parameter to get_nodes so that large files
+  can be skipped.
+- Auth-ldap: added flag to set debug mode for LDAP connections.
+- Labs: moved rebase-merge option from labs settings into VCS settings.
+- System: send platform type and version to upgrade endpoint when checking
+  for new versions.
+- Packaging: update rhodecode-tools from 0.8.3 to 0.10.0
+- Packaging: update codemirror from 5.4.0 to 5.11.0
+- Packaging: updated pygments to 2.1.3
+- Packaging: bumped supervisor to 3.3.0
+- Packaging: bumped psycopg2 to 2.6.1
+- Packaging: bumped mercurial to 3.8.4
+
+
+New Features
+^^^^^^^^^^^^
+
+- Integrations: created new event based integration framework.
+  Allows to configure global, or per repo: Slack, Hipchat, Webhooks, Email
+  integrations. This also deprecated usage of rcextensions for those.
+- Integrations (EE only): added smart commits for Jira and Redmine with
+  ability to map keywords into issue tracker actions.
+  `Fixes #123 -> resolves issues`, `Closes #123 -> closes issue` etc.
+- Markdown: added improved support for Github flavored markdown.
+- Labs: enable labs setting by default. Labs are new experimental features in
+  RhodeCode that can be used to test new upcomming features.
+- Api: Add api methods to get/set repository settings, implements #4021.
+- Gravatars: commit emails are now displayed based on the actual email
+  used inside commit rather then the main one of associated account
+  inside RhodeCode, #4037.
+- Emails: All emails got new styling. They look now consistent
+  to UI of application. We also added bunch of usefull information into
+  email body, #4087.
+- Pull requests: add show/hide comment functionality inside diffs, #4106.
+- Notifications: added real-time notifications with via channelstream
+  about new comments when reviewing the code. Never miss someone replies
+  onto comments you submitted while doing a code-review.
+
+
+Security
+^^^^^^^^
+
+- Api: make `comment_commits` api call have consistent permissions
+  with web interface.
+- Files: fixes display of "Add File" button missing or present despite
+  permissions, because of cached version of the page was rendered, fixes #4083.
+- Login/Registration: fixed flash message problem on login/registration
+  pages, fixes #4043.
+- Auth-token: allow other authentication types to use auth-token.
+  Accounts associated with other types like LDAP, or PAM can
+  now use auth-tokens to authenticate via RhodeCode.
+
+
+Performance
+^^^^^^^^^^^
+
+- Core: made all RhodeCode components gevent compatible. RhodeCode can now make
+  use of async workers. You can handle dozens of concurrent operations using a
+  single worker. This works only with new HTTP backend.
+- Core: added new very efficient HTTP backend can be used to replace pyro4.
+- Core: Set 'gzip_responses' to false by default. We no longer require any
+  gzip computations on backed, thus speeding up large file transfers.
+- UI: optimized events system for JavaScript to boost performance on
+  large html pages.
+- VCS: moved VCSMiddleware up to pyramid layer as wrapper around pylons app.
+  Skips few calls, and allows slightly faster clones/pulls and pushes.
+
+
+Fixes
+^^^^^
+
+- VCS: add vcsserver cache invalidation to mercurial backend.
+  Fixes multi-process problems after Mercurial 3.8.X release with server
+  side merges.
+- VCS: clear caches on remap-and-rescan option.
+- VCS: improved logic of updating commit caches in cases of rebases.
+- Caches: Add an argument to make the cache context thread scoped. Brings
+  support to gevent compatible handling.
+- Diff2way: fixed unicode problem on non-ascii files.
+- Full text search: whoosh schema uses now bigger ints, fixes #4035
+- File-browser: optimized cached tree calculation, reduced load times by
+  50% on complex file trees.
+- Styling: #4086 fixing bug where long commit messages did not wrap in file view.
+- SVN: Ignore the content length header from response, fixes #4112.
+  Fixes the "svn: E120106: ra_serf: The server sent a truncated HTTP response body."
+- Auth: Fix password_changed function, fixes #4043.
+- UI/tables: better message when tables are empty #685 #1832.
+- UX: put gravatar and username together in user list #3203.
+- Gists: use colander schema to validate input data.
+    * brings consistent validation acros API and web
+    * use nicer and stricter schemas to validate data
+    * fixes #4118
+- Appenlight: error reporting can now also report VCSMiddleware errors.
+- Users: hash email key for User.get_by_email() fixes #4132

licenses/tornado_license.txt

@@ -0,0 +1,13 b''
+# Copyright 2009 Facebook
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.

.bumpversion.cfg

@@ -1,6 +1,6 b''
 [bumpversion]
-current_version = 4.2.1
+current_version = 4.3.0
 message = release: Bump version {current_version} to {new_version}
 
 [bumpversion:file:rhodecode/VERSION]
 

.hgignore

@@ -1,58 +1,59 b''
 syntax: glob
 *.egg
 *.egg-info
 *.idea
 *.orig
 *.pyc
 *.sqlite-journal
 *.swp
 *.tox
 *.DS_Store*
 
 syntax: regexp
 
 #.filename
 ^\.settings$
 ^\.project$
 ^\.pydevproject$
 ^\.coverage$
 ^\.cache.*$
 ^\.rhodecode$
 
 ^rcextensions
 ^_dev
 ^._dev
 ^build/
 ^coverage\.xml$
 ^data$
+^\.eggs/
 ^configs/data$
 ^dev.ini$
 ^acceptance_tests/dev.*\.ini$
 ^dist/
 ^fabfile.py
 ^htmlcov
 ^junit\.xml$
 ^node_modules/
 ^pylint.log$
 ^rcextensions/
 ^result$
 ^rhodecode/public/css/style.css$
 ^rhodecode/public/js/scripts.js$
 ^rhodecode\.db$
 ^rhodecode\.log$
 ^rhodecode_dev\.log$
 ^test\.db$
 
 # ac-tests
 ^acceptance_tests/\.cache.*$
 ^acceptance_tests/externals
 ^acceptance_tests/ghostdriver.log$
 ^acceptance_tests/local(_.+)?\.ini$
 
 # docs
 ^docs/_build$
 ^docs/result$
 ^docs-internal/_build$
 
 # Cythonized things
 ^rhodecode/.*\.(c|so)$

.release.cfg

@@ -1,33 +1,28 b''
 [DEFAULT]
 done = false
 
 [task:bump_version]
 done = true
 
-[task:rc_tools_pinned]
-done = true
-
 [task:fixes_on_stable]
-done = true
 
 [task:pip2nix_generated]
-done = true
 
 [task:changelog_updated]
-done = true
 
 [task:generate_api_docs]
-done = true
+
+[task:updated_translation]
 
 [release]
-state = prepared
-version = 4.2.1
+state = in_progress
+version = 4.3.0
 
-[task:updated_translation]
+[task:rc_tools_pinned]
 
 [task:generate_js_routes]
 
 [task:updated_trial_license]
 
 [task:generate_oss_licenses]
 

Gruntfile.js

@@ -1,139 +1,144 b''
 module.exports = function(grunt) {
   grunt.initConfig({
 
     dirs: {
       css: "rhodecode/public/css",
       js: {
         "src": "rhodecode/public/js/src",
         "dest": "rhodecode/public/js"
       }
     },
 
     concat: {
       dist: {
         src: [
           // Base libraries
           '<%= dirs.js.src %>/jquery-1.11.1.min.js',
           '<%= dirs.js.src %>/logging.js',
           '<%= dirs.js.src %>/bootstrap.js',
           '<%= dirs.js.src %>/mousetrap.js',
           '<%= dirs.js.src %>/moment.js',
           '<%= dirs.js.src %>/appenlight-client-0.4.1.min.js',
           '<%= dirs.js.src %>/i18n_utils.js',
+          '<%= dirs.js.src %>/deform.js',
 
           // Plugins
           '<%= dirs.js.src %>/plugins/jquery.pjax.js',
           '<%= dirs.js.src %>/plugins/jquery.dataTables.js',
           '<%= dirs.js.src %>/plugins/flavoured_checkbox.js',
           '<%= dirs.js.src %>/plugins/jquery.auto-grow-input.js',
           '<%= dirs.js.src %>/plugins/jquery.autocomplete.js',
           '<%= dirs.js.src %>/plugins/jquery.debounce.js',
           '<%= dirs.js.src %>/plugins/jquery.mark.js',
           '<%= dirs.js.src %>/plugins/jquery.timeago.js',
           '<%= dirs.js.src %>/plugins/jquery.timeago-extension.js',
+          '<%= dirs.js.src %>/plugins/toastr.js',
 
           // Select2
           '<%= dirs.js.src %>/select2/select2.js',
 
           // Code-mirror
           '<%= dirs.js.src %>/codemirror/codemirror.js',
           '<%= dirs.js.src %>/codemirror/codemirror_loadmode.js',
           '<%= dirs.js.src %>/codemirror/codemirror_hint.js',
           '<%= dirs.js.src %>/codemirror/codemirror_overlay.js',
           '<%= dirs.js.src %>/codemirror/codemirror_placeholder.js',
           // TODO: mikhail: this is an exception. Since the code mirror modes
           // are loaded "on the fly", we need to keep them in a public folder
           '<%= dirs.js.dest %>/mode/meta.js',
           '<%= dirs.js.dest %>/mode/meta_ext.js',
           '<%= dirs.js.dest %>/rhodecode/i18n/select2/translations.js',
 
           // Rhodecode utilities
           '<%= dirs.js.src %>/rhodecode/utils/array.js',
           '<%= dirs.js.src %>/rhodecode/utils/string.js',
           '<%= dirs.js.src %>/rhodecode/utils/pyroutes.js',
           '<%= dirs.js.src %>/rhodecode/utils/ajax.js',
           '<%= dirs.js.src %>/rhodecode/utils/autocomplete.js',
           '<%= dirs.js.src %>/rhodecode/utils/colorgenerator.js',
           '<%= dirs.js.src %>/rhodecode/utils/ie.js',
           '<%= dirs.js.src %>/rhodecode/utils/os.js',
+          '<%= dirs.js.src %>/rhodecode/utils/topics.js',
 
           // Rhodecode widgets
           '<%= dirs.js.src %>/rhodecode/widgets/multiselect.js',
 
           // Rhodecode components
           '<%= dirs.js.src %>/rhodecode/init.js',
+          '<%= dirs.js.src %>/rhodecode/connection_controller.js',
           '<%= dirs.js.src %>/rhodecode/codemirror.js',
           '<%= dirs.js.src %>/rhodecode/comments.js',
           '<%= dirs.js.src %>/rhodecode/constants.js',
           '<%= dirs.js.src %>/rhodecode/files.js',
           '<%= dirs.js.src %>/rhodecode/followers.js',
           '<%= dirs.js.src %>/rhodecode/menus.js',
           '<%= dirs.js.src %>/rhodecode/notifications.js',
           '<%= dirs.js.src %>/rhodecode/permissions.js',
           '<%= dirs.js.src %>/rhodecode/pjax.js',
           '<%= dirs.js.src %>/rhodecode/pullrequests.js',
           '<%= dirs.js.src %>/rhodecode/settings.js',
           '<%= dirs.js.src %>/rhodecode/select2_widgets.js',
           '<%= dirs.js.src %>/rhodecode/tooltips.js',
           '<%= dirs.js.src %>/rhodecode/users.js',
+          '<%= dirs.js.src %>/rhodecode/utils/notifications.js',
           '<%= dirs.js.src %>/rhodecode/appenlight.js',
 
           // Rhodecode main module
           '<%= dirs.js.src %>/rhodecode.js'
         ],
         dest: '<%= dirs.js.dest %>/scripts.js',
         nonull: true
       }
     },
 
     less: {
       development: {
         options: {
           compress: false,
           yuicompress: false,
           optimization: 0
         },
         files: {
           "<%= dirs.css %>/style.css": "<%= dirs.css %>/main.less"
         }
       },
       production: {
         options: {
           compress: true,
           yuicompress: true,
           optimization: 2
         },
         files: {
           "<%= dirs.css %>/style.css": "<%= dirs.css %>/main.less"
         }
       }
     },
 
     watch: {
       less: {
         files: ["<%= dirs.css %>/*.less"],
         tasks: ["less:production"]
       },
       js: {
         files: ["<%= dirs.js.src %>/**/*.js"],
         tasks: ["concat:dist"]
       }
     },
 
     jshint: {
       rhodecode: {
         src: '<%= dirs.js.src %>/rhodecode/**/*.js',
         options: {
           jshintrc: '.jshintrc'
         }
       }
     }
   });
 
   grunt.loadNpmTasks('grunt-contrib-less');
   grunt.loadNpmTasks('grunt-contrib-concat');
   grunt.loadNpmTasks('grunt-contrib-watch');
   grunt.loadNpmTasks('grunt-contrib-jshint');
 
   grunt.registerTask('default', ['less:production', 'concat:dist']);
 };

LICENSE.txt

@@ -1,690 +1,692 b''
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU Affero General Public License, version 3
 (only), as published by the Free Software Foundation.
 
 
 This program incorporates work covered by the following copyright and
 permission notice:
 
    Copyright (c) 2014-2016 - packaging
        file:
    Copyright (c) 2008-2011 - msgpack-python
        file:licenses/msgpack_license.txt
+   Copyright (c) 2009 - tornado
+       file:licenses/tornado_license.txt
 
-Both licensed under the Apache License, Version 2.0 (the "License");
+All licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
 
     http://www.apache.org/licenses/LICENSE-2.0
 
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 imitations under the License.
 
 
 Below is the full text of GNU Affero General Public License, version 3
 
 
                     GNU AFFERO GENERAL PUBLIC LICENSE
                        Version 3, 19 November 2007
 
  Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
                             Preamble
 
   The GNU Affero General Public License is a free, copyleft license for
 software and other kinds of works, specifically designed to ensure
 cooperation with the community in the case of network server software.
 
   The licenses for most software and other practical works are designed
 to take away your freedom to share and change the works.  By contrast,
 our General Public Licenses are intended to guarantee your freedom to
 share and change all versions of a program--to make sure it remains free
 software for all its users.
 
   When we speak of free software, we are referring to freedom, not
 price.  Our General Public Licenses are designed to make sure that you
 have the freedom to distribute copies of free software (and charge for
 them if you wish), that you receive source code or can get it if you
 want it, that you can change the software or use pieces of it in new
 free programs, and that you know you can do these things.
 
   Developers that use our General Public Licenses protect your rights
 with two steps: (1) assert copyright on the software, and (2) offer
 you this License which gives you legal permission to copy, distribute
 and/or modify the software.
 
   A secondary benefit of defending all users' freedom is that
 improvements made in alternate versions of the program, if they
 receive widespread use, become available for other developers to
 incorporate.  Many developers of free software are heartened and
 encouraged by the resulting cooperation.  However, in the case of
 software used on network servers, this result may fail to come about.
 The GNU General Public License permits making a modified version and
 letting the public access it on a server without ever releasing its
 source code to the public.
 
   The GNU Affero General Public License is designed specifically to
 ensure that, in such cases, the modified source code becomes available
 to the community.  It requires the operator of a network server to
 provide the source code of the modified version running there to the
 users of that server.  Therefore, public use of a modified version, on
 a publicly accessible server, gives the public access to the source
 code of the modified version.
 
   An older license, called the Affero General Public License and
 published by Affero, was designed to accomplish similar goals.  This is
 a different license, not a version of the Affero GPL, but Affero has
 released a new version of the Affero GPL which permits relicensing under
 this license.
 
   The precise terms and conditions for copying, distribution and
 modification follow.
 
                        TERMS AND CONDITIONS
 
   0. Definitions.
 
   "This License" refers to version 3 of the GNU Affero General Public License.
 
   "Copyright" also means copyright-like laws that apply to other kinds of
 works, such as semiconductor masks.
 
   "The Program" refers to any copyrightable work licensed under this
 License.  Each licensee is addressed as "you".  "Licensees" and
 "recipients" may be individuals or organizations.
 
   To "modify" a work means to copy from or adapt all or part of the work
 in a fashion requiring copyright permission, other than the making of an
 exact copy.  The resulting work is called a "modified version" of the
 earlier work or a work "based on" the earlier work.
 
   A "covered work" means either the unmodified Program or a work based
 on the Program.
 
   To "propagate" a work means to do anything with it that, without
 permission, would make you directly or secondarily liable for
 infringement under applicable copyright law, except executing it on a
 computer or modifying a private copy.  Propagation includes copying,
 distribution (with or without modification), making available to the
 public, and in some countries other activities as well.
 
   To "convey" a work means any kind of propagation that enables other
 parties to make or receive copies.  Mere interaction with a user through
 a computer network, with no transfer of a copy, is not conveying.
 
   An interactive user interface displays "Appropriate Legal Notices"
 to the extent that it includes a convenient and prominently visible
 feature that (1) displays an appropriate copyright notice, and (2)
 tells the user that there is no warranty for the work (except to the
 extent that warranties are provided), that licensees may convey the
 work under this License, and how to view a copy of this License.  If
 the interface presents a list of user commands or options, such as a
 menu, a prominent item in the list meets this criterion.
 
   1. Source Code.
 
   The "source code" for a work means the preferred form of the work
 for making modifications to it.  "Object code" means any non-source
 form of a work.
 
   A "Standard Interface" means an interface that either is an official
 standard defined by a recognized standards body, or, in the case of
 interfaces specified for a particular programming language, one that
 is widely used among developers working in that language.
 
   The "System Libraries" of an executable work include anything, other
 than the work as a whole, that (a) is included in the normal form of
 packaging a Major Component, but which is not part of that Major
 Component, and (b) serves only to enable use of the work with that
 Major Component, or to implement a Standard Interface for which an
 implementation is available to the public in source code form.  A
 "Major Component", in this context, means a major essential component
 (kernel, window system, and so on) of the specific operating system
 (if any) on which the executable work runs, or a compiler used to
 produce the work, or an object code interpreter used to run it.
 
   The "Corresponding Source" for a work in object code form means all
 the source code needed to generate, install, and (for an executable
 work) run the object code and to modify the work, including scripts to
 control those activities.  However, it does not include the work's
 System Libraries, or general-purpose tools or generally available free
 programs which are used unmodified in performing those activities but
 which are not part of the work.  For example, Corresponding Source
 includes interface definition files associated with source files for
 the work, and the source code for shared libraries and dynamically
 linked subprograms that the work is specifically designed to require,
 such as by intimate data communication or control flow between those
 subprograms and other parts of the work.
 
   The Corresponding Source need not include anything that users
 can regenerate automatically from other parts of the Corresponding
 Source.
 
   The Corresponding Source for a work in source code form is that
 same work.
 
   2. Basic Permissions.
 
   All rights granted under this License are granted for the term of
 copyright on the Program, and are irrevocable provided the stated
 conditions are met.  This License explicitly affirms your unlimited
 permission to run the unmodified Program.  The output from running a
 covered work is covered by this License only if the output, given its
 content, constitutes a covered work.  This License acknowledges your
 rights of fair use or other equivalent, as provided by copyright law.
 
   You may make, run and propagate covered works that you do not
 convey, without conditions so long as your license otherwise remains
 in force.  You may convey covered works to others for the sole purpose
 of having them make modifications exclusively for you, or provide you
 with facilities for running those works, provided that you comply with
 the terms of this License in conveying all material for which you do
 not control copyright.  Those thus making or running the covered works
 for you must do so exclusively on your behalf, under your direction
 and control, on terms that prohibit them from making any copies of
 your copyrighted material outside their relationship with you.
 
   Conveying under any other circumstances is permitted solely under
 the conditions stated below.  Sublicensing is not allowed; section 10
 makes it unnecessary.
 
   3. Protecting Users' Legal Rights From Anti-Circumvention Law.
 
   No covered work shall be deemed part of an effective technological
 measure under any applicable law fulfilling obligations under article
 11 of the WIPO copyright treaty adopted on 20 December 1996, or
 similar laws prohibiting or restricting circumvention of such
 measures.
 
   When you convey a covered work, you waive any legal power to forbid
 circumvention of technological measures to the extent such circumvention
 is effected by exercising rights under this License with respect to
 the covered work, and you disclaim any intention to limit operation or
 modification of the work as a means of enforcing, against the work's
 users, your or third parties' legal rights to forbid circumvention of
 technological measures.
 
   4. Conveying Verbatim Copies.
 
   You may convey verbatim copies of the Program's source code as you
 receive it, in any medium, provided that you conspicuously and
 appropriately publish on each copy an appropriate copyright notice;
 keep intact all notices stating that this License and any
 non-permissive terms added in accord with section 7 apply to the code;
 keep intact all notices of the absence of any warranty; and give all
 recipients a copy of this License along with the Program.
 
   You may charge any price or no price for each copy that you convey,
 and you may offer support or warranty protection for a fee.
 
   5. Conveying Modified Source Versions.
 
   You may convey a work based on the Program, or the modifications to
 produce it from the Program, in the form of source code under the
 terms of section 4, provided that you also meet all of these conditions:
 
     a) The work must carry prominent notices stating that you modified
     it, and giving a relevant date.
 
     b) The work must carry prominent notices stating that it is
     released under this License and any conditions added under section
     7.  This requirement modifies the requirement in section 4 to
     "keep intact all notices".
 
     c) You must license the entire work, as a whole, under this
     License to anyone who comes into possession of a copy.  This
     License will therefore apply, along with any applicable section 7
     additional terms, to the whole of the work, and all its parts,
     regardless of how they are packaged.  This License gives no
     permission to license the work in any other way, but it does not
     invalidate such permission if you have separately received it.
 
     d) If the work has interactive user interfaces, each must display
     Appropriate Legal Notices; however, if the Program has interactive
     interfaces that do not display Appropriate Legal Notices, your
     work need not make them do so.
 
   A compilation of a covered work with other separate and independent
 works, which are not by their nature extensions of the covered work,
 and which are not combined with it such as to form a larger program,
 in or on a volume of a storage or distribution medium, is called an
 "aggregate" if the compilation and its resulting copyright are not
 used to limit the access or legal rights of the compilation's users
 beyond what the individual works permit.  Inclusion of a covered work
 in an aggregate does not cause this License to apply to the other
 parts of the aggregate.
 
   6. Conveying Non-Source Forms.
 
   You may convey a covered work in object code form under the terms
 of sections 4 and 5, provided that you also convey the
 machine-readable Corresponding Source under the terms of this License,
 in one of these ways:
 
     a) Convey the object code in, or embodied in, a physical product
     (including a physical distribution medium), accompanied by the
     Corresponding Source fixed on a durable physical medium
     customarily used for software interchange.
 
     b) Convey the object code in, or embodied in, a physical product
     (including a physical distribution medium), accompanied by a
     written offer, valid for at least three years and valid for as
     long as you offer spare parts or customer support for that product
     model, to give anyone who possesses the object code either (1) a
     copy of the Corresponding Source for all the software in the
     product that is covered by this License, on a durable physical
     medium customarily used for software interchange, for a price no
     more than your reasonable cost of physically performing this
     conveying of source, or (2) access to copy the
     Corresponding Source from a network server at no charge.
 
     c) Convey individual copies of the object code with a copy of the
     written offer to provide the Corresponding Source.  This
     alternative is allowed only occasionally and noncommercially, and
     only if you received the object code with such an offer, in accord
     with subsection 6b.
 
     d) Convey the object code by offering access from a designated
     place (gratis or for a charge), and offer equivalent access to the
     Corresponding Source in the same way through the same place at no
     further charge.  You need not require recipients to copy the
     Corresponding Source along with the object code.  If the place to
     copy the object code is a network server, the Corresponding Source
     may be on a different server (operated by you or a third party)
     that supports equivalent copying facilities, provided you maintain
     clear directions next to the object code saying where to find the
     Corresponding Source.  Regardless of what server hosts the
     Corresponding Source, you remain obligated to ensure that it is
     available for as long as needed to satisfy these requirements.
 
     e) Convey the object code using peer-to-peer transmission, provided
     you inform other peers where the object code and Corresponding
     Source of the work are being offered to the general public at no
     charge under subsection 6d.
 
   A separable portion of the object code, whose source code is excluded
 from the Corresponding Source as a System Library, need not be
 included in conveying the object code work.
 
   A "User Product" is either (1) a "consumer product", which means any
 tangible personal property which is normally used for personal, family,
 or household purposes, or (2) anything designed or sold for incorporation
 into a dwelling.  In determining whether a product is a consumer product,
 doubtful cases shall be resolved in favor of coverage.  For a particular
 product received by a particular user, "normally used" refers to a
 typical or common use of that class of product, regardless of the status
 of the particular user or of the way in which the particular user
 actually uses, or expects or is expected to use, the product.  A product
 is a consumer product regardless of whether the product has substantial
 commercial, industrial or non-consumer uses, unless such uses represent
 the only significant mode of use of the product.
 
   "Installation Information" for a User Product means any methods,
 procedures, authorization keys, or other information required to install
 and execute modified versions of a covered work in that User Product from
 a modified version of its Corresponding Source.  The information must
 suffice to ensure that the continued functioning of the modified object
 code is in no case prevented or interfered with solely because
 modification has been made.
 
   If you convey an object code work under this section in, or with, or
 specifically for use in, a User Product, and the conveying occurs as
 part of a transaction in which the right of possession and use of the
 User Product is transferred to the recipient in perpetuity or for a
 fixed term (regardless of how the transaction is characterized), the
 Corresponding Source conveyed under this section must be accompanied
 by the Installation Information.  But this requirement does not apply
 if neither you nor any third party retains the ability to install
 modified object code on the User Product (for example, the work has
 been installed in ROM).
 
   The requirement to provide Installation Information does not include a
 requirement to continue to provide support service, warranty, or updates
 for a work that has been modified or installed by the recipient, or for
 the User Product in which it has been modified or installed.  Access to a
 network may be denied when the modification itself materially and
 adversely affects the operation of the network or violates the rules and
 protocols for communication across the network.
 
   Corresponding Source conveyed, and Installation Information provided,
 in accord with this section must be in a format that is publicly
 documented (and with an implementation available to the public in
 source code form), and must require no special password or key for
 unpacking, reading or copying.
 
   7. Additional Terms.
 
   "Additional permissions" are terms that supplement the terms of this
 License by making exceptions from one or more of its conditions.
 Additional permissions that are applicable to the entire Program shall
 be treated as though they were included in this License, to the extent
 that they are valid under applicable law.  If additional permissions
 apply only to part of the Program, that part may be used separately
 under those permissions, but the entire Program remains governed by
 this License without regard to the additional permissions.
 
   When you convey a copy of a covered work, you may at your option
 remove any additional permissions from that copy, or from any part of
 it.  (Additional permissions may be written to require their own
 removal in certain cases when you modify the work.)  You may place
 additional permissions on material, added by you to a covered work,
 for which you have or can give appropriate copyright permission.
 
   Notwithstanding any other provision of this License, for material you
 add to a covered work, you may (if authorized by the copyright holders of
 that material) supplement the terms of this License with terms:
 
     a) Disclaiming warranty or limiting liability differently from the
     terms of sections 15 and 16 of this License; or
 
     b) Requiring preservation of specified reasonable legal notices or
     author attributions in that material or in the Appropriate Legal
     Notices displayed by works containing it; or
 
     c) Prohibiting misrepresentation of the origin of that material, or
     requiring that modified versions of such material be marked in
     reasonable ways as different from the original version; or
 
     d) Limiting the use for publicity purposes of names of licensors or
     authors of the material; or
 
     e) Declining to grant rights under trademark law for use of some
     trade names, trademarks, or service marks; or
 
     f) Requiring indemnification of licensors and authors of that
     material by anyone who conveys the material (or modified versions of
     it) with contractual assumptions of liability to the recipient, for
     any liability that these contractual assumptions directly impose on
     those licensors and authors.
 
   All other non-permissive additional terms are considered "further
 restrictions" within the meaning of section 10.  If the Program as you
 received it, or any part of it, contains a notice stating that it is
 governed by this License along with a term that is a further
 restriction, you may remove that term.  If a license document contains
 a further restriction but permits relicensing or conveying under this
 License, you may add to a covered work material governed by the terms
 of that license document, provided that the further restriction does
 not survive such relicensing or conveying.
 
   If you add terms to a covered work in accord with this section, you
 must place, in the relevant source files, a statement of the
 additional terms that apply to those files, or a notice indicating
 where to find the applicable terms.
 
   Additional terms, permissive or non-permissive, may be stated in the
 form of a separately written license, or stated as exceptions;
 the above requirements apply either way.
 
   8. Termination.
 
   You may not propagate or modify a covered work except as expressly
 provided under this License.  Any attempt otherwise to propagate or
 modify it is void, and will automatically terminate your rights under
 this License (including any patent licenses granted under the third
 paragraph of section 11).
 
   However, if you cease all violation of this License, then your
 license from a particular copyright holder is reinstated (a)
 provisionally, unless and until the copyright holder explicitly and
 finally terminates your license, and (b) permanently, if the copyright
 holder fails to notify you of the violation by some reasonable means
 prior to 60 days after the cessation.
 
   Moreover, your license from a particular copyright holder is
 reinstated permanently if the copyright holder notifies you of the
 violation by some reasonable means, this is the first time you have
 received notice of violation of this License (for any work) from that
 copyright holder, and you cure the violation prior to 30 days after
 your receipt of the notice.
 
   Termination of your rights under this section does not terminate the
 licenses of parties who have received copies or rights from you under
 this License.  If your rights have been terminated and not permanently
 reinstated, you do not qualify to receive new licenses for the same
 material under section 10.
 
   9. Acceptance Not Required for Having Copies.
 
   You are not required to accept this License in order to receive or
 run a copy of the Program.  Ancillary propagation of a covered work
 occurring solely as a consequence of using peer-to-peer transmission
 to receive a copy likewise does not require acceptance.  However,
 nothing other than this License grants you permission to propagate or
 modify any covered work.  These actions infringe copyright if you do
 not accept this License.  Therefore, by modifying or propagating a
 covered work, you indicate your acceptance of this License to do so.
 
   10. Automatic Licensing of Downstream Recipients.
 
   Each time you convey a covered work, the recipient automatically
 receives a license from the original licensors, to run, modify and
 propagate that work, subject to this License.  You are not responsible
 for enforcing compliance by third parties with this License.
 
   An "entity transaction" is a transaction transferring control of an
 organization, or substantially all assets of one, or subdividing an
 organization, or merging organizations.  If propagation of a covered
 work results from an entity transaction, each party to that
 transaction who receives a copy of the work also receives whatever
 licenses to the work the party's predecessor in interest had or could
 give under the previous paragraph, plus a right to possession of the
 Corresponding Source of the work from the predecessor in interest, if
 the predecessor has it or can get it with reasonable efforts.
 
   You may not impose any further restrictions on the exercise of the
 rights granted or affirmed under this License.  For example, you may
 not impose a license fee, royalty, or other charge for exercise of
 rights granted under this License, and you may not initiate litigation
 (including a cross-claim or counterclaim in a lawsuit) alleging that
 any patent claim is infringed by making, using, selling, offering for
 sale, or importing the Program or any portion of it.
 
   11. Patents.
 
   A "contributor" is a copyright holder who authorizes use under this
 License of the Program or a work on which the Program is based.  The
 work thus licensed is called the contributor's "contributor version".
 
   A contributor's "essential patent claims" are all patent claims
 owned or controlled by the contributor, whether already acquired or
 hereafter acquired, that would be infringed by some manner, permitted
 by this License, of making, using, or selling its contributor version,
 but do not include claims that would be infringed only as a
 consequence of further modification of the contributor version.  For
 purposes of this definition, "control" includes the right to grant
 patent sublicenses in a manner consistent with the requirements of
 this License.
 
   Each contributor grants you a non-exclusive, worldwide, royalty-free
 patent license under the contributor's essential patent claims, to
 make, use, sell, offer for sale, import and otherwise run, modify and
 propagate the contents of its contributor version.
 
   In the following three paragraphs, a "patent license" is any express
 agreement or commitment, however denominated, not to enforce a patent
 (such as an express permission to practice a patent or covenant not to
 sue for patent infringement).  To "grant" such a patent license to a
 party means to make such an agreement or commitment not to enforce a
 patent against the party.
 
   If you convey a covered work, knowingly relying on a patent license,
 and the Corresponding Source of the work is not available for anyone
 to copy, free of charge and under the terms of this License, through a
 publicly available network server or other readily accessible means,
 then you must either (1) cause the Corresponding Source to be so
 available, or (2) arrange to deprive yourself of the benefit of the
 patent license for this particular work, or (3) arrange, in a manner
 consistent with the requirements of this License, to extend the patent
 license to downstream recipients.  "Knowingly relying" means you have
 actual knowledge that, but for the patent license, your conveying the
 covered work in a country, or your recipient's use of the covered work
 in a country, would infringe one or more identifiable patents in that
 country that you have reason to believe are valid.
 
   If, pursuant to or in connection with a single transaction or
 arrangement, you convey, or propagate by procuring conveyance of, a
 covered work, and grant a patent license to some of the parties
 receiving the covered work authorizing them to use, propagate, modify
 or convey a specific copy of the covered work, then the patent license
 you grant is automatically extended to all recipients of the covered
 work and works based on it.
 
   A patent license is "discriminatory" if it does not include within
 the scope of its coverage, prohibits the exercise of, or is
 conditioned on the non-exercise of one or more of the rights that are
 specifically granted under this License.  You may not convey a covered
 work if you are a party to an arrangement with a third party that is
 in the business of distributing software, under which you make payment
 to the third party based on the extent of your activity of conveying
 the work, and under which the third party grants, to any of the
 parties who would receive the covered work from you, a discriminatory
 patent license (a) in connection with copies of the covered work
 conveyed by you (or copies made from those copies), or (b) primarily
 for and in connection with specific products or compilations that
 contain the covered work, unless you entered into that arrangement,
 or that patent license was granted, prior to 28 March 2007.
 
   Nothing in this License shall be construed as excluding or limiting
 any implied license or other defenses to infringement that may
 otherwise be available to you under applicable patent law.
 
   12. No Surrender of Others' Freedom.
 
   If conditions are imposed on you (whether by court order, agreement or
 otherwise) that contradict the conditions of this License, they do not
 excuse you from the conditions of this License.  If you cannot convey a
 covered work so as to satisfy simultaneously your obligations under this
 License and any other pertinent obligations, then as a consequence you may
 not convey it at all.  For example, if you agree to terms that obligate you
 to collect a royalty for further conveying from those to whom you convey
 the Program, the only way you could satisfy both those terms and this
 License would be to refrain entirely from conveying the Program.
 
   13. Remote Network Interaction; Use with the GNU General Public License.
 
   Notwithstanding any other provision of this License, if you modify the
 Program, your modified version must prominently offer all users
 interacting with it remotely through a computer network (if your version
 supports such interaction) an opportunity to receive the Corresponding
 Source of your version by providing access to the Corresponding Source
 from a network server at no charge, through some standard or customary
 means of facilitating copying of software.  This Corresponding Source
 shall include the Corresponding Source for any work covered by version 3
 of the GNU General Public License that is incorporated pursuant to the
 following paragraph.
 
   Notwithstanding any other provision of this License, you have
 permission to link or combine any covered work with a work licensed
 under version 3 of the GNU General Public License into a single
 combined work, and to convey the resulting work.  The terms of this
 License will continue to apply to the part which is the covered work,
 but the work with which it is combined will remain governed by version
 3 of the GNU General Public License.
 
   14. Revised Versions of this License.
 
   The Free Software Foundation may publish revised and/or new versions of
 the GNU Affero General Public License from time to time.  Such new versions
 will be similar in spirit to the present version, but may differ in detail to
 address new problems or concerns.
 
   Each version is given a distinguishing version number.  If the
 Program specifies that a certain numbered version of the GNU Affero General
 Public License "or any later version" applies to it, you have the
 option of following the terms and conditions either of that numbered
 version or of any later version published by the Free Software
 Foundation.  If the Program does not specify a version number of the
 GNU Affero General Public License, you may choose any version ever published
 by the Free Software Foundation.
 
   If the Program specifies that a proxy can decide which future
 versions of the GNU Affero General Public License can be used, that proxy's
 public statement of acceptance of a version permanently authorizes you
 to choose that version for the Program.
 
   Later license versions may give you additional or different
 permissions.  However, no additional obligations are imposed on any
 author or copyright holder as a result of your choosing to follow a
 later version.
 
   15. Disclaimer of Warranty.
 
   THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
 APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
 HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
 OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
 THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
 IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
 ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
 
   16. Limitation of Liability.
 
   IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
 WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
 THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
 GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
 USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
 DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
 PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
 EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
 SUCH DAMAGES.
 
   17. Interpretation of Sections 15 and 16.
 
   If the disclaimer of warranty and limitation of liability provided
 above cannot be given local legal effect according to their terms,
 reviewing courts shall apply local law that most closely approximates
 an absolute waiver of all civil liability in connection with the
 Program, unless a warranty or assumption of liability accompanies a
 copy of the Program in return for a fee.
 
                      END OF TERMS AND CONDITIONS
 
             How to Apply These Terms to Your New Programs
 
   If you develop a new program, and you want it to be of the greatest
 possible use to the public, the best way to achieve this is to make it
 free software which everyone can redistribute and change under these terms.
 
   To do so, attach the following notices to the program.  It is safest
 to attach them to the start of each source file to most effectively
 state the exclusion of warranty; and each file should have at least
 the "copyright" line and a pointer to where the full notice is found.
 
     <one line to give the program's name and a brief idea of what it does.>
     Copyright (C) <year>  <name of author>
 
     This program is free software: you can redistribute it and/or modify
     it under the terms of the GNU Affero General Public License as published by
     the Free Software Foundation, either version 3 of the License, or
     (at your option) any later version.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU Affero General Public License for more details.
 
     You should have received a copy of the GNU Affero General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 Also add information on how to contact you by electronic and paper mail.
 
   If your software can interact with users remotely through a computer
 network, you should also make sure that it provides a way for users to
 get its source.  For example, if your program is a web application, its
 interface could display a "Source" link that leads users to an archive
 of the code.  There are many ways you could offer source, and different
 solutions will be better for different programs; see section 13 for the
 specific requirements.
 
   You should also get your employer (if you work as a programmer) or school,
 if any, to sign a "copyright disclaimer" for the program, if necessary.
 For more information on this, and how to apply and follow the GNU AGPL, see
 <http://www.gnu.org/licenses/>.

MANIFEST.in

@@ -1,48 +1,48 b''
 # top level files
 include test.ini
 include MANIFEST.in
 include README.rst
+include CHANGES.rst
+include LICENSE.txt
+
 include rhodecode/VERSION
 
 # docs
 recursive-include docs *
 
-# init.d
-recursive-include init.d *
+# all config files
+recursive-include configs *
 
 # translations
 recursive-include rhodecode/i18n *
 
-# bin stuff
-recursive-include rhodecode/bin *
-
 # hook templates
 recursive-include rhodecode/config/hook_templates *
 
 # non-python core stuff
 recursive-include rhodecode *.cfg
 recursive-include rhodecode *.json
 recursive-include rhodecode *.ini_tmpl
 recursive-include rhodecode *.sh
 
 # images, css
 include rhodecode/public/css/*.css
 include rhodecode/public/images/*.*
 
 # sound files
 include rhodecode/public/sounds/*.mp3
 include rhodecode/public/sounds/*.wav
 
 # fonts
 recursive-include rhodecode/public/fonts/ProximaNova *
 recursive-include rhodecode/public/fonts/RCIcons *
 
 # js
 recursive-include rhodecode/public/js *
 
 # templates
 recursive-include rhodecode/templates *
 
 # skip any tests files
 recursive-exclude rhodecode/tests *
 

Makefile

@@ -1,47 +1,47 b''
 
 WEBPACK=./node_modules/webpack/bin/webpack.js
 GRUNT=grunt
 NODE_PATH=./node_modules
 FLAKE8=flake8 setup.py pytest_pylons/ rhodecode/ --select=E124 --ignore=E711,E712,E510,E121,E122,E126,E127,E128,E501,F401 --max-line-length=100 --exclude=*rhodecode/lib/dbmigrate/*,*rhodecode/tests/*,*rhodecode/lib/vcs/utils/*
 CI_PREFIX=enterprise
 
 .PHONY: docs docs-clean ci-docs clean test test-clean test-lint test-only
 
 
 docs:
 	(cd docs; nix-build default.nix -o result; make clean html)
 
 docs-clean:
 	(cd docs; make clean)
 
 ci-docs: docs;
 
 
 clean: test-clean
 	find . -type f \( -iname '*.c' -o -iname '*.pyc' -o -iname '*.so' \) -exec rm '{}' ';'
 
-test: test-clean test-lint test-only
+test: test-clean test-only
 
 test-clean:
 	rm -rf coverage.xml htmlcov junit.xml pylint.log result
 
 test-lint:
 	if [ "$$IN_NIX_SHELL" = "1" ]; then \
 		$(FLAKE8); \
 	else \
 		$(FLAKE8) --format=pylint --exit-zero > pylint.log; \
 	fi
 
 test-only:
 	PYTHONHASHSEED=random py.test -vv -r xw --cov=rhodecode --cov-report=term-missing --cov-report=html rhodecode/tests/
 
 web-build:
 	NODE_PATH=$(NODE_PATH) $(GRUNT)
 
 web-test:
 	@echo "no test for our javascript, yet!"
 
 docs-bootstrap:
 	(cd docs; nix-build default.nix -o result)
 	@echo "Please go to docs folder and run make html"
 

configs/development.ini

@@ -1,612 +1,672 b''
-################################################################################
+
+
 ################################################################################
-# RhodeCode Enterprise - configuration file                                    #
-# Built-in functions and variables                                             #
+##                    RHODECODE ENTERPRISE CONFIGURATION                      ##
 # The %(here)s variable will be replaced with the parent directory of this file#
-#                                                                              #
 ################################################################################
 
 [DEFAULT]
 debug = true
+
 ################################################################################
+##                            EMAIL CONFIGURATION                             ##
 ## Uncomment and replace with the email address which should receive          ##
 ## any error reports after an application crash                               ##
 ## Additionally these settings will be used by the RhodeCode mailing system   ##
 ################################################################################
-#email_to = admin@localhost
-#error_email_from = paste_error@localhost
+
+## prefix all emails subjects with given prefix, helps filtering out emails
+#email_prefix = [RhodeCode]
+
+## email FROM address all mails will be sent
 #app_email_from = rhodecode-noreply@localhost
+
+## Uncomment and replace with the address which should receive any error report
+## note: using appenlight for error handling doesn't need this to be uncommented
+#email_to = admin@localhost
+
+## in case of Application errors, sent an error email form
+#error_email_from = rhodecode_error@localhost
+
+## additional error message to be send in case of server crash
 #error_message =
-#email_prefix = [RhodeCode]
+
 
 #smtp_server = mail.server.com
 #smtp_username =
 #smtp_password =
 #smtp_port =
 #smtp_use_tls = false
 #smtp_use_ssl = true
 ## Specify available auth parameters here (e.g. LOGIN PLAIN CRAM-MD5, etc.)
 #smtp_auth =
 
 [server:main]
 ## COMMON ##
 host = 127.0.0.1
 port = 5000
 
 ##################################
 ##     WAITRESS WSGI SERVER     ##
 ## Recommended for Development  ##
 ##################################
+
 use = egg:waitress#main
 ## number of worker threads
 threads = 5
 ## MAX BODY SIZE 100GB
 max_request_body_size = 107374182400
 ## Use poll instead of select, fixes file descriptors limits problems.
 ## May not work on old windows systems.
 asyncore_use_poll = true
 
 
 ##########################
 ## GUNICORN WSGI SERVER ##
 ##########################
 ## run with gunicorn --log-config <inifile.ini> --paste <inifile.ini>
+
 #use = egg:gunicorn#main
 ## Sets the number of process workers. You must set `instance_id = *`
 ## when this option is set to more than one worker, recommended
 ## value is (2 * NUMBER_OF_CPUS + 1), eg 2CPU = 5 workers
 ## The `instance_id = *` must be set in the [app:main] section below
 #workers = 2
 ## number of threads for each of the worker, must be set to 1 for gevent
 ## generally recommened to be at 1
 #threads = 1
 ## process name
 #proc_name = rhodecode
 ## type of worker class, one of sync, gevent
 ## recommended for bigger setup is using of of other than sync one
 #worker_class = sync
 ## The maximum number of simultaneous clients. Valid only for Gevent
 #worker_connections = 10
 ## max number of requests that worker will handle before being gracefully
 ## restarted, could prevent memory leaks
 #max_requests = 1000
 #max_requests_jitter = 30
 ## amount of time a worker can spend with handling a request before it
 ## gets killed and restarted. Set to 6hrs
 #timeout = 21600
 
 
 ## prefix middleware for RhodeCode, disables force_https flag.
+## recommended when using proxy setup.
 ## allows to set RhodeCode under a prefix in server.
 ## eg https://server.com/<prefix>. Enable `filter-with =` option below as well.
-#[filter:proxy-prefix]
-#use = egg:PasteDeploy#prefix
-#prefix = /<your-prefix>
+## optionally set prefix like: `prefix = /<your-prefix>`
+[filter:proxy-prefix]
+use = egg:PasteDeploy#prefix
+prefix = /
 
 [app:main]
 use = egg:rhodecode-enterprise-ce
-## enable proxy prefix middleware, defined below
+
+## enable proxy prefix middleware, defined above
 #filter-with = proxy-prefix
 
 # During development the we want to have the debug toolbar enabled
 pyramid.includes =
     pyramid_debugtoolbar
     rhodecode.utils.debugtoolbar
     rhodecode.lib.middleware.request_wrapper
 
 pyramid.reload_templates = true
 
 debugtoolbar.hosts = 0.0.0.0/0
 debugtoolbar.exclude_prefixes =
     /css
     /fonts
     /images
     /js
 
 ## RHODECODE PLUGINS ##
 rhodecode.includes =
     rhodecode.api
 
 
 # api prefix url
 rhodecode.api.url = /_admin/api
 
 
 ## END RHODECODE PLUGINS ##
 
 ## encryption key used to encrypt social plugin tokens,
 ## remote_urls with credentials etc, if not set it defaults to
 ## `beaker.session.secret`
 #rhodecode.encrypted_values.secret =
 
 ## decryption strict mode (enabled by default). It controls if decryption raises
 ## `SignatureVerificationError` in case of wrong key, or damaged encryption data.
 #rhodecode.encrypted_values.strict = false
 
-full_stack = true
+## return gzipped responses from Rhodecode (static files/application)
+gzip_responses = false
 
-## Serve static files via RhodeCode, disable to serve them via HTTP server
-static_files = true
-
-# autogenerate javascript routes file on startup
+## autogenerate javascript routes file on startup
 generate_js_files = false
 
 ## Optional Languages
 ## en(default), be, de, es, fr, it, ja, pl, pt, ru, zh
 lang = en
 
 ## perform a full repository scan on each server start, this should be
 ## set to false after first startup, to allow faster server restarts.
 startup.import_repos = false
 
 ## Uncomment and set this path to use archive download cache.
 ## Once enabled, generated archives will be cached at this location
 ## and served from the cache during subsequent requests for the same archive of
 ## the repository.
 #archive_cache_dir = /tmp/tarballcache
 
 ## change this to unique ID for security
 app_instance_uuid = rc-production
 
 ## cut off limit for large diffs (size in bytes)
 cut_off_limit_diff = 1024000
 cut_off_limit_file = 256000
 
 ## use cache version of scm repo everywhere
 vcs_full_cache = true
 
 ## force https in RhodeCode, fixes https redirects, assumes it's always https
 ## Normally this is controlled by proper http flags sent from http server
 force_https = false
 
 ## use Strict-Transport-Security headers
 use_htsts = false
 
 ## number of commits stats will parse on each iteration
 commit_parse_limit = 25
 
 ## git rev filter option, --all is the default filter, if you need to
 ## hide all refs in changelog switch this to --branches --tags
 git_rev_filter = --branches --tags
 
 # Set to true if your repos are exposed using the dumb protocol
 git_update_server_info = false
 
 ## RSS/ATOM feed options
 rss_cut_off_limit = 256000
 rss_items_per_page = 10
 rss_include_diff = false
 
 ## gist URL alias, used to create nicer urls for gist. This should be an
 ## url that does rewrites to _admin/gists/<gistid>.
 ## example: http://gist.rhodecode.org/{gistid}. Empty means use the internal
 ## RhodeCode url, ie. http[s]://rhodecode.server/_admin/gists/<gistid>
 gist_alias_url =
 
 ## List of controllers (using glob pattern syntax) that AUTH TOKENS could be
 ## used for access.
 ## Adding ?auth_token = <token> to the url authenticates this request as if it
 ## came from the the logged in user who own this authentication token.
 ##
 ## Syntax is <ControllerClass>:<function_pattern>.
 ## To enable access to raw_files put `FilesController:raw`.
 ## To enable access to patches add `ChangesetController:changeset_patch`.
 ## The list should be "," separated and on a single line.
 ##
 ## Recommended controllers to enable:
 #    ChangesetController:changeset_patch,
 #    ChangesetController:changeset_raw,
 #    FilesController:raw,
 #    FilesController:archivefile,
 #    GistsController:*,
 api_access_controllers_whitelist =
 
 ## default encoding used to convert from and to unicode
 ## can be also a comma separated list of encoding in case of mixed encodings
 default_encoding = UTF-8
 
 ## instance-id prefix
 ## a prefix key for this instance used for cache invalidation when running
 ## multiple instances of rhodecode, make sure it's globally unique for
 ## all running rhodecode instances. Leave empty if you don't use it
 instance_id =
 
 ## Fallback authentication plugin. Set this to a plugin ID to force the usage
 ## of an authentication plugin also if it is disabled by it's settings.
 ## This could be useful if you are unable to log in to the system due to broken
 ## authentication settings. Then you can enable e.g. the internal rhodecode auth
 ## module to log in again and fix the settings.
 ##
 ## Available builtin plugin IDs (hash is part of the ID):
 ## egg:rhodecode-enterprise-ce#rhodecode
 ## egg:rhodecode-enterprise-ce#pam
 ## egg:rhodecode-enterprise-ce#ldap
 ## egg:rhodecode-enterprise-ce#jasig_cas
 ## egg:rhodecode-enterprise-ce#headers
 ## egg:rhodecode-enterprise-ce#crowd
 #rhodecode.auth_plugin_fallback = egg:rhodecode-enterprise-ce#rhodecode
 
 ## alternative return HTTP header for failed authentication. Default HTTP
 ## response is 401 HTTPUnauthorized. Currently HG clients have troubles with
 ## handling that causing a series of failed authentication calls.
 ## Set this variable to 403 to return HTTPForbidden, or any other HTTP code
 ## This will be served instead of default 401 on bad authnetication
 auth_ret_code =
 
 ## use special detection method when serving auth_ret_code, instead of serving
 ## ret_code directly, use 401 initially (Which triggers credentials prompt)
 ## and then serve auth_ret_code to clients
 auth_ret_code_detection = false
 
 ## locking return code. When repository is locked return this HTTP code. 2XX
 ## codes don't break the transactions while 4XX codes do
 lock_ret_code = 423
 
 ## allows to change the repository location in settings page
 allow_repo_location_change = true
 
 ## allows to setup custom hooks in settings page
 allow_custom_hooks_settings = true
 
 ## generated license token, goto license page in RhodeCode settings to obtain
 ## new token
 license_token =
 
 ## supervisor connection uri, for managing supervisor and logs.
 supervisor.uri =
 ## supervisord group name/id we only want this RC instance to handle
 supervisor.group_id = dev
 
 ## Display extended labs settings
 labs_settings_active = true
 
 ####################################
 ###        CELERY CONFIG        ####
 ####################################
 use_celery = false
 broker.host = localhost
 broker.vhost = rabbitmqhost
 broker.port = 5672
 broker.user = rabbitmq
 broker.password = qweqwe
 
 celery.imports = rhodecode.lib.celerylib.tasks
 
 celery.result.backend = amqp
 celery.result.dburi = amqp://
 celery.result.serialier = json
 
 #celery.send.task.error.emails = true
 #celery.amqp.task.result.expires = 18000
 
 celeryd.concurrency = 2
 #celeryd.log.file = celeryd.log
 celeryd.log.level = debug
 celeryd.max.tasks.per.child = 1
 
 ## tasks will never be sent to the queue, but executed locally instead.
 celery.always.eager = false
 
 ####################################
 ###         BEAKER CACHE        ####
 ####################################
 # default cache dir for templates.  Putting this into a ramdisk
 ## can boost performance, eg. %(here)s/data_ramdisk
 cache_dir = %(here)s/data
 
 ## locking and default file storage for Beaker. Putting this into a ramdisk
 ## can boost performance, eg. %(here)s/data_ramdisk/cache/beaker_data
 beaker.cache.data_dir = %(here)s/data/cache/beaker_data
 beaker.cache.lock_dir = %(here)s/data/cache/beaker_lock
 
 beaker.cache.regions = super_short_term, short_term, long_term, sql_cache_short, auth_plugins, repo_cache_long
 
 beaker.cache.super_short_term.type = memory
 beaker.cache.super_short_term.expire = 10
 beaker.cache.super_short_term.key_length = 256
 
 beaker.cache.short_term.type = memory
 beaker.cache.short_term.expire = 60
 beaker.cache.short_term.key_length = 256
 
 beaker.cache.long_term.type = memory
 beaker.cache.long_term.expire = 36000
 beaker.cache.long_term.key_length = 256
 
 beaker.cache.sql_cache_short.type = memory
 beaker.cache.sql_cache_short.expire = 10
 beaker.cache.sql_cache_short.key_length = 256
 
-# default is memory cache, configure only if required
-# using multi-node or multi-worker setup
+## default is memory cache, configure only if required
+## using multi-node or multi-worker setup
 #beaker.cache.auth_plugins.type = ext:database
 #beaker.cache.auth_plugins.lock_dir = %(here)s/data/cache/auth_plugin_lock
 #beaker.cache.auth_plugins.url = postgresql://postgres:secret@localhost/rhodecode
 #beaker.cache.auth_plugins.url = mysql://root:secret@127.0.0.1/rhodecode
 #beaker.cache.auth_plugins.sa.pool_recycle = 3600
 #beaker.cache.auth_plugins.sa.pool_size = 10
 #beaker.cache.auth_plugins.sa.max_overflow = 0
 
 beaker.cache.repo_cache_long.type = memorylru_base
 beaker.cache.repo_cache_long.max_items = 4096
 beaker.cache.repo_cache_long.expire = 2592000
 
-# default is memorylru_base cache, configure only if required
-# using multi-node or multi-worker setup
+## default is memorylru_base cache, configure only if required
+## using multi-node or multi-worker setup
 #beaker.cache.repo_cache_long.type = ext:memcached
 #beaker.cache.repo_cache_long.url = localhost:11211
 #beaker.cache.repo_cache_long.expire = 1209600
 #beaker.cache.repo_cache_long.key_length = 256
 
 ####################################
 ###       BEAKER SESSION        ####
 ####################################
 
 ## .session.type is type of storage options for the session, current allowed
 ## types are file, ext:memcached, ext:database, and memory (default).
 beaker.session.type = file
 beaker.session.data_dir = %(here)s/data/sessions/data
 
-## db based session, fast, and allows easy management over logged in users ##
+## db based session, fast, and allows easy management over logged in users
 #beaker.session.type = ext:database
 #beaker.session.table_name = db_session
 #beaker.session.sa.url = postgresql://postgres:secret@localhost/rhodecode
 #beaker.session.sa.url = mysql://root:secret@127.0.0.1/rhodecode
 #beaker.session.sa.pool_recycle = 3600
 #beaker.session.sa.echo = false
 
 beaker.session.key = rhodecode
 beaker.session.secret = develop-rc-uytcxaz
 beaker.session.lock_dir = %(here)s/data/sessions/lock
 
 ## Secure encrypted cookie. Requires AES and AES python libraries
 ## you must disable beaker.session.secret to use this
 #beaker.session.encrypt_key = <key_for_encryption>
 #beaker.session.validate_key = <validation_key>
 
 ## sets session as invalid(also logging out user) if it haven not been
 ## accessed for given amount of time in seconds
 beaker.session.timeout = 2592000
 beaker.session.httponly = true
+## Path to use for the cookie.
 #beaker.session.cookie_path = /<your-prefix>
 
 ## uncomment for https secure cookie
 beaker.session.secure = false
 
 ## auto save the session to not to use .save()
 beaker.session.auto = false
 
 ## default cookie expiration time in seconds, set to `true` to set expire
 ## at browser close
 #beaker.session.cookie_expires = 3600
 
 ###################################
 ## SEARCH INDEXING CONFIGURATION ##
 ###################################
 ## Full text search indexer is available in rhodecode-tools under
 ## `rhodecode-tools index` command
 
 # WHOOSH Backend, doesn't require additional services to run
 # it works good with few dozen repos
 search.module = rhodecode.lib.index.whoosh
 search.location = %(here)s/data/index
 
+########################################
+###    CHANNELSTREAM CONFIG         ####
+########################################
+## channelstream enables persistent connections and live notification
+## in the system. It's also used by the chat system
+
+channelstream.enabled = true
+## location of channelstream server on the backend
+channelstream.server = 127.0.0.1:9800
+## location of the channelstream server from outside world
+## most likely this would be an http server special backend URL, that handles
+## websocket connections see nginx example for config
+channelstream.ws_url = ws://rhodecode.yourserver.com/_channelstream
+channelstream.secret = secret
+channelstream.history.location = %(here)s/channelstream_history
+
+
 ###################################
 ##       APPENLIGHT CONFIG       ##
 ###################################
 
 ## Appenlight is tailored to work with RhodeCode, see
 ## http://appenlight.com for details how to obtain an account
 
 ## appenlight integration enabled
 appenlight = false
 
 appenlight.server_url = https://api.appenlight.com
 appenlight.api_key = YOUR_API_KEY
 #appenlight.transport_config = https://api.appenlight.com?threaded=1&timeout=5
 
 # used for JS client
 appenlight.api_public_key = YOUR_API_PUBLIC_KEY
 
 ## TWEAK AMOUNT OF INFO SENT HERE
 
 ## enables 404 error logging (default False)
 appenlight.report_404 = false
 
 ## time in seconds after request is considered being slow (default 1)
 appenlight.slow_request_time = 1
 
 ## record slow requests in application
 ## (needs to be enabled for slow datastore recording and time tracking)
 appenlight.slow_requests = true
 
 ## enable hooking to application loggers
 appenlight.logging = true
 
 ## minimum log level for log capture
 appenlight.logging.level = WARNING
 
 ## send logs only from erroneous/slow requests
 ## (saves API quota for intensive logging)
 appenlight.logging_on_error = false
 
 ## list of additonal keywords that should be grabbed from environ object
 ## can be string with comma separated list of words in lowercase
 ## (by default client will always send following info:
 ## 'REMOTE_USER', 'REMOTE_ADDR', 'SERVER_NAME', 'CONTENT_TYPE' + all keys that
 ## start with HTTP* this list be extended with additional keywords here
 appenlight.environ_keys_whitelist =
 
 ## list of keywords that should be blanked from request object
 ## can be string with comma separated list of words in lowercase
 ## (by default client will always blank keys that contain following words
 ## 'password', 'passwd', 'pwd', 'auth_tkt', 'secret', 'csrf'
 ## this list be extended with additional keywords set here
 appenlight.request_keys_blacklist =
 
 ## list of namespaces that should be ignores when gathering log entries
 ## can be string with comma separated list of namespaces
 ## (by default the client ignores own entries: appenlight_client.client)
 appenlight.log_namespace_blacklist =
 
 
 ################################################################################
 ## WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT*  ##
 ## Debug mode will enable the interactive debugging tool, allowing ANYONE to  ##
 ## execute malicious code after an exception is raised.                       ##
 ################################################################################
 #set debug = false
 
 
 ##############
 ## STYLING  ##
 ##############
 debug_style = true
 
 #########################################################
 ### DB CONFIGS - EACH DB WILL HAVE IT'S OWN CONFIG    ###
 #########################################################
-sqlalchemy.db1.url = sqlite:///%(here)s/rhodecode.db?timeout=30
+#sqlalchemy.db1.url = sqlite:///%(here)s/rhodecode.db?timeout=30
 #sqlalchemy.db1.url = postgresql://postgres:qweqwe@localhost/rhodecode
 #sqlalchemy.db1.url = mysql://root:qweqwe@localhost/rhodecode
+sqlalchemy.db1.url = sqlite:///%(here)s/rhodecode.db?timeout=30
 
 # see sqlalchemy docs for other advanced settings
 
 ## print the sql statements to output
 sqlalchemy.db1.echo = false
 ## recycle the connections after this ammount of seconds
 sqlalchemy.db1.pool_recycle = 3600
 sqlalchemy.db1.convert_unicode = true
 
 ## the number of connections to keep open inside the connection pool.
 ## 0 indicates no limit
 #sqlalchemy.db1.pool_size = 5
 
 ## the number of connections to allow in connection pool "overflow", that is
 ## connections that can be opened above and beyond the pool_size setting,
 ## which defaults to five.
 #sqlalchemy.db1.max_overflow = 10
 
 
 ##################
 ### VCS CONFIG ###
 ##################
 vcs.server.enable = true
 vcs.server = localhost:9900
 
 ## Web server connectivity protocol, responsible for web based VCS operatations
 ## Available protocols are:
 ## `pyro4` - using pyro4 server
 ## `http` - using http-rpc backend
-#vcs.server.protocol = http
+vcs.server.protocol = http
 
 ## Push/Pull operations protocol, available options are:
 ## `pyro4` - using pyro4 server
 ## `rhodecode.lib.middleware.utils.scm_app_http` - Http based, recommended
 ## `vcsserver.scm_app` - internal app (EE only)
-#vcs.scm_app_implementation = rhodecode.lib.middleware.utils.scm_app_http
+vcs.scm_app_implementation = rhodecode.lib.middleware.utils.scm_app_http
 
 ## Push/Pull operations hooks protocol, available options are:
 ## `pyro4` - using pyro4 server
 ## `http` - using http-rpc backend
-#vcs.hooks.protocol = http
+vcs.hooks.protocol = http
 
 vcs.server.log_level = debug
 ## Start VCSServer with this instance as a subprocess, usefull for development
 vcs.start_server = true
+
+## List of enabled VCS backends, available options are:
+## `hg`  - mercurial
+## `git` - git
+## `svn` - subversion
 vcs.backends = hg, git, svn
+
 vcs.connection_timeout = 3600
 ## Compatibility version when creating SVN repositories. Defaults to newest version when commented out.
 ## Available options are: pre-1.4-compatible, pre-1.5-compatible, pre-1.6-compatible, pre-1.8-compatible
 #vcs.svn.compatible_version = pre-1.8-compatible
 
+
+############################################################
+### Subversion proxy support (mod_dav_svn)               ###
+### Maps RhodeCode repo groups into SVN paths for Apache ###
+############################################################
+## Enable or disable the config file generation.
+svn.proxy.generate_config = false
+## Generate config file with `SVNListParentPath` set to `On`.
+svn.proxy.list_parent_path = true
+## Set location and file name of generated config file.
+svn.proxy.config_file_path = %(here)s/mod_dav_svn.conf
+## File system path to the directory containing the repositories served by
+## RhodeCode.
+svn.proxy.parent_path_root = /path/to/repo_store
+## Used as a prefix to the <Location> block in the generated config file. In
+## most cases it should be set to `/`.
+svn.proxy.location_root = /
+
+
 ################################
 ### LOGGING CONFIGURATION   ####
 ################################
 [loggers]
 keys = root, routes, rhodecode, sqlalchemy, beaker, pyro4, templates
 
 [handlers]
 keys = console, console_sql
 
 [formatters]
 keys = generic, color_formatter, color_formatter_sql
 
 #############
 ## LOGGERS ##
 #############
 [logger_root]
 level = NOTSET
 handlers = console
 
 [logger_routes]
 level = DEBUG
 handlers =
 qualname = routes.middleware
 ## "level = DEBUG" logs the route matched and routing variables.
 propagate = 1
 
 [logger_beaker]
 level = DEBUG
 handlers =
 qualname = beaker.container
 propagate = 1
 
 [logger_pyro4]
 level = DEBUG
 handlers =
 qualname = Pyro4
 propagate = 1
 
 [logger_templates]
 level = INFO
 handlers =
 qualname = pylons.templating
 propagate = 1
 
 [logger_rhodecode]
 level = DEBUG
 handlers =
 qualname = rhodecode
 propagate = 1
 
 [logger_sqlalchemy]
 level = INFO
 handlers = console_sql
 qualname = sqlalchemy.engine
 propagate = 0
 
 ##############
 ## HANDLERS ##
 ##############
 
 [handler_console]
 class = StreamHandler
 args = (sys.stderr,)
 level = DEBUG
 formatter = color_formatter
 
 [handler_console_sql]
 class = StreamHandler
 args = (sys.stderr,)
 level = DEBUG
 formatter = color_formatter_sql
 
 ################
 ## FORMATTERS ##
 ################
 
 [formatter_generic]
 class = rhodecode.lib.logging_formatter.Pyro4AwareFormatter
 format = %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
 datefmt = %Y-%m-%d %H:%M:%S
 
 [formatter_color_formatter]
 class = rhodecode.lib.logging_formatter.ColorFormatter
 format = %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
 datefmt = %Y-%m-%d %H:%M:%S
 
 [formatter_color_formatter_sql]
 class = rhodecode.lib.logging_formatter.ColorFormatterSql
 format = %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
 datefmt = %Y-%m-%d %H:%M:%S

configs/production.ini

@@ -1,581 +1,641 b''
-################################################################################
+
+
 ################################################################################
-# RhodeCode Enterprise - configuration file                                    #
-# Built-in functions and variables                                             #
+##                    RHODECODE ENTERPRISE CONFIGURATION                      ##
 # The %(here)s variable will be replaced with the parent directory of this file#
-#                                                                              #
 ################################################################################
 
 [DEFAULT]
 debug = true
+
 ################################################################################
+##                            EMAIL CONFIGURATION                             ##
 ## Uncomment and replace with the email address which should receive          ##
 ## any error reports after an application crash                               ##
 ## Additionally these settings will be used by the RhodeCode mailing system   ##
 ################################################################################
-#email_to = admin@localhost
-#error_email_from = paste_error@localhost
+
+## prefix all emails subjects with given prefix, helps filtering out emails
+#email_prefix = [RhodeCode]
+
+## email FROM address all mails will be sent
 #app_email_from = rhodecode-noreply@localhost
+
+## Uncomment and replace with the address which should receive any error report
+## note: using appenlight for error handling doesn't need this to be uncommented
+#email_to = admin@localhost
+
+## in case of Application errors, sent an error email form
+#error_email_from = rhodecode_error@localhost
+
+## additional error message to be send in case of server crash
 #error_message =
-#email_prefix = [RhodeCode]
+
 
 #smtp_server = mail.server.com
 #smtp_username =
 #smtp_password =
 #smtp_port =
 #smtp_use_tls = false
 #smtp_use_ssl = true
 ## Specify available auth parameters here (e.g. LOGIN PLAIN CRAM-MD5, etc.)
 #smtp_auth =
 
 [server:main]
 ## COMMON ##
 host = 127.0.0.1
 port = 5000
 
 ##################################
 ##     WAITRESS WSGI SERVER     ##
 ## Recommended for Development  ##
 ##################################
+
 #use = egg:waitress#main
 ## number of worker threads
 #threads = 5
 ## MAX BODY SIZE 100GB
 #max_request_body_size = 107374182400
 ## Use poll instead of select, fixes file descriptors limits problems.
 ## May not work on old windows systems.
 #asyncore_use_poll = true
 
 
 ##########################
 ## GUNICORN WSGI SERVER ##
 ##########################
 ## run with gunicorn --log-config <inifile.ini> --paste <inifile.ini>
+
 use = egg:gunicorn#main
 ## Sets the number of process workers. You must set `instance_id = *`
 ## when this option is set to more than one worker, recommended
 ## value is (2 * NUMBER_OF_CPUS + 1), eg 2CPU = 5 workers
 ## The `instance_id = *` must be set in the [app:main] section below
 workers = 2
 ## number of threads for each of the worker, must be set to 1 for gevent
 ## generally recommened to be at 1
 #threads = 1
 ## process name
 proc_name = rhodecode
 ## type of worker class, one of sync, gevent
 ## recommended for bigger setup is using of of other than sync one
 worker_class = sync
 ## The maximum number of simultaneous clients. Valid only for Gevent
 #worker_connections = 10
 ## max number of requests that worker will handle before being gracefully
 ## restarted, could prevent memory leaks
 max_requests = 1000
 max_requests_jitter = 30
 ## amount of time a worker can spend with handling a request before it
 ## gets killed and restarted. Set to 6hrs
 timeout = 21600
 
 
 ## prefix middleware for RhodeCode, disables force_https flag.
+## recommended when using proxy setup.
 ## allows to set RhodeCode under a prefix in server.
 ## eg https://server.com/<prefix>. Enable `filter-with =` option below as well.
-#[filter:proxy-prefix]
-#use = egg:PasteDeploy#prefix
-#prefix = /<your-prefix>
+## optionally set prefix like: `prefix = /<your-prefix>`
+[filter:proxy-prefix]
+use = egg:PasteDeploy#prefix
+prefix = /
 
 [app:main]
 use = egg:rhodecode-enterprise-ce
-## enable proxy prefix middleware, defined below
+
+## enable proxy prefix middleware, defined above
 #filter-with = proxy-prefix
 
 ## encryption key used to encrypt social plugin tokens,
 ## remote_urls with credentials etc, if not set it defaults to
 ## `beaker.session.secret`
 #rhodecode.encrypted_values.secret =
 
 ## decryption strict mode (enabled by default). It controls if decryption raises
 ## `SignatureVerificationError` in case of wrong key, or damaged encryption data.
 #rhodecode.encrypted_values.strict = false
 
-full_stack = true
+## return gzipped responses from Rhodecode (static files/application)
+gzip_responses = false
 
-## Serve static files via RhodeCode, disable to serve them via HTTP server
-static_files = true
-
-# autogenerate javascript routes file on startup
+## autogenerate javascript routes file on startup
 generate_js_files = false
 
 ## Optional Languages
 ## en(default), be, de, es, fr, it, ja, pl, pt, ru, zh
 lang = en
 
 ## perform a full repository scan on each server start, this should be
 ## set to false after first startup, to allow faster server restarts.
 startup.import_repos = false
 
 ## Uncomment and set this path to use archive download cache.
 ## Once enabled, generated archives will be cached at this location
 ## and served from the cache during subsequent requests for the same archive of
 ## the repository.
 #archive_cache_dir = /tmp/tarballcache
 
 ## change this to unique ID for security
 app_instance_uuid = rc-production
 
 ## cut off limit for large diffs (size in bytes)
 cut_off_limit_diff = 1024000
 cut_off_limit_file = 256000
 
 ## use cache version of scm repo everywhere
 vcs_full_cache = true
 
 ## force https in RhodeCode, fixes https redirects, assumes it's always https
 ## Normally this is controlled by proper http flags sent from http server
 force_https = false
 
 ## use Strict-Transport-Security headers
 use_htsts = false
 
 ## number of commits stats will parse on each iteration
 commit_parse_limit = 25
 
 ## git rev filter option, --all is the default filter, if you need to
 ## hide all refs in changelog switch this to --branches --tags
 git_rev_filter = --branches --tags
 
 # Set to true if your repos are exposed using the dumb protocol
 git_update_server_info = false
 
 ## RSS/ATOM feed options
 rss_cut_off_limit = 256000
 rss_items_per_page = 10
 rss_include_diff = false
 
 ## gist URL alias, used to create nicer urls for gist. This should be an
 ## url that does rewrites to _admin/gists/<gistid>.
 ## example: http://gist.rhodecode.org/{gistid}. Empty means use the internal
 ## RhodeCode url, ie. http[s]://rhodecode.server/_admin/gists/<gistid>
 gist_alias_url =
 
 ## List of controllers (using glob pattern syntax) that AUTH TOKENS could be
 ## used for access.
 ## Adding ?auth_token = <token> to the url authenticates this request as if it
 ## came from the the logged in user who own this authentication token.
 ##
 ## Syntax is <ControllerClass>:<function_pattern>.
 ## To enable access to raw_files put `FilesController:raw`.
 ## To enable access to patches add `ChangesetController:changeset_patch`.
 ## The list should be "," separated and on a single line.
 ##
 ## Recommended controllers to enable:
 #    ChangesetController:changeset_patch,
 #    ChangesetController:changeset_raw,
 #    FilesController:raw,
 #    FilesController:archivefile,
 #    GistsController:*,
 api_access_controllers_whitelist =
 
 ## default encoding used to convert from and to unicode
 ## can be also a comma separated list of encoding in case of mixed encodings
 default_encoding = UTF-8
 
 ## instance-id prefix
 ## a prefix key for this instance used for cache invalidation when running
 ## multiple instances of rhodecode, make sure it's globally unique for
 ## all running rhodecode instances. Leave empty if you don't use it
 instance_id =
 
 ## Fallback authentication plugin. Set this to a plugin ID to force the usage
 ## of an authentication plugin also if it is disabled by it's settings.
 ## This could be useful if you are unable to log in to the system due to broken
 ## authentication settings. Then you can enable e.g. the internal rhodecode auth
 ## module to log in again and fix the settings.
 ##
 ## Available builtin plugin IDs (hash is part of the ID):
 ## egg:rhodecode-enterprise-ce#rhodecode
 ## egg:rhodecode-enterprise-ce#pam
 ## egg:rhodecode-enterprise-ce#ldap
 ## egg:rhodecode-enterprise-ce#jasig_cas
 ## egg:rhodecode-enterprise-ce#headers
 ## egg:rhodecode-enterprise-ce#crowd
 #rhodecode.auth_plugin_fallback = egg:rhodecode-enterprise-ce#rhodecode
 
 ## alternative return HTTP header for failed authentication. Default HTTP
 ## response is 401 HTTPUnauthorized. Currently HG clients have troubles with
 ## handling that causing a series of failed authentication calls.
 ## Set this variable to 403 to return HTTPForbidden, or any other HTTP code
 ## This will be served instead of default 401 on bad authnetication
 auth_ret_code =
 
 ## use special detection method when serving auth_ret_code, instead of serving
 ## ret_code directly, use 401 initially (Which triggers credentials prompt)
 ## and then serve auth_ret_code to clients
 auth_ret_code_detection = false
 
 ## locking return code. When repository is locked return this HTTP code. 2XX
 ## codes don't break the transactions while 4XX codes do
 lock_ret_code = 423
 
 ## allows to change the repository location in settings page
 allow_repo_location_change = true
 
 ## allows to setup custom hooks in settings page
 allow_custom_hooks_settings = true
 
 ## generated license token, goto license page in RhodeCode settings to obtain
 ## new token
 license_token =
 
 ## supervisor connection uri, for managing supervisor and logs.
 supervisor.uri =
 ## supervisord group name/id we only want this RC instance to handle
 supervisor.group_id = prod
 
 ## Display extended labs settings
 labs_settings_active = true
 
 ####################################
 ###        CELERY CONFIG        ####
 ####################################
 use_celery = false
 broker.host = localhost
 broker.vhost = rabbitmqhost
 broker.port = 5672
 broker.user = rabbitmq
 broker.password = qweqwe
 
 celery.imports = rhodecode.lib.celerylib.tasks
 
 celery.result.backend = amqp
 celery.result.dburi = amqp://
 celery.result.serialier = json
 
 #celery.send.task.error.emails = true
 #celery.amqp.task.result.expires = 18000
 
 celeryd.concurrency = 2
 #celeryd.log.file = celeryd.log
 celeryd.log.level = debug
 celeryd.max.tasks.per.child = 1
 
 ## tasks will never be sent to the queue, but executed locally instead.
 celery.always.eager = false
 
 ####################################
 ###         BEAKER CACHE        ####
 ####################################
 # default cache dir for templates.  Putting this into a ramdisk
 ## can boost performance, eg. %(here)s/data_ramdisk
 cache_dir = %(here)s/data
 
 ## locking and default file storage for Beaker. Putting this into a ramdisk
 ## can boost performance, eg. %(here)s/data_ramdisk/cache/beaker_data
 beaker.cache.data_dir = %(here)s/data/cache/beaker_data
 beaker.cache.lock_dir = %(here)s/data/cache/beaker_lock
 
 beaker.cache.regions = super_short_term, short_term, long_term, sql_cache_short, auth_plugins, repo_cache_long
 
 beaker.cache.super_short_term.type = memory
 beaker.cache.super_short_term.expire = 10
 beaker.cache.super_short_term.key_length = 256
 
 beaker.cache.short_term.type = memory
 beaker.cache.short_term.expire = 60
 beaker.cache.short_term.key_length = 256
 
 beaker.cache.long_term.type = memory
 beaker.cache.long_term.expire = 36000
 beaker.cache.long_term.key_length = 256
 
 beaker.cache.sql_cache_short.type = memory
 beaker.cache.sql_cache_short.expire = 10
 beaker.cache.sql_cache_short.key_length = 256
 
-# default is memory cache, configure only if required
-# using multi-node or multi-worker setup
+## default is memory cache, configure only if required
+## using multi-node or multi-worker setup
 #beaker.cache.auth_plugins.type = ext:database
 #beaker.cache.auth_plugins.lock_dir = %(here)s/data/cache/auth_plugin_lock
 #beaker.cache.auth_plugins.url = postgresql://postgres:secret@localhost/rhodecode
 #beaker.cache.auth_plugins.url = mysql://root:secret@127.0.0.1/rhodecode
 #beaker.cache.auth_plugins.sa.pool_recycle = 3600
 #beaker.cache.auth_plugins.sa.pool_size = 10
 #beaker.cache.auth_plugins.sa.max_overflow = 0
 
 beaker.cache.repo_cache_long.type = memorylru_base
 beaker.cache.repo_cache_long.max_items = 4096
 beaker.cache.repo_cache_long.expire = 2592000
 
-# default is memorylru_base cache, configure only if required
-# using multi-node or multi-worker setup
+## default is memorylru_base cache, configure only if required
+## using multi-node or multi-worker setup
 #beaker.cache.repo_cache_long.type = ext:memcached
 #beaker.cache.repo_cache_long.url = localhost:11211
 #beaker.cache.repo_cache_long.expire = 1209600
 #beaker.cache.repo_cache_long.key_length = 256
 
 ####################################
 ###       BEAKER SESSION        ####
 ####################################
 
 ## .session.type is type of storage options for the session, current allowed
 ## types are file, ext:memcached, ext:database, and memory (default).
 beaker.session.type = file
 beaker.session.data_dir = %(here)s/data/sessions/data
 
-## db based session, fast, and allows easy management over logged in users ##
+## db based session, fast, and allows easy management over logged in users
 #beaker.session.type = ext:database
 #beaker.session.table_name = db_session
 #beaker.session.sa.url = postgresql://postgres:secret@localhost/rhodecode
 #beaker.session.sa.url = mysql://root:secret@127.0.0.1/rhodecode
 #beaker.session.sa.pool_recycle = 3600
 #beaker.session.sa.echo = false
 
 beaker.session.key = rhodecode
 beaker.session.secret = production-rc-uytcxaz
 beaker.session.lock_dir = %(here)s/data/sessions/lock
 
 ## Secure encrypted cookie. Requires AES and AES python libraries
 ## you must disable beaker.session.secret to use this
 #beaker.session.encrypt_key = <key_for_encryption>
 #beaker.session.validate_key = <validation_key>
 
 ## sets session as invalid(also logging out user) if it haven not been
 ## accessed for given amount of time in seconds
 beaker.session.timeout = 2592000
 beaker.session.httponly = true
+## Path to use for the cookie.
 #beaker.session.cookie_path = /<your-prefix>
 
 ## uncomment for https secure cookie
 beaker.session.secure = false
 
 ## auto save the session to not to use .save()
 beaker.session.auto = false
 
 ## default cookie expiration time in seconds, set to `true` to set expire
 ## at browser close
 #beaker.session.cookie_expires = 3600
 
 ###################################
 ## SEARCH INDEXING CONFIGURATION ##
 ###################################
 ## Full text search indexer is available in rhodecode-tools under
 ## `rhodecode-tools index` command
 
 # WHOOSH Backend, doesn't require additional services to run
 # it works good with few dozen repos
 search.module = rhodecode.lib.index.whoosh
 search.location = %(here)s/data/index
 
+########################################
+###    CHANNELSTREAM CONFIG         ####
+########################################
+## channelstream enables persistent connections and live notification
+## in the system. It's also used by the chat system
+
+channelstream.enabled = true
+## location of channelstream server on the backend
+channelstream.server = 127.0.0.1:9800
+## location of the channelstream server from outside world
+## most likely this would be an http server special backend URL, that handles
+## websocket connections see nginx example for config
+channelstream.ws_url = ws://rhodecode.yourserver.com/_channelstream
+channelstream.secret = secret
+channelstream.history.location = %(here)s/channelstream_history
+
+
 ###################################
 ##       APPENLIGHT CONFIG       ##
 ###################################
 
 ## Appenlight is tailored to work with RhodeCode, see
 ## http://appenlight.com for details how to obtain an account
 
 ## appenlight integration enabled
 appenlight = false
 
 appenlight.server_url = https://api.appenlight.com
 appenlight.api_key = YOUR_API_KEY
 #appenlight.transport_config = https://api.appenlight.com?threaded=1&timeout=5
 
 # used for JS client
 appenlight.api_public_key = YOUR_API_PUBLIC_KEY
 
 ## TWEAK AMOUNT OF INFO SENT HERE
 
 ## enables 404 error logging (default False)
 appenlight.report_404 = false
 
 ## time in seconds after request is considered being slow (default 1)
 appenlight.slow_request_time = 1
 
 ## record slow requests in application
 ## (needs to be enabled for slow datastore recording and time tracking)
 appenlight.slow_requests = true
 
 ## enable hooking to application loggers
 appenlight.logging = true
 
 ## minimum log level for log capture
 appenlight.logging.level = WARNING
 
 ## send logs only from erroneous/slow requests
 ## (saves API quota for intensive logging)
 appenlight.logging_on_error = false
 
 ## list of additonal keywords that should be grabbed from environ object
 ## can be string with comma separated list of words in lowercase
 ## (by default client will always send following info:
 ## 'REMOTE_USER', 'REMOTE_ADDR', 'SERVER_NAME', 'CONTENT_TYPE' + all keys that
 ## start with HTTP* this list be extended with additional keywords here
 appenlight.environ_keys_whitelist =
 
 ## list of keywords that should be blanked from request object
 ## can be string with comma separated list of words in lowercase
 ## (by default client will always blank keys that contain following words
 ## 'password', 'passwd', 'pwd', 'auth_tkt', 'secret', 'csrf'
 ## this list be extended with additional keywords set here
 appenlight.request_keys_blacklist =
 
 ## list of namespaces that should be ignores when gathering log entries
 ## can be string with comma separated list of namespaces
 ## (by default the client ignores own entries: appenlight_client.client)
 appenlight.log_namespace_blacklist =
 
 
 ################################################################################
 ## WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT*  ##
 ## Debug mode will enable the interactive debugging tool, allowing ANYONE to  ##
 ## execute malicious code after an exception is raised.                       ##
 ################################################################################
 set debug = false
 
 
 #########################################################
 ### DB CONFIGS - EACH DB WILL HAVE IT'S OWN CONFIG    ###
 #########################################################
 #sqlalchemy.db1.url = sqlite:///%(here)s/rhodecode.db?timeout=30
+#sqlalchemy.db1.url = postgresql://postgres:qweqwe@localhost/rhodecode
+#sqlalchemy.db1.url = mysql://root:qweqwe@localhost/rhodecode
 sqlalchemy.db1.url = postgresql://postgres:qweqwe@localhost/rhodecode
-#sqlalchemy.db1.url = mysql://root:qweqwe@localhost/rhodecode
 
 # see sqlalchemy docs for other advanced settings
 
 ## print the sql statements to output
 sqlalchemy.db1.echo = false
 ## recycle the connections after this ammount of seconds
 sqlalchemy.db1.pool_recycle = 3600
 sqlalchemy.db1.convert_unicode = true
 
 ## the number of connections to keep open inside the connection pool.
 ## 0 indicates no limit
 #sqlalchemy.db1.pool_size = 5
 
 ## the number of connections to allow in connection pool "overflow", that is
 ## connections that can be opened above and beyond the pool_size setting,
 ## which defaults to five.
 #sqlalchemy.db1.max_overflow = 10
 
 
 ##################
 ### VCS CONFIG ###
 ##################
 vcs.server.enable = true
 vcs.server = localhost:9900
 
 ## Web server connectivity protocol, responsible for web based VCS operatations
 ## Available protocols are:
 ## `pyro4` - using pyro4 server
 ## `http` - using http-rpc backend
 #vcs.server.protocol = http
 
 ## Push/Pull operations protocol, available options are:
 ## `pyro4` - using pyro4 server
 ## `rhodecode.lib.middleware.utils.scm_app_http` - Http based, recommended
 ## `vcsserver.scm_app` - internal app (EE only)
 #vcs.scm_app_implementation = rhodecode.lib.middleware.utils.scm_app_http
 
 ## Push/Pull operations hooks protocol, available options are:
 ## `pyro4` - using pyro4 server
 ## `http` - using http-rpc backend
 #vcs.hooks.protocol = http
 
 vcs.server.log_level = info
 ## Start VCSServer with this instance as a subprocess, usefull for development
 vcs.start_server = false
+
+## List of enabled VCS backends, available options are:
+## `hg`  - mercurial
+## `git` - git
+## `svn` - subversion
 vcs.backends = hg, git, svn
+
 vcs.connection_timeout = 3600
 ## Compatibility version when creating SVN repositories. Defaults to newest version when commented out.
 ## Available options are: pre-1.4-compatible, pre-1.5-compatible, pre-1.6-compatible, pre-1.8-compatible
 #vcs.svn.compatible_version = pre-1.8-compatible
 
+
+############################################################
+### Subversion proxy support (mod_dav_svn)               ###
+### Maps RhodeCode repo groups into SVN paths for Apache ###
+############################################################
+## Enable or disable the config file generation.
+svn.proxy.generate_config = false
+## Generate config file with `SVNListParentPath` set to `On`.
+svn.proxy.list_parent_path = true
+## Set location and file name of generated config file.
+svn.proxy.config_file_path = %(here)s/mod_dav_svn.conf
+## File system path to the directory containing the repositories served by
+## RhodeCode.
+svn.proxy.parent_path_root = /path/to/repo_store
+## Used as a prefix to the <Location> block in the generated config file. In
+## most cases it should be set to `/`.
+svn.proxy.location_root = /
+
+
 ################################
 ### LOGGING CONFIGURATION   ####
 ################################
 [loggers]
 keys = root, routes, rhodecode, sqlalchemy, beaker, pyro4, templates
 
 [handlers]
 keys = console, console_sql
 
 [formatters]
 keys = generic, color_formatter, color_formatter_sql
 
 #############
 ## LOGGERS ##
 #############
 [logger_root]
 level = NOTSET
 handlers = console
 
 [logger_routes]
 level = DEBUG
 handlers =
 qualname = routes.middleware
 ## "level = DEBUG" logs the route matched and routing variables.
 propagate = 1
 
 [logger_beaker]
 level = DEBUG
 handlers =
 qualname = beaker.container
 propagate = 1
 
 [logger_pyro4]
 level = DEBUG
 handlers =
 qualname = Pyro4
 propagate = 1
 
 [logger_templates]
 level = INFO
 handlers =
 qualname = pylons.templating
 propagate = 1
 
 [logger_rhodecode]
 level = DEBUG
 handlers =
 qualname = rhodecode
 propagate = 1
 
 [logger_sqlalchemy]
 level = INFO
 handlers = console_sql
 qualname = sqlalchemy.engine
 propagate = 0
 
 ##############
 ## HANDLERS ##
 ##############
 
 [handler_console]
 class = StreamHandler
 args = (sys.stderr,)
 level = INFO
 formatter = generic
 
 [handler_console_sql]
 class = StreamHandler
 args = (sys.stderr,)
 level = WARN
 formatter = generic
 
 ################
 ## FORMATTERS ##
 ################
 
 [formatter_generic]
 class = rhodecode.lib.logging_formatter.Pyro4AwareFormatter
 format = %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
 datefmt = %Y-%m-%d %H:%M:%S
 
 [formatter_color_formatter]
 class = rhodecode.lib.logging_formatter.ColorFormatter
 format = %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
 datefmt = %Y-%m-%d %H:%M:%S
 
 [formatter_color_formatter_sql]
 class = rhodecode.lib.logging_formatter.ColorFormatterSql
 format = %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
 datefmt = %Y-%m-%d %H:%M:%S

default.nix

@@ -1,227 +1,229 b''
 # Nix environment for the community edition
 #
 # This shall be as lean as possible, just producing the Enterprise
 # derivation. For advanced tweaks to pimp up the development environment we use
 # "shell.nix" so that it does not have to clutter this file.
 
 { pkgs ? (import <nixpkgs> {})
 , pythonPackages ? "python27Packages"
 , pythonExternalOverrides ? self: super: {}
 , doCheck ? true
 }:
 
 let pkgs_ = pkgs; in
 
 let
   pkgs = pkgs_.overridePackages (self: super: {
     # Override subversion derivation to
     #  - activate python bindings
     #  - set version to 1.8
     subversion = super.subversion18.override {
        httpSupport = true;
        pythonBindings = true;
        python = self.python27Packages.python;
     };
   });
 
   inherit (pkgs.lib) fix extends;
 
   basePythonPackages = with builtins; if isAttrs pythonPackages
     then pythonPackages
     else getAttr pythonPackages pkgs;
 
   elem = builtins.elem;
   basename = path: with pkgs.lib; last (splitString "/" path);
   startsWith = prefix: full: let
     actualPrefix = builtins.substring 0 (builtins.stringLength prefix) full;
   in actualPrefix == prefix;
 
   src-filter = path: type: with pkgs.lib;
     let
       ext = last (splitString "." path);
     in
       !elem (basename path) [
         ".git" ".hg" "__pycache__" ".eggs" "node_modules"
         "build" "data" "tmp"] &&
       !elem ext ["egg-info" "pyc"] &&
       !startsWith "result" path;
 
   sources = pkgs.config.rc.sources or {};
   rhodecode-enterprise-ce-src = builtins.filterSource src-filter ./.;
 
   # Load the generated node packages
   nodePackages = pkgs.callPackage "${pkgs.path}/pkgs/top-level/node-packages.nix" rec {
     self = nodePackages;
     generated = pkgs.callPackage ./pkgs/node-packages.nix { inherit self; };
   };
 
   # TODO: Should be taken automatically out of the generates packages.
   # apps.nix has one solution for this, although I'd prefer to have the deps
   # from package.json mapped in here.
   nodeDependencies = with nodePackages; [
     grunt
     grunt-contrib-concat
     grunt-contrib-jshint
     grunt-contrib-less
     grunt-contrib-watch
     jshint
   ];
 
   pythonGeneratedPackages = self: basePythonPackages.override (a: {
     inherit self;
   })
   // (scopedImport {
     self = self;
     super = basePythonPackages;
     inherit pkgs;
     inherit (pkgs) fetchurl fetchgit;
   } ./pkgs/python-packages.nix);
 
   pythonOverrides = import ./pkgs/python-packages-overrides.nix {
     inherit
       basePythonPackages
       pkgs;
   };
 
   pythonLocalOverrides = self: super: {
     rhodecode-enterprise-ce =
       let
         version = builtins.readFile ./rhodecode/VERSION;
         linkNodeModules = ''
           echo "Link node packages"
           # TODO: check if this adds stuff as a dependency, closure size
           rm -fr node_modules
           mkdir -p node_modules
           ${pkgs.lib.concatMapStrings (dep: ''
             ln -sfv ${dep}/lib/node_modules/${dep.pkgName} node_modules/
           '') nodeDependencies}
           echo "DONE: Link node packages"
         '';
       in super.rhodecode-enterprise-ce.override (attrs: {
 
       inherit
         doCheck
         version;
       name = "rhodecode-enterprise-ce-${version}";
       releaseName = "RhodeCodeEnterpriseCE-${version}";
       src = rhodecode-enterprise-ce-src;
 
       buildInputs =
         attrs.buildInputs ++
         (with self; [
           pkgs.nodePackages.grunt-cli
           pkgs.subversion
           pytest-catchlog
           rhodecode-testdata
         ]);
 
       propagatedBuildInputs = attrs.propagatedBuildInputs ++ (with self; [
         rhodecode-tools
       ]);
 
       # TODO: johbo: Make a nicer way to expose the parts. Maybe
       # pkgs/default.nix?
       passthru = {
         inherit
-          pythonLocalOverrides
-          myPythonPackagesUnfix;
+          linkNodeModules
+          myPythonPackagesUnfix
+          pythonLocalOverrides;
         pythonPackages = self;
       };
 
       LC_ALL = "en_US.UTF-8";
       LOCALE_ARCHIVE =
         if pkgs.stdenv ? glibc
         then "${pkgs.glibcLocales}/lib/locale/locale-archive"
         else "";
 
       # Somewhat snappier setup of the development environment
       # TODO: move into shell.nix
       # TODO: think of supporting a stable path again, so that multiple shells
       #       can share it.
       shellHook = ''
         tmp_path=$(mktemp -d)
         export PATH="$tmp_path/bin:$PATH"
         export PYTHONPATH="$tmp_path/${self.python.sitePackages}:$PYTHONPATH"
         mkdir -p $tmp_path/${self.python.sitePackages}
         python setup.py develop --prefix $tmp_path --allow-hosts ""
       '' + linkNodeModules;
 
       preCheck = ''
         export PATH="$out/bin:$PATH"
       '';
 
       postCheck = ''
         rm -rf $out/lib/${self.python.libPrefix}/site-packages/pytest_pylons
         rm -rf $out/lib/${self.python.libPrefix}/site-packages/rhodecode/tests
       '';
 
       preBuild = linkNodeModules + ''
         grunt
         rm -fr node_modules
       '';
 
       postInstall = ''
         # python based programs need to be wrapped
         ln -s ${self.supervisor}/bin/supervisor* $out/bin/
         ln -s ${self.gunicorn}/bin/gunicorn $out/bin/
         ln -s ${self.PasteScript}/bin/paster $out/bin/
+        ln -s ${self.channelstream}/bin/channelstream $out/bin/
         ln -s ${self.pyramid}/bin/* $out/bin/  #*/
 
         # rhodecode-tools
         # TODO: johbo: re-think this. Do the tools import anything from enterprise?
         ln -s ${self.rhodecode-tools}/bin/rhodecode-* $out/bin/
 
         # note that condition should be restricted when adding further tools
         for file in $out/bin/*; do  #*/
           wrapProgram $file \
               --prefix PYTHONPATH : $PYTHONPATH \
               --prefix PATH : $PATH \
               --set PYTHONHASHSEED random
         done
 
         mkdir $out/etc
         cp configs/production.ini $out/etc
 
         echo "Writing meta information for rccontrol to nix-support/rccontrol"
         mkdir -p $out/nix-support/rccontrol
         cp -v rhodecode/VERSION $out/nix-support/rccontrol/version
         echo "DONE: Meta information for rccontrol written"
 
         # TODO: johbo: Make part of ac-tests
         if [ ! -f rhodecode/public/js/scripts.js ]; then
           echo "Missing scripts.js"
           exit 1
         fi
         if [ ! -f rhodecode/public/css/style.css ]; then
           echo "Missing style.css"
           exit 1
         fi
       '';
 
     });
 
     rhodecode-testdata = import "${rhodecode-testdata-src}/default.nix" {
     inherit
       doCheck
       pkgs
       pythonPackages;
     };
 
   };
 
   rhodecode-testdata-src = sources.rhodecode-testdata or (
     pkgs.fetchhg {
       url = "https://code.rhodecode.com/upstream/rc_testdata";
       rev = "v0.8.0";
       sha256 = "0hy1ba134rq2f9si85yx7j4qhc9ky0hjzdk553s3q026i7km809m";
   });
 
   # Apply all overrides and fix the final package set
   myPythonPackagesUnfix =
     (extends pythonExternalOverrides
     (extends pythonLocalOverrides
     (extends pythonOverrides
              pythonGeneratedPackages)));
   myPythonPackages = (fix myPythonPackagesUnfix);
 
 in myPythonPackages.rhodecode-enterprise-ce

docs/admin/apache-reverse-proxy.rst

@@ -1,33 +1,33 b''
 Apache Reverse Proxy
 ^^^^^^^^^^^^^^^^^^^^
 
 Here is a sample configuration file for using Apache as a reverse proxy.
 
 .. code-block:: apache
 
     <VirtualHost *:80>
             ServerName hg.myserver.com
             ServerAlias hg.myserver.com
 
-            ## uncomment root directive if you want to serve static files by
-            ## Apache requires static_files = false in .ini file
-            #DocumentRoot /path/to/rhodecode/installation/public
+            ## uncomment to serve static files by Apache
+            ## ProxyPass /_static/rhodecode !
+            ## Alias /_static/rhodecode /path/to/.rccontrol/enterprise-1/static
 
             <Proxy *>
               Order allow,deny
               Allow from all
             </Proxy>
 
             ## Important !
             ## Directive to properly generate url (clone url) for pylons
             ProxyPreserveHost On
 
             ## RhodeCode instance running
             ProxyPass / http://127.0.0.1:10002/
             ProxyPassReverse / http://127.0.0.1:10002/
 
             ## to enable https use line below
             #SetEnvIf X-Url-Scheme https HTTPS=1
 
     </VirtualHost>
 

docs/admin/apache-subdirectory.rst

@@ -1,32 +1,33 b''
 .. _apache-sub-ref:
 
 Apache URL Prefix Configuration
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Use the following example to configure Apache to use a URL prefix.
 
 .. code-block:: apache
 
     <Location /<someprefix> > # Change <someprefix> into your chosen prefix
       ProxyPass http://127.0.0.1:5000/<someprefix>
       ProxyPassReverse http://127.0.0.1:5000/<someprefix>
       SetEnvIf X-Url-Scheme https HTTPS=1
     </Location>
 
 In addition to the regular Apache setup you will need to add the following
 lines into the ``rhodecode.ini`` file.
 
+* Above ``[app:main]`` section of the ``rhodecode.ini`` file add the
+  following section if it doesn't exist yet.
+
+.. code-block:: ini
+
+    [filter:proxy-prefix]
+    use = egg:PasteDeploy#prefix
+    prefix = /<someprefix> # Change <someprefix> into your chosen prefix
+
 * In the the ``[app:main]`` section of your ``rhodecode.ini`` file add the
   following line.
 
 .. code-block:: ini
 
     filter-with = proxy-prefix
-
-* At the end of the ``rhodecode.ini`` file add the following section.
-
-.. code-block:: ini
-
-    [filter:proxy-prefix]
-    use = egg:PasteDeploy#prefix
-    prefix = /<someprefix> # Change <someprefix> into your chosen prefix

docs/admin/backup-restore.rst

@@ -1,127 +1,127 b''
 .. _backup-ref:
 
 Backup and Restore
 ==================
 
 *“The condition of any backup is unknown until a restore is attempted.”*
 `Schrödinger's Backup`_
 
 To snapshot an instance of |RCE|, and save its settings, you need to backup the
 following parts of the system at the same time.
 
 * The |repos| managed by the instance.
 * The |RCE| database.
 * Any configuration files or extensions that you've configured.
 
 .. important::
 
    Ideally you should script all of these functions so that it creates a
    backup snapshot of your system at a particular timestamp and then run that
    script regularly.
 
 Backup Details
 --------------
 
 To backup the relevant parts of |RCE| required to restore your system, use
 the information in this section to identify what is important to you.
 
 Repository Backup
 ^^^^^^^^^^^^^^^^^
 
 To back up your |repos|, use the API to get a list of all |repos| managed,
 and then clone them to your backup location.
 
 Use the ``get_repos`` method to list all your managed |repos|,
 and use the ``clone_uri`` information that is returned. See the :ref:`api`
 for more information.
 
 .. important::
 
    This will not work for |svn| |repos|. Currently the only way to back up
    your |svn| |repos| is to make a copy of them.
 
    It is also important to note, that you can only restore the |svn| |repos|
    using the same version as they were saved with.
 
 Database Backup
 ^^^^^^^^^^^^^^^
 
 The instance database contains all the |RCE| permissions settings,
 and user management information. To backup your database,
 export it using the following appropriate example, and then move it to your
 backup location:
 
 .. code-block:: bash
 
    # For MySQL DBs
    $ mysqldump -u <uname> -p <pass> db_name > mysql-db-backup
 
    # For PostgreSQL DBs
    $ pg_dump dbname > postgresql-db-backup
 
    # For SQLlite
    $ sqlite3 rhodecode.db ‘.dump’ > sqlite-db-backup
 
 
 The default |RCE| SQLite database location is
 :file:`/home/{user}/.rccontrol/{instance-id}/rhodecode.db`
 
 If running MySQL or PostgreSQL databases, you will have configured these
 separately, for more information see :ref:`rhodecode-database-ref`
 
 Configuration File Backup
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Depending on your setup, you could have a number of configuration files that
 should be backed up. You may have some, or all of the configuration files
 listed in the :ref:`config-rce-files` section. Ideally you should back these
 up at the same time as the database and |repos|.
 
 Gist Backup
 ^^^^^^^^^^^
 
 To backup the gists on your |RCE| instance you can use the ``get_users`` and
 ``get_gists`` API methods to fetch the gists for each user on the instance.
 
 Extension Backups
 ^^^^^^^^^^^^^^^^^
 
 You should also backup any extensions added in the
 :file:`home/{user}/.rccontrol/{instance-id}/rcextensions` directory.
 
 Full-text Search Backup
 ^^^^^^^^^^^^^^^^^^^^^^^
 
 You may also have full text search set up, but the index can be rebuild from
 re-imported |repos| if necessary. You will most likely want to backup your
 :file:`mapping.ini` file if you've configured that. For more information, see
 the :ref:`indexing-ref` section.
 
 Restoration Steps
 -----------------
 
 To restore an instance of |RCE| from its backed up components, use the
 following steps.
 
 1. Install a new instance of |RCE|.
 2. Once installed, configure the instance to use the backed up
    :file:`rhodecode.ini` file. Ensure this file points to the backed up
    database, see the :ref:`config-database` section.
 3. Restart |RCE| and remap and rescan your |repos|, see the
    :ref:`remap-rescan` section.
 
 Post Restoration Steps
 ^^^^^^^^^^^^^^^^^^^^^^
 
 Once you have restored your |RCE| instance to basic functionality, you can
 then work on restoring any specific setup changes you had made.
 
 * To recreate the |RCE| index, use the backed up :file:`mapping.ini` file if
   you had made changes and rerun the indexer. See the
   :ref:`indexing-ref` section for details.
 * To reconfigure any extensions, copy the backed up extensions into the
   :file:`/home/{user}/.rccontrol/{instance-id}/rcextensions` and also specify
-  any custom hooks if necessary. See the :ref:`integrations-ref` section for
+  any custom hooks if necessary. See the :ref:`extensions-hooks-ref` section for
   details.
 
 .. _Schrödinger's Backup: http://novabackup.novastor.com/blog/schrodingers-backup-good-bad-backup/

docs/admin/nginx-config-example.rst

@@ -1,72 +1,120 b''
 Nginx Configuration Example
 ---------------------------
 
 Use the following example to configure Nginx as a your web server.
 
 .. code-block:: nginx
 
+    log_format log_custom '$remote_addr - $remote_user [$time_local] '
+                          '"$request" $status $body_bytes_sent '
+                          '"$http_referer" "$http_user_agent" '
+                          '$request_time $upstream_response_time $pipe';
+
     upstream rc {
 
         server 127.0.0.1:10002;
 
         # add more instances for load balancing
         # server 127.0.0.1:10003;
         # server 127.0.0.1:10004;
     }
 
-    ## gist alias
+    ## gist alias server, for serving nicer GIST urls
 
     server {
         listen          443;
         server_name     gist.myserver.com;
-        access_log      /var/log/nginx/gist.access.log;
+        access_log      /var/log/nginx/gist.access.log log_custom;
         error_log       /var/log/nginx/gist.error.log;
 
         ssl on;
         ssl_certificate     gist.rhodecode.myserver.com.crt;
         ssl_certificate_key gist.rhodecode.myserver.com.key;
 
         ssl_session_timeout 5m;
 
-        ssl_protocols SSLv3 TLSv1;
-        ssl_ciphers DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA:EDH-RSA-DES-CBC3-SHA:AES256-SHA:DES-CBC3-SHA:AES128-SHA:RC4-SHA:RC4-MD5;
+        ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
         ssl_prefer_server_ciphers on;
+        ssl_ciphers 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:AES:CAMELLIA:DES-CBC3-SHA:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!aECDH:!EDH-DSS-DES-CBC3-SHA:!EDH-RSA-DES-CBC3-SHA:!KRB5-DES-CBC3-SHA';
+
         add_header Strict-Transport-Security "max-age=31536000; includeSubdomains;";
 
         # Diffie-Hellman parameter for DHE ciphersuites, recommended 2048 bits
-        ssl_dhparam /etc/nginx/ssl/dhparam.pem;
+        #ssl_dhparam /etc/nginx/ssl/dhparam.pem;
 
         rewrite ^/(.+)$ https://rhodecode.myserver.com/_admin/gists/$1;
         rewrite (.*)    https://rhodecode.myserver.com/_admin/gists;
     }
 
+    ## HTTP to HTTPS rewrite
     server {
-        listen          443;
+        listen          80;
         server_name     rhodecode.myserver.com;
-        access_log      /var/log/nginx/rhodecode.access.log;
-        error_log       /var/log/nginx/rhodecode.error.log;
+
+        if ($http_host = rhodecode.myserver.com) {
+            rewrite  (.*)  https://rhodecode.myserver.com$1 permanent;
+        }
+    }
+
+    ## MAIN SSL enabled server
+    server {
+        listen       443 ssl;
+        server_name  rhodecode.myserver.com;
+
+        access_log   /var/log/nginx/rhodecode.access.log log_custom;
+        error_log    /var/log/nginx/rhodecode.error.log;
 
         ssl on;
         ssl_certificate     rhodecode.myserver.com.crt;
         ssl_certificate_key rhodecode.myserver.com.key;
 
         ssl_session_timeout 5m;
 
-        ssl_protocols SSLv3 TLSv1;
-        ssl_ciphers DHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA:EDH-RSA-DES-CBC3-SHA:AES256-SHA:DES-CBC3-SHA:AES128-SHA:RC4-SHA:RC4-MD5;
+        ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
         ssl_prefer_server_ciphers on;
+        ssl_ciphers 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:kEDH+AESGCM:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:ECDHE-ECDSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-DSS-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA:AES:CAMELLIA:DES-CBC3-SHA:!aNULL:!eNULL:!EXPORT:!DES:!RC4:!MD5:!PSK:!aECDH:!EDH-DSS-DES-CBC3-SHA:!EDH-RSA-DES-CBC3-SHA:!KRB5-DES-CBC3-SHA';
+
+        # Diffie-Hellman parameter for DHE ciphersuites, recommended 2048 bits
+        #ssl_dhparam /etc/nginx/ssl/dhparam.pem;
+
+        include     /etc/nginx/proxy.conf;
+
+        ## serve static files by nginx, recommended
+        # location /_static/rhodecode {
+        #    alias /path/to/.rccontrol/enterprise-1/static;
+        # }
 
-        ## uncomment root directive if you want to serve static files by nginx
-        ## requires static_files = false in .ini file
-        # root /path/to/rhodecode/installation/public;
+        ## channel stream live components
+        location /_channelstream {
+            rewrite /_channelstream/(.*) /$1 break;
+            proxy_pass                  http://127.0.0.1:9800;
 
-        include         /etc/nginx/proxy.conf;
+            proxy_connect_timeout        10;
+            proxy_send_timeout           10m;
+            proxy_read_timeout           10m;
+            tcp_nodelay                  off;
+            proxy_set_header             Host $host;
+            proxy_set_header             X-Real-IP $remote_addr;
+            proxy_set_header             X-Url-Scheme $scheme;
+            proxy_set_header             X-Forwarded-Proto $scheme;
+            proxy_set_header             X-Forwarded-For $proxy_add_x_forwarded_for;
+            gzip                         off;
+            proxy_http_version           1.1;
+            proxy_set_header Upgrade     $http_upgrade;
+            proxy_set_header Connection  "upgrade";
+        }
 
         location / {
             try_files $uri @rhode;
         }
 
-       location @rhode {
-           proxy_pass      http://rc;
-       }
-    }
+        location @rhode {
+            proxy_pass      http://rc;
+        }
+
+        ## custom 502 error page
+        error_page 502 /502.html;
+        location = /502.html {
+           root  /path/to/.rccontrol/enterprise-1/static;
+        }
+    }
  No newline at end of file

docs/admin/nginx-url-prefix.rst

@@ -1,33 +1,36 b''
 .. _nginx_url-pre:
 
 Nginx URL Prefix Configuration
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Use the following example to configure Nginx to use a URL prefix.
 
 .. code-block:: nginx
 
     location  /foo {
       rewrite /foo(.*) /$1  break;
       proxy_pass         http://localhost:3200;
       proxy_redirect     off;
       proxy_set_header   Host $host;
     }
 
 In addition to the Nginx configuration you will need to add the following
-lines into the ``rhodecode.ini`` file.
+lines (if they not exist) into the ``rhodecode.ini`` file.
+
+* Above ``[app:main]`` section of the ``rhodecode.ini`` file add the
+  following section if it doesn't exist yet.
+
+.. code-block:: ini
+
+    [filter:proxy-prefix]
+    use = egg:PasteDeploy#prefix
+    prefix = /<someprefix> # Change <someprefix> into your chosen prefix
 
 * In the the ``[app:main]`` section of your ``rhodecode.ini`` file add the
   following line.
 
 .. code-block:: ini
 
     filter-with = proxy-prefix
 
-* At the end of the ``rhodecode.ini`` file add the following section.
 
-.. code-block:: ini
-
-    [filter:proxy-prefix]
-    use = egg:PasteDeploy#prefix
-    prefix = /<someprefix> # Change <someprefix> into your chosen prefix

docs/admin/repo-extra-fields.rst

@@ -1,68 +1,68 b''
 .. _repo-xtra:
 
 Repository Extra Fields
 =======================
 
 Extra fields attached to a |repo| allow you to configure additional actions for
 |RCX|. To install and read more about |RCX|, see the :ref:`install-rcx` section.
 
 Enabling Extra Fields
 ---------------------
 
 To enable extra fields on |repos|, use the following steps:
 
 1. Go to the :menuselection:`Admin --> Settings --> Visual` page.
 2. Check the :guilabel:`Use repository extra fields` box.
 3. Save your changes.
 
 
 Configuring Extra Fields
 ------------------------
 
 To configure extra fields per repository, use the following steps:
 
 1. Go to :menuselection:`Admin --> Repositories` and select :guilabel:`Edit`
    beside the |repo| to which you wish to add extra fields.
 2. On the |repo| settings page, select the :guilabel:`Extra fields` tab.
 
 .. image:: ../images/extra-repo-fields.png
 
 
 Example Usage
 -------------
 
 To use the extra fields in an extension, see the example below. For more
-information and examples, see the :ref:`integrations-ref` section.
+information and examples, see the :ref:`extensions-hooks-ref` section.
 
 .. code-block:: python
 
     call = load_extension('http_notify.py')
     if call:
         url = 'http://default.url' # <url for post data>
 
         # possibly extract the URL from extra fields
         call = load_extension('extra_fields.py')
         if call:
             repo_extra_fields = call(**kwargs)
             # now update if we have extra fields, they have precedence
             # this way users can store any configuration inside the database per
             # repo
             for key, data in repo_extra_fields.items():
                 kwargs[key] = data['field_value']
 
         # an endpoint url data will be sent to, fetched from extra fields
         # if exists, or fallback to default
         kwargs['URL'] = kwargs.pop('webhook_url', None) or url
 
         # fetch pushed commits, from commit_ids list
         call = load_extension('extract_commits.py')
         extracted_commits = {}
         if call:
             extracted_commits = call(**kwargs)
             # store the commits for the next call chain
         kwargs['COMMITS'] = extracted_commits
 
         # set additional keys and values to be sent via POST to given URL
         kwargs['caller_type'] = 'rhodecode'
         kwargs['date'] = time.time() # import time before
         call(**kwargs)

docs/admin/reset-information.rst

@@ -1,95 +1,95 b''
 .. _rhodecode-reset-ref:
 
 Settings Management
 -------------------
 
 All |RCE| settings can be set from the user interface, but in the event that
 it somehow becomes unavailable you can use ``ishell`` inside your |RCE|
 ``virtualenv`` to carry out emergency measures.
 
 .. warning::
 
    Logging into the |RCE| database with ``iShell`` should only be done by an
    experienced and knowledgeable database administrator.
 
 Reset Admin Account Privileges
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 If you accidentally remove your admin privileges from the admin account you
 can restore them using ``ishell``. Use the following example to reset your
 account permissions.
 
 .. code-block:: bash
 
     # Open iShell from the terminal
     $ .rccontrol/enterprise-5/profile/bin/paster \
         ishell .rccontrol/enterprise-5/rhodecode.ini
 
 .. code-block:: mysql
 
     # Use this example to change user permissions
     In [1]: adminuser = User.get_by_username('username')
     In [2]: adminuser.admin = True
-    In [3]: Session.add(adminuser);Session().commit()
+    In [3]: Session().add(adminuser);Session().commit()
     In [4]: exit()
 
 Set to read global ``.hgrc`` file
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 By default, |RCE| does not read global ``hgrc`` files in
 ``/etc/mercurial/hgrc`` or ``/etc/mercurial/hgrc.d`` because it
 can lead to issues. This is set in the ``rhodecode_ui`` table for which
 there is no UI. If you need to edit this you can
 manually change the settings using SQL statements with ``ishell``. Use the
 following example to make changes to this table.
 
 .. code-block:: bash
 
   # Open iShell from the terminal
   $ .rccontrol/enterprise-5/profile/bin/paster \
       ishell.rccontrol/enterprise-5/rhodecode.ini
 
 .. code-block:: mysql
 
   # Use this example to enable global .hgrc access
   In [4]: new_option = RhodeCodeUi()
   In [5]: new_option.ui_section='web'
   In [6]: new_option.ui_key='allow_push'
   In [7]: new_option.ui_value='*'
   In [8]: Session().add(new_option);Session().commit()
 
 Manually Reset Password
 ^^^^^^^^^^^^^^^^^^^^^^^
 
 If you need to manually reset a user password, use the following steps.
 
 1. Navigate to your |RCE| install location.
 2. Run the interactive ``ishell`` prompt.
 3. Set a new password.
 
 Use the following code example to carry out these steps.
 
 .. code-block:: bash
 
     # starts the ishell interactive prompt
     $ .rccontrol/enterprise-5/profile/bin/paster \
         ishell .rccontrol/enterprise-5/rhodecode.ini
 
 .. code-block:: mysql
 
     from rhodecode.lib.auth import generate_auth_token
     from rhodecode.lib.auth import get_crypt_password
 
     # Enter the user name whose password you wish to change
     my_user = 'USERNAME'
     u = User.get_by_username(my_user)
 
     # If this fails then the user does not exist
     u.auth_token = generate_auth_token(my_user)
 
     # Set the new password
     u.password = get_crypt_password('PASSWORD')
 
     Session().add(u)
     Session().commit()
     exit

docs/admin/svn-http.rst

@@ -1,84 +1,84 b''
 .. _svn-http:
 
 |svn| With Write Over HTTP
 --------------------------
 
 To use |svn| with write access, the currently supported method is over HTTP.
 This requires you to configure your local machine so that it can access your
 |RCE| instance.
 
 Prerequisites
 ^^^^^^^^^^^^^
 
 - Enable lab setting on your |RCE| instance, see :ref:`lab-settings`.
 - You need to install the following tools on your local machine: ``Apache`` and
   ``mod_dav_svn``. Use the following Ubuntu as an example.
 
 .. code-block:: bash
 
     $ sudo apt-get install apache2 libapache2-mod-svn
 
 Once installed you need to enable ``dav_svn``:
 
 .. code-block:: bash
 
     $ sudo a2enmod dav_svn
 
 Configuring Apache Setup
 ^^^^^^^^^^^^^^^^^^^^^^^^
 
 .. tip::
 
    It is recommended to run Apache on a port other than 80, due to possible
    conflicts with other HTTP servers like nginx. To do this, set the
    ``Listen`` parameter in the ``/etc/apache2/ports.conf`` file, for example
    ``Listen 8090``
 
    It is also recommended to run apache as the same user as |RCE|, otherwise
    permission issues could occur. To do this edit the ``/etc/apache2/envvars``
 
    .. code-block:: apache
 
       export APACHE_RUN_USER=ubuntu
       export APACHE_RUN_GROUP=ubuntu
 
 1. To configure Apache, create and edit a virtual hosts file, for example
    :file:`/etc/apache2/sites-available/default.conf`, or create another
    virtual hosts file and add a location section inside the
    ``<VirtualHost>`` section.
 
 .. code-block:: apache
 
     <Location />
         DAV svn
         # Must be explicit path, relative not supported
         SVNParentPath /PATH/TO/REPOSITORIES
         SVNListParentPath On
         Allow from all
         Order allow,deny
     </Location>
 
 .. note::
 
    Once configured, check that you can see the list of repositories on your
    |RCE| instance.
 
 2. Go to the :menuselection:`Admin --> Settings --> Labs` page, and
    enable :guilabel:`Proxy Subversion HTTP requests`, and specify the
    :guilabel:`Subversion HTTP Server URL`.
 
 Using |svn|
 ^^^^^^^^^^^
 
 Once |svn| has been enabled on your instance, you can use it using the
 following examples. For more |svn| information, see the `Subversion Red Book`_
 
 .. code-block:: bash
 
     # To clone a repository
-    svn clone http://my-svn-server.example.com/my-svn-repo
+    svn checkout http://my-svn-server.example.com/my-svn-repo
 
     # svn commit
     svn commit
 
 .. _Subversion Red Book: http://svnbook.red-bean.com/en/1.7/svn-book.html#svn.ref.svn

docs/api/api.rst

@@ -1,2824 +1,207 b''
 .. _api:
 
 API Documentation
 =================
 
 The |RCE| API uses a single scheme for calling all API methods. The API is
 implemented with JSON protocol in both directions. To send API requests to
 your instance of |RCE|, use the following URL format
 ``<your_server>/_admin``
 
 .. note::
 
    To use the API, you should configure the :file:`~/.rhoderc` file with
    access details per instance. For more information, see
    :ref:`config-rhoderc`.
 
 
 API ACCESS FOR WEB VIEWS
 ------------------------
 
 API access can also be turned on for each web view in |RCE| that is
 decorated with a `@LoginRequired` decorator. To enable API access, change
 the standard login decorator to `@LoginRequired(api_access=True)`.
 
 From |RCM| version 1.7.0 you can configure a white list
 of views that have API access enabled by default. To enable these,
 edit the |RCM| configuration ``.ini`` file. The default location is:
 
 * |RCM| Pre-2.2.7 :file:`root/rhodecode/data/production.ini`
 * |RCM| 3.0 :file:`/home/{user}/.rccontrol/{instance-id}/rhodecode.ini`
 
 To configure the white list, edit this section of the file. In this
 configuration example, API access is granted to the patch/diff raw file and
 archive.
 
 .. code-block:: ini
 
     ## List of controllers (using glob syntax) that AUTH TOKENS could be used for access.
     ## Adding ?auth_token = <token> to the url authenticates this request as if it
     ## came from the the logged in user who own this authentication token.
     ##
     ## Syntax is <ControllerClass>:<function_pattern>.
     ## The list should be "," separated and on a single line.
     ##
     api_access_controllers_whitelist = ChangesetController:changeset_patch,ChangesetController:changeset_raw,ilesController:raw,FilesController:archivefile,
 
 After this change, a |RCE| view can be accessed without login by adding a
 GET parameter ``?auth_token=<auth_token>`` to a url. For example to
 access the raw diff.
 
 .. code-block:: html
 
    http://<server>/<repo>/changeset-diff/<sha>?auth_token=<auth_token>
 
 By default this is only enabled on RSS/ATOM feed views. Exposing raw diffs is a
 good way to integrate with 3rd party services like code review, or build farms
 that could download archives.
 
 API ACCESS
 ----------
 
 All clients are required to send JSON-RPC spec JSON data.
 
 .. code-block:: bash
 
     {
         "id:"<id>",
         "auth_token":"<auth_token>",
         "method":"<method_name>",
         "args":{"<arg_key>":"<arg_val>"}
     }
 
 Example call for auto pulling from remote repositories using curl:
 
 .. code-block:: bash
 
     curl https://server.com/_admin/api -X POST -H 'content-type:text/plain' --data-binary '{"id":1,
     "auth_token":"xe7cdb2v278e4evbdf5vs04v832v0efvcbcve4a3","method":"pull", "args":{"repo":"CPython"}}'
 
 Provide those parameters:
  - **id** A value of any type, which is used to match the response with the
    request that it is replying to.
  - **auth_token** 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::
 
     To get your |authtoken|, from the |RCE| interface,
     go to:
     :menuselection:`username --> My account --> Auth tokens`
 
     For security reasons you should always create a dedicated |authtoken| for
     API use only.
 
 
 The |RCE| API will always return a JSON-RPC response:
 
 .. code-block:: bash
 
     {
         "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 with `HTTP/1.0 200 OK` status code.
 If there is an error when calling the API, the *error* key will contain a
 failure description and the *result* will be `null`.
 
 API CLIENT
 ----------
 
 To install the |RCE| API, see :ref:`install-tools`. To configure the API per
 instance, see the :ref:`rc-tools` section as you need to configure a
 :file:`~/.rhoderc` file with your |authtokens|.
 
 Once you have set up your instance API access, use the following examples to
 get started.
 
 .. code-block:: bash
 
     # Getting the 'rhodecode' repository
     # from a RhodeCode Enterprise instance
     rhodecode-api --instance-name=enterprise-1 get_repo repoid:rhodecode
 
     Calling method get_repo => http://127.0.0.1:5000
     Server response
     {
         <json data>
     }
 
     # Creating a new mercurial repository called 'brand-new'
     # with a description 'Repo-description'
     rhodecode-api --instance-name=enterprise-1 create_repo repo_name:brand-new repo_type:hg description:Repo-description
     {
       "error": null,
       "id": 1110,
       "result": {
         "msg": "Created new repository `brand-new`",
         "success": true,
         "task": null
       }
     }
 
 A broken example, what not to do.
 
 .. code-block:: bash
 
     # A call missing the required arguments
     # and not specifying the instance
     rhodecode-api get_repo
 
     Calling method get_repo => http://127.0.0.1:5000
     Server response
     "Missing non optional `repoid` arg in JSON DATA"
 
 You can specify pure JSON using the ``--format`` parameter.
 
 .. code-block:: bash
 
     rhodecode-api --format=json get_repo repoid:rhodecode
 
 In such case only output that this function shows is pure JSON, we can use that
 and pipe output to some json formatter.
 
 If output is in pure JSON format, you can pipe output to a JSON formatter.
 
 .. code-block:: bash
 
     rhodecode-api --instance-name=enterprise-1 --format=json get_repo repoid:rhodecode | python -m json.tool
 
 API METHODS
 -----------
 
 Each method by default required following arguments.
 
 .. code-block:: bash
 
     id :      "<id_for_response>"
     auth_token : "<auth_token>"
     method :  "<method name>"
     args :    {}
 
 Use each **param** from docs and put it in args, Optional parameters
 are not required in args.
 
 .. code-block:: bash
 
     args: {"repoid": "rhodecode"}
 
 .. Note: From this point on things are generated by the script in
    `scripts/fabfile.py`. To change things below, update the docstrings in the
    ApiController.
 
 .. --- API DEFS MARKER ---
-
-pull
-----
-
-.. py:function:: pull(apiuser, repoid)
-
-   Triggers a pull on the given repository from a remote location. You
-   can use this to keep remote repositories up-to-date.
-
-   This command can only be run using an |authtoken| with admin
-   rights to the specified repository. For more information,
-   see :ref:`config-token-ref`.
-
-   This command takes the following options:
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: The repository name or repository ID.
-   :type repoid: str or int
-
-   Example output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : {
-       "msg": "Pulled from `<repository name>`"
-       "repository": "<repository name>"
-     }
-     error :  null
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : null
-     error :  {
-       "Unable to pull changes from `<reponame>`"
-     }
-
-
-strip
------
-
-.. py:function:: strip(apiuser, repoid, revision, branch)
-
-   Strips the given revision from the specified repository.
-
-   * This will remove the revision and all of its decendants.
-
-   This command can only be run using an |authtoken| with admin rights to
-   the specified repository.
-
-   This command takes the following options:
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: The repository name or repository ID.
-   :type repoid: str or int
-   :param revision: The revision you wish to strip.
-   :type revision: str
-   :param branch: The branch from which to strip the revision.
-   :type branch: str
-
-   Example output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : {
-       "msg": "'Stripped commit <commit_hash> from repo `<repository name>`'"
-       "repository": "<repository name>"
-     }
-     error :  null
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : null
-     error :  {
-       "Unable to strip commit <commit_hash> from repo `<repository name>`"
-     }
-
-
-rescan_repos
-------------
-
-.. py:function:: rescan_repos(apiuser, remove_obsolete=<Optional:False>)
-
-   Triggers a rescan of the specified repositories.
-
-   * If the ``remove_obsolete`` option is set, it also deletes repositories
-     that are found in the database but not on the file system, so called
-     "clean zombies".
-
-   This command can only be run using an |authtoken| with admin rights to
-   the specified repository.
-
-   This command takes the following options:
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param remove_obsolete: Deletes repositories from the database that
-       are not found on the filesystem.
-   :type remove_obsolete: Optional(``True`` | ``False``)
-
-   Example output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : {
-       'added': [<added repository name>,...]
-       'removed': [<removed repository name>,...]
-     }
-     error :  null
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : null
-     error :  {
-       'Error occurred during rescan repositories action'
-     }
-
-
-invalidate_cache
-----------------
-
-.. py:function:: invalidate_cache(apiuser, repoid, delete_keys=<Optional:False>)
-
-   Invalidates the cache for the specified repository.
-
-   This command can only be run using an |authtoken| with admin rights to
-   the specified repository.
-
-   This command takes the following options:
-
-   :param apiuser: This is filled automatically from |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: Sets the repository name or repository ID.
-   :type repoid: str or int
-   :param delete_keys: This deletes the invalidated keys instead of
-       just flagging them.
-   :type delete_keys: Optional(``True`` | ``False``)
-
-   Example output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : {
-       'msg': Cache for repository `<repository name>` was invalidated,
-       'repository': <repository name>
-     }
-     error :  null
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : null
-     error : {
-        'Error occurred during cache invalidation action'
-     }
-
-
-lock
-----
-
-.. py:function:: lock(apiuser, repoid, locked=<Optional:None>, userid=<Optional:<OptionalAttr:apiuser>>)
-
-   Sets the lock state of the specified |repo| by the given user.
-   From more information, see :ref:`repo-locking`.
-
-   * If the ``userid`` option is not set, the repository is locked to the
-     user who called the method.
-   * If the ``locked`` parameter is not set, the current lock state of the
-     repository is displayed.
-
-   This command can only be run using an |authtoken| with admin rights to
-   the specified repository.
-
-   This command takes the following options:
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: Sets the repository name or repository ID.
-   :type repoid: str or int
-   :param locked: Sets the lock state.
-   :type locked: Optional(``True`` | ``False``)
-   :param userid: Set the repository lock to this user.
-   :type userid: Optional(str or int)
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : {
-       'repo': '<reponame>',
-       'locked': <bool: lock state>,
-       'locked_since': <int: lock timestamp>,
-       'locked_by': <username of person who made the lock>,
-       'lock_reason': <str: reason for locking>,
-       'lock_state_changed': <bool: True if lock state has been changed in this request>,
-       'msg': 'Repo `<reponame>` locked by `<username>` on <timestamp>.'
-       or
-       'msg': 'Repo `<repository name>` not locked.'
-       or
-       'msg': 'User `<user name>` set lock state for repo `<repository name>` to `<new lock state>`'
-     }
-     error :  null
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : null
-     error :  {
-       'Error occurred locking repository `<reponame>`
-     }
-
-
-get_locks
----------
-
-.. py:function:: get_locks(apiuser, userid=<Optional:<OptionalAttr:apiuser>>)
-
-   Displays all repositories locked by the specified user.
-
-   * If this command is run by a non-admin user, it returns
-     a list of |repos| locked by that user.
-
-   This command takes the following options:
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param userid: Sets the userid whose list of locked |repos| will be
-       displayed.
-   :type userid: Optional(str or int)
-
-   Example output:
-
-   .. code-block:: bash
-
-       id : <id_given_in_input>
-       result : {
-           [repo_object, repo_object,...]
-       }
-       error :  null
-
-
-get_ip
-------
-
-.. py:function:: get_ip(apiuser, userid=<Optional:<OptionalAttr:apiuser>>)
-
-   Displays the IP Address as seen from the |RCE| server.
-
-   * This command displays the IP Address, as well as all the defined IP
-     addresses for the specified user. If the ``userid`` is not set, the
-     data returned is for the user calling the method.
-
-   This command can only be run using an |authtoken| with admin rights to
-   the specified repository.
-
-   This command takes the following options:
-
-   :param apiuser: This is filled automatically from |authtoken|.
-   :type apiuser: AuthUser
-   :param userid: Sets the userid for which associated IP Address data
-       is returned.
-   :type userid: Optional(str or int)
-
-   Example output:
-
-   .. code-block:: bash
-
-       id : <id_given_in_input>
-       result : {
-                    "server_ip_addr": "<ip_from_clien>",
-                    "user_ips": [
-                                   {
-                                      "ip_addr": "<ip_with_mask>",
-                                      "ip_range": ["<start_ip>", "<end_ip>"],
-                                   },
-                                   ...
-                                ]
-       }
-
-
-show_ip
--------
-
-.. py:function:: show_ip(apiuser, userid=<Optional:<OptionalAttr:apiuser>>)
-
-   Displays the IP Address as seen from the |RCE| server.
-
-   * This command displays the IP Address, as well as all the defined IP
-     addresses for the specified user. If the ``userid`` is not set, the
-     data returned is for the user calling the method.
-
-   This command can only be run using an |authtoken| with admin rights to
-   the specified repository.
-
-   This command takes the following options:
-
-   :param apiuser: This is filled automatically from |authtoken|.
-   :type apiuser: AuthUser
-   :param userid: Sets the userid for which associated IP Address data
-       is returned.
-   :type userid: Optional(str or int)
-
-   Example output:
-
-   .. code-block:: bash
-
-       id : <id_given_in_input>
-       result : {
-                    "server_ip_addr": "<ip_from_clien>",
-                    "user_ips": [
-                                   {
-                                      "ip_addr": "<ip_with_mask>",
-                                      "ip_range": ["<start_ip>", "<end_ip>"],
-                                   },
-                                   ...
-                                ]
-       }
-
-
-get_license_info
-----------------
-
-.. py:function:: get_license_info(apiuser)
-
-   Returns the |RCE| license information.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-
-   Example output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : {
-       'rhodecode_version': <rhodecode version>,
-       'token': <license token>,
-       'issued_to': <license owner>,
-       'issued_on': <license issue date>,
-       'expires_on': <license expiration date>,
-       'type': <license type>,
-       'users_limit': <license users limit>,
-       'key': <license key>
-     }
-     error :  null
-
-
-set_license_key
----------------
-
-.. py:function:: set_license_key(apiuser, key)
-
-   Sets the |RCE| license key.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param key: This is the license key to be set.
-   :type key: str
-
-   Example output:
-
-   .. code-block:: bash
-
-       id : <id_given_in_input>
-       result: {
-                 "msg" : "updated license information",
-                 "key": <key>
-               }
-       error:  null
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : null
-     error :  {
-       "license key is not valid"
-       or
-       "trial licenses cannot be uploaded"
-       or
-       "error occurred while updating license"
-     }
-
-
-get_server_info
----------------
-
-.. py:function:: get_server_info(apiuser)
-
-   Returns the |RCE| server information.
-
-   This includes the running version of |RCE| and all installed
-   packages. This command takes the following options:
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-
-   Example output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : {
-       'modules': [<module name>,...]
-       'py_version': <python version>,
-       'platform': <platform type>,
-       'rhodecode_version': <rhodecode version>
-     }
-     error :  null
-
-
-get_user
---------
-
-.. py:function:: get_user(apiuser, userid=<Optional:<OptionalAttr:apiuser>>)
-
-   Returns the information associated with a username or userid.
-
-   * If the ``userid`` is not set, this command returns the information
-     for the ``userid`` calling the method.
-
-   .. note::
-
-      Normal users may only run this command against their ``userid``. For
-      full privileges you must run this command using an |authtoken| with
-      admin rights.
-
-   This command takes the following options:
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param userid: Sets the userid for which data will be returned.
-   :type userid: Optional(str or int)
-
-   Example output:
-
-   .. code-block:: bash
-
-       {
-         "error": null,
-         "id": <id>,
-         "result": {
-           "active": true,
-           "admin": false,
-           "api_key": "api-key",
-           "api_keys": [ list of keys ],
-           "email": "[e-mail]",
-           "emails": [
-             "[e-mail]"
-           ],
-           "extern_name": "rhodecode",
-           "extern_type": "rhodecode",
-           "firstname": "username",
-           "ip_addresses": [],
-           "language": null,
-           "last_login": "Timestamp",
-           "lastname": "surnae",
-           "permissions": {
-             "global": [
-               "hg.inherit_default_perms.true",
-               "usergroup.read",
-               "hg.repogroup.create.false",
-               "hg.create.none",
-               "hg.extern_activate.manual",
-               "hg.create.write_on_repogroup.false",
-               "hg.usergroup.create.false",
-               "group.none",
-               "repository.none",
-               "hg.register.none",
-               "hg.fork.repository"
-             ],
-             "repositories": { "username/example": "repository.write"},
-             "repositories_groups": { "user-group/repo": "group.none" },
-             "user_groups": { "user_group_name": "usergroup.read" }
-           },
-           "user_id": 32,
-           "username": "username"
-         }
-       }
-
-
-get_users
----------
-
-.. py:function:: get_users(apiuser)
-
-   Lists all users in the |RCE| user database.
-
-   This command can only be run using an |authtoken| with admin rights to
-   the specified repository.
-
-   This command takes the following options:
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-
-   Example output:
-
-   .. code-block:: bash
-
-       id : <id_given_in_input>
-           result: [<user_object>, ...]
-       error:  null
-
-
-create_user
------------
-
-.. py:function:: create_user(apiuser, username, email, password=<Optional:''>, firstname=<Optional:''>, lastname=<Optional:''>, active=<Optional:True>, admin=<Optional:False>, extern_name=<Optional:'rhodecode'>, extern_type=<Optional:'rhodecode'>, force_password_change=<Optional:False>)
-
-   Creates a new user and returns the new user object.
-
-   This command can only be run using an |authtoken| with admin rights to
-   the specified repository.
-
-   This command takes the following options:
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param username: Set the new username.
-   :type username: str or int
-   :param email: Set the user email address.
-   :type email: str
-   :param password: Set the new user password.
-   :type password: Optional(str)
-   :param firstname: Set the new user firstname.
-   :type firstname: Optional(str)
-   :param lastname: Set the new user surname.
-   :type lastname: Optional(str)
-   :param active: Set the user as active.
-   :type active: Optional(``True`` | ``False``)
-   :param admin: Give the new user admin rights.
-   :type admin: Optional(``True`` | ``False``)
-   :param extern_name: Set the authentication plugin name.
-       Using LDAP this is filled with LDAP UID.
-   :type extern_name: Optional(str)
-   :param extern_type: Set the new user authentication plugin.
-   :type extern_type: Optional(str)
-   :param force_password_change: Force the new user to change password
-       on next login.
-   :type force_password_change: Optional(``True`` | ``False``)
-
-   Example output:
-
-   .. code-block:: bash
-
-       id : <id_given_in_input>
-       result: {
-                 "msg" : "created new user `<username>`",
-                 "user": <user_obj>
-               }
-       error:  null
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : null
-     error :  {
-       "user `<username>` already exist"
-       or
-       "email `<email>` already exist"
-       or
-       "failed to create user `<username>`"
-     }
-
-
-update_user
------------
-
-.. py:function:: update_user(apiuser, userid, username=<Optional:None>, email=<Optional:None>, password=<Optional:None>, firstname=<Optional:None>, lastname=<Optional:None>, active=<Optional:None>, admin=<Optional:None>, extern_type=<Optional:None>, extern_name=<Optional:None>)
-
-   Updates the details for the specified user, if that user exists.
-
-   This command can only be run using an |authtoken| with admin rights to
-   the specified repository.
-
-   This command takes the following options:
-
-   :param apiuser: This is filled automatically from |authtoken|.
-   :type apiuser: AuthUser
-   :param userid: Set the ``userid`` to update.
-   :type userid: str or int
-   :param username: Set the new username.
-   :type username: str or int
-   :param email: Set the new email.
-   :type email: str
-   :param password: Set the new password.
-   :type password: Optional(str)
-   :param firstname: Set the new first name.
-   :type firstname: Optional(str)
-   :param lastname: Set the new surname.
-   :type lastname: Optional(str)
-   :param active: Set the new user as active.
-   :type active: Optional(``True`` | ``False``)
-   :param admin: Give the user admin rights.
-   :type admin: Optional(``True`` | ``False``)
-   :param extern_name: Set the authentication plugin user name.
-       Using LDAP this is filled with LDAP UID.
-   :type extern_name: Optional(str)
-   :param extern_type: Set the authentication plugin type.
-   :type extern_type: Optional(str)
-
-
-   Example output:
-
-   .. code-block:: bash
-
-       id : <id_given_in_input>
-       result: {
-                 "msg" : "updated user ID:<userid> <username>",
-                 "user": <user_object>,
-               }
-       error:  null
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : null
-     error :  {
-       "failed to update user `<username>`"
-     }
-
-
-delete_user
------------
-
-.. py:function:: delete_user(apiuser, userid)
-
-   Deletes the specified user from the |RCE| user database.
-
-   This command can only be run using an |authtoken| with admin rights to
-   the specified repository.
-
-   .. important::
-
-      Ensure all open pull requests and open code review
-      requests to this user are close.
-
-      Also ensure all repositories, or repository groups owned by this
-      user are reassigned before deletion.
-
-   This command takes the following options:
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param userid: Set the user to delete.
-   :type userid: str or int
-
-   Example output:
-
-   .. code-block:: bash
-
-       id : <id_given_in_input>
-       result: {
-                 "msg" : "deleted user ID:<userid> <username>",
-                 "user": null
-               }
-       error:  null
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : null
-     error :  {
-       "failed to delete user ID:<userid> <username>"
-     }
-
-
-get_user_group
---------------
-
-.. py:function:: get_user_group(apiuser, usergroupid)
-
-   Returns the data of an existing user group.
-
-   This command can only be run using an |authtoken| with admin rights to
-   the specified repository.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param usergroupid: Set the user group from which to return data.
-   :type usergroupid: str or int
-
-   Example error output:
-
-   .. code-block:: bash
-
-       {
-         "error": null,
-         "id": <id>,
-         "result": {
-           "active": true,
-           "group_description": "group description",
-           "group_name": "group name",
-           "members": [
-             {
-               "name": "owner-name",
-               "origin": "owner",
-               "permission": "usergroup.admin",
-               "type": "user"
-             },
-             {
-             {
-               "name": "user name",
-               "origin": "permission",
-               "permission": "usergroup.admin",
-               "type": "user"
-             },
-             {
-               "name": "user group name",
-               "origin": "permission",
-               "permission": "usergroup.write",
-               "type": "user_group"
-             }
-           ],
-           "owner": "owner name",
-           "users": [],
-           "users_group_id": 2
-         }
-       }
-
-
-get_user_groups
----------------
-
-.. py:function:: get_user_groups(apiuser)
-
-   Lists all the existing user groups within RhodeCode.
-
-   This command can only be run using an |authtoken| with admin rights to
-   the specified repository.
-
-   This command takes the following options:
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-
-   Example error output:
-
-   .. code-block:: bash
-
-       id : <id_given_in_input>
-       result : [<user_group_obj>,...]
-       error : null
-
-
-create_user_group
------------------
-
-.. py:function:: create_user_group(apiuser, group_name, description=<Optional:''>, owner=<Optional:<OptionalAttr:apiuser>>, active=<Optional:True>)
-
-   Creates a new user group.
-
-   This command can only be run using an |authtoken| with admin rights to
-   the specified repository.
-
-   This command takes the following options:
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param group_name: Set the name of the new user group.
-   :type group_name: str
-   :param description: Give a description of the new user group.
-   :type description: str
-   :param owner: Set the owner of the new user group.
-       If not set, the owner is the |authtoken| user.
-   :type owner: Optional(str or int)
-   :param active: Set this group as active.
-   :type active: Optional(``True`` | ``False``)
-
-   Example output:
-
-   .. code-block:: bash
-
-       id : <id_given_in_input>
-       result: {
-                 "msg": "created new user group `<groupname>`",
-                 "user_group": <user_group_object>
-               }
-       error:  null
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : null
-     error :  {
-       "user group `<group name>` already exist"
-       or
-       "failed to create group `<group name>`"
-     }
-
-
-update_user_group
------------------
-
-.. py:function:: update_user_group(apiuser, usergroupid, group_name=<Optional:''>, description=<Optional:''>, owner=<Optional:None>, active=<Optional:True>)
-
-   Updates the specified `user group` with the details provided.
-
-   This command can only be run using an |authtoken| with admin rights to
-   the specified repository.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param usergroupid: Set the id of the `user group` to update.
-   :type usergroupid: str or int
-   :param group_name: Set the new name the `user group`
-   :type group_name: str
-   :param description: Give a description for the `user group`
-   :type description: str
-   :param owner: Set the owner of the `user group`.
-   :type owner: Optional(str or int)
-   :param active: Set the group as active.
-   :type active: Optional(``True`` | ``False``)
-
-   Example output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : {
-       "msg": 'updated user group ID:<user group id> <user group name>',
-       "user_group": <user_group_object>
-     }
-     error :  null
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : null
-     error :  {
-       "failed to update user group `<user group name>`"
-     }
-
-
-delete_user_group
------------------
-
-.. py:function:: delete_user_group(apiuser, usergroupid)
-
-   Deletes the specified `user group`.
-
-   This command can only be run using an |authtoken| with admin rights to
-   the specified repository.
-
-   This command takes the following options:
-
-   :param apiuser: filled automatically from apikey
-   :type apiuser: AuthUser
-   :param usergroupid:
-   :type usergroupid: int
-
-   Example output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : {
-       "msg": "deleted user group ID:<user_group_id> <user_group_name>"
-     }
-     error :  null
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : null
-     error :  {
-       "failed to delete user group ID:<user_group_id> <user_group_name>"
-       or
-       "RepoGroup assigned to <repo_groups_list>"
-     }
-
-
-add_user_to_user_group
-----------------------
-
-.. py:function:: add_user_to_user_group(apiuser, usergroupid, userid)
-
-   Adds a user to a `user group`. If the user already exists in the group
-   this command will return false.
-
-   This command can only be run using an |authtoken| with admin rights to
-   the specified user group.
-
-   This command takes the following options:
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param usergroupid: Set the name of the `user group` to which a
-       user will be added.
-   :type usergroupid: int
-   :param userid: Set the `user_id` of the user to add to the group.
-   :type userid: int
-
-   Example output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : {
-         "success": True|False # depends on if member is in group
-         "msg": "added member `<username>` to user group `<groupname>` |
-                 User is already in that group"
-
-     }
-     error :  null
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : null
-     error :  {
-       "failed to add member to user group `<user_group_name>`"
-     }
-
-
-remove_user_from_user_group
----------------------------
-
-.. py:function:: remove_user_from_user_group(apiuser, usergroupid, userid)
-
-   Removes a user from a user group.
-
-   * If the specified user is not in the group, this command will return
-     `false`.
-
-   This command can only be run using an |authtoken| with admin rights to
-   the specified user group.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param usergroupid: Sets the user group name.
-   :type usergroupid: str or int
-   :param userid: The user you wish to remove from |RCE|.
-   :type userid: str or int
-
-   Example output:
-
-   .. code-block:: bash
-
-       id : <id_given_in_input>
-       result: {
-                 "success":  True|False,  # depends on if member is in group
-                 "msg": "removed member <username> from user group <groupname> |
-                         User wasn't in group"
-               }
-       error:  null
-
-
-grant_user_permission_to_user_group
------------------------------------
-
-.. py:function:: grant_user_permission_to_user_group(apiuser, usergroupid, userid, perm)
-
-   Set permissions for a user in a user group.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param usergroupid: Set the user group to edit permissions on.
-   :type usergroupid: str or int
-   :param userid: Set the user from whom you wish to set permissions.
-   :type userid: str
-   :param perm: (usergroup.(none|read|write|admin))
-   :type perm: str
-
-   Example output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : {
-       "msg": "Granted perm: `<perm_name>` for user: `<username>` in user group: `<user_group_name>`",
-       "success": true
-     }
-     error :  null
-
-
-revoke_user_permission_from_user_group
---------------------------------------
-
-.. py:function:: revoke_user_permission_from_user_group(apiuser, usergroupid, userid)
-
-   Revoke a users permissions in a user group.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param usergroupid: Set the user group from which to revoke the user
-       permissions.
-   :type: usergroupid: str or int
-   :param userid: Set the userid of the user whose permissions will be
-       revoked.
-   :type userid: str
-
-   Example output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : {
-       "msg": "Revoked perm for user: `<username>` in user group: `<user_group_name>`",
-       "success": true
-     }
-     error :  null
-
-
-grant_user_group_permission_to_user_group
------------------------------------------
-
-.. py:function:: grant_user_group_permission_to_user_group(apiuser, usergroupid, sourceusergroupid, perm)
-
-   Give one user group permissions to another user group.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param usergroupid: Set the user group on which to edit permissions.
-   :type usergroupid: str or int
-   :param sourceusergroupid: Set the source user group to which
-       access/permissions will be granted.
-   :type sourceusergroupid: str or int
-   :param perm: (usergroup.(none|read|write|admin))
-   :type perm: str
-
-   Example output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : {
-       "msg": "Granted perm: `<perm_name>` for user group: `<source_user_group_name>` in user group: `<user_group_name>`",
-       "success": true
-     }
-     error :  null
-
-
-revoke_user_group_permission_from_user_group
---------------------------------------------
-
-.. py:function:: revoke_user_group_permission_from_user_group(apiuser, usergroupid, sourceusergroupid)
-
-   Revoke the permissions that one user group has to another.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param usergroupid: Set the user group on which to edit permissions.
-   :type usergroupid: str or int
-   :param sourceusergroupid: Set the user group from which permissions
-       are revoked.
-   :type sourceusergroupid: str or int
-
-   Example output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : {
-       "msg": "Revoked perm for user group: `<user_group_name>` in user group: `<target_user_group_name>`",
-       "success": true
-     }
-     error :  null
-
-
-get_pull_request
-----------------
-
-.. py:function:: get_pull_request(apiuser, repoid, pullrequestid)
-
-   Get a pull request based on the given ID.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: Repository name or repository ID from where the pull
-       request was opened.
-   :type repoid: str or int
-   :param pullrequestid: ID of the requested pull request.
-   :type pullrequestid: int
-
-   Example output:
-
-   .. code-block:: bash
-
-     "id": <id_given_in_input>,
-     "result":
-       {
-           "pull_request_id":   "<pull_request_id>",
-           "url":               "<url>",
-           "title":             "<title>",
-           "description":       "<description>",
-           "status" :           "<status>",
-           "created_on":        "<date_time_created>",
-           "updated_on":        "<date_time_updated>",
-           "commit_ids":        [
-                                    ...
-                                    "<commit_id>",
-                                    "<commit_id>",
-                                    ...
-                                ],
-           "review_status":    "<review_status>",
-           "mergeable":         {
-                                    "status":  "<bool>",
-                                    "message": "<message>",
-                                },
-           "source":            {
-                                    "clone_url":     "<clone_url>",
-                                    "repository":    "<repository_name>",
-                                    "reference":
-                                    {
-                                        "name":      "<name>",
-                                        "type":      "<type>",
-                                        "commit_id": "<commit_id>",
-                                    }
-                                },
-           "target":            {
-                                    "clone_url":   "<clone_url>",
-                                    "repository":    "<repository_name>",
-                                    "reference":
-                                    {
-                                        "name":      "<name>",
-                                        "type":      "<type>",
-                                        "commit_id": "<commit_id>",
-                                    }
-                                },
-          "author":             <user_obj>,
-          "reviewers":          [
-                                    ...
-                                    {
-                                       "user":          "<user_obj>",
-                                       "review_status": "<review_status>",
-                                    }
-                                    ...
-                                ]
-       },
-      "error": null
-
-
-get_pull_requests
------------------
-
-.. py:function:: get_pull_requests(apiuser, repoid, status=<Optional:'new'>)
-
-   Get all pull requests from the repository specified in `repoid`.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: Repository name or repository ID.
-   :type repoid: str or int
-   :param status: Only return pull requests with the specified status.
-       Valid options are.
-       * ``new`` (default)
-       * ``open``
-       * ``closed``
-   :type status: str
-
-   Example output:
-
-   .. code-block:: bash
-
-     "id": <id_given_in_input>,
-     "result":
-       [
-           ...
-           {
-               "pull_request_id":   "<pull_request_id>",
-               "url":               "<url>",
-               "title" :            "<title>",
-               "description":       "<description>",
-               "status":            "<status>",
-               "created_on":        "<date_time_created>",
-               "updated_on":        "<date_time_updated>",
-               "commit_ids":        [
-                                        ...
-                                        "<commit_id>",
-                                        "<commit_id>",
-                                        ...
-                                    ],
-               "review_status":    "<review_status>",
-               "mergeable":         {
-                                       "status":      "<bool>",
-                                       "message:      "<message>",
-                                    },
-               "source":            {
-                                        "clone_url":     "<clone_url>",
-                                        "reference":
-                                        {
-                                            "name":      "<name>",
-                                            "type":      "<type>",
-                                            "commit_id": "<commit_id>",
-                                        }
-                                    },
-               "target":            {
-                                        "clone_url":   "<clone_url>",
-                                        "reference":
-                                        {
-                                            "name":      "<name>",
-                                            "type":      "<type>",
-                                            "commit_id": "<commit_id>",
-                                        }
-                                    },
-              "author":             <user_obj>,
-              "reviewers":          [
-                                        ...
-                                        {
-                                           "user":          "<user_obj>",
-                                           "review_status": "<review_status>",
-                                        }
-                                        ...
-                                    ]
-           }
-           ...
-       ],
-     "error": null
-
-
-merge_pull_request
-------------------
-
-.. py:function:: merge_pull_request(apiuser, repoid, pullrequestid, userid=<Optional:<OptionalAttr:apiuser>>)
-
-   Merge the pull request specified by `pullrequestid` into its target
-   repository.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: The Repository name or repository ID of the
-       target repository to which the |pr| is to be merged.
-   :type repoid: str or int
-   :param pullrequestid: ID of the pull request which shall be merged.
-   :type pullrequestid: int
-   :param userid: Merge the pull request as this user.
-   :type userid: Optional(str or int)
-
-   Example output:
-
-   .. code-block:: bash
-
-     "id": <id_given_in_input>,
-     "result":
-       {
-           "executed":         "<bool>",
-           "failure_reason":   "<int>",
-           "merge_commit_id":  "<merge_commit_id>",
-           "possible":         "<bool>"
-       },
-     "error": null
-
-
-close_pull_request
-------------------
-
-.. py:function:: close_pull_request(apiuser, repoid, pullrequestid, userid=<Optional:<OptionalAttr:apiuser>>)
-
-   Close the pull request specified by `pullrequestid`.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: Repository name or repository ID to which the pull
-       request belongs.
-   :type repoid: str or int
-   :param pullrequestid: ID of the pull request to be closed.
-   :type pullrequestid: int
-   :param userid: Close the pull request as this user.
-   :type userid: Optional(str or int)
-
-   Example output:
-
-   .. code-block:: bash
-
-     "id": <id_given_in_input>,
-     "result":
-       {
-           "pull_request_id":  "<int>",
-           "closed":           "<bool>"
-       },
-     "error": null
-
-
-comment_pull_request
---------------------
-
-.. py:function:: comment_pull_request(apiuser, repoid, pullrequestid, message=<Optional:None>, status=<Optional:None>, userid=<Optional:<OptionalAttr:apiuser>>)
+.. toctree::
 
-   Comment on the pull request specified with the `pullrequestid`,
-   in the |repo| specified by the `repoid`, and optionally change the
-   review status.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: The repository name or repository ID.
-   :type repoid: str or int
-   :param pullrequestid: The pull request ID.
-   :type pullrequestid: int
-   :param message: The text content of the comment.
-   :type message: str
-   :param status: (**Optional**) Set the approval status of the pull
-       request. Valid options are:
-       * not_reviewed
-       * approved
-       * rejected
-       * under_review
-   :type status: str
-   :param userid: Comment on the pull request as this user
-   :type userid: Optional(str or int)
-
-   Example output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result :
-       {
-           "pull_request_id":  "<Integer>",
-           "comment_id":       "<Integer>"
-       }
-     error :  null
-
-
-create_pull_request
--------------------
-
-.. py:function:: create_pull_request(apiuser, source_repo, target_repo, source_ref, target_ref, title, description=<Optional:''>, reviewers=<Optional:None>)
-
-   Creates a new pull request.
-
-   Accepts refs in the following formats:
-
-       * branch:<branch_name>:<sha>
-       * branch:<branch_name>
-       * bookmark:<bookmark_name>:<sha> (Mercurial only)
-       * bookmark:<bookmark_name> (Mercurial only)
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param source_repo: Set the source repository name.
-   :type source_repo: str
-   :param target_repo: Set the target repository name.
-   :type target_repo: str
-   :param source_ref: Set the source ref name.
-   :type source_ref: str
-   :param target_ref: Set the target ref name.
-   :type target_ref: str
-   :param title: Set the pull request title.
-   :type title: str
-   :param description: Set the pull request description.
-   :type description: Optional(str)
-   :param reviewers: Set the new pull request reviewers list.
-   :type reviewers: Optional(list)
-
-
-update_pull_request
--------------------
-
-.. py:function:: update_pull_request(apiuser, repoid, pullrequestid, title=<Optional:''>, description=<Optional:''>, reviewers=<Optional:None>, update_commits=<Optional:None>, close_pull_request=<Optional:None>)
-
-   Updates a pull request.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: The repository name or repository ID.
-   :type repoid: str or int
-   :param pullrequestid: The pull request ID.
-   :type pullrequestid: int
-   :param title: Set the pull request title.
-   :type title: str
-   :param description: Update pull request description.
-   :type description: Optional(str)
-   :param reviewers: Update pull request reviewers list with new value.
-   :type reviewers: Optional(list)
-   :param update_commits: Trigger update of commits for this pull request
-   :type: update_commits: Optional(bool)
-   :param close_pull_request: Close this pull request with rejected state
-   :type: close_pull_request: Optional(bool)
-
-   Example output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result :
-       {
-           "msg": "Updated pull request `63`",
-           "pull_request": <pull_request_object>,
-           "updated_reviewers": {
-             "added": [
-               "username"
-             ],
-             "removed": []
-           },
-           "updated_commits": {
-             "added": [
-               "<sha1_hash>"
-             ],
-             "common": [
-               "<sha1_hash>",
-               "<sha1_hash>",
-             ],
-             "removed": []
-           }
-       }
-     error :  null
-
-
-get_repo
---------
-
-.. py:function:: get_repo(apiuser, repoid, cache=<Optional:True>)
-
-   Gets an existing repository by its name or repository_id.
-
-   The members section so the output returns users groups or users
-   associated with that repository.
-
-   This command can only be run using an |authtoken| with admin rights,
-   or users with at least read rights to the |repo|.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: The repository name or repository id.
-   :type repoid: str or int
-   :param cache: use the cached value for last changeset
-   :type: cache: Optional(bool)
-
-   Example output:
-
-   .. code-block:: bash
-
-       {
-         "error": null,
-         "id": <repo_id>,
-         "result": {
-           "clone_uri": null,
-           "created_on": "timestamp",
-           "description": "repo description",
-           "enable_downloads": false,
-           "enable_locking": false,
-           "enable_statistics": false,
-           "followers": [
-             {
-               "active": true,
-               "admin": false,
-               "api_key": "****************************************",
-               "api_keys": [
-                 "****************************************"
-               ],
-               "email": "[e-mail]",
-               "emails": [
-                 "[e-mail]"
-               ],
-               "extern_name": "rhodecode",
-               "extern_type": "rhodecode",
-               "firstname": "username",
-               "ip_addresses": [],
-               "language": null,
-               "last_login": "2015-09-16T17:16:35.854",
-               "lastname": "surname",
-               "user_id": <user_id>,
-               "username": "name"
-             }
-           ],
-           "fork_of": "parent-repo",
-           "landing_rev": [
-             "rev",
-             "tip"
-           ],
-           "last_changeset": {
-             "author": "User <[e-mail]>",
-             "branch": "default",
-             "date": "timestamp",
-             "message": "last commit message",
-             "parents": [
-               {
-                 "raw_id": "commit-id"
-               }
-             ],
-             "raw_id": "commit-id",
-             "revision": <revision number>,
-             "short_id": "short id"
-           },
-           "lock_reason": null,
-           "locked_by": null,
-           "locked_date": null,
-           "members": [
-             {
-               "name": "super-admin-name",
-               "origin": "super-admin",
-               "permission": "repository.admin",
-               "type": "user"
-             },
-             {
-               "name": "owner-name",
-               "origin": "owner",
-               "permission": "repository.admin",
-               "type": "user"
-             },
-             {
-               "name": "user-group-name",
-               "origin": "permission",
-               "permission": "repository.write",
-               "type": "user_group"
-             }
-           ],
-           "owner": "owner-name",
-           "permissions": [
-             {
-               "name": "super-admin-name",
-               "origin": "super-admin",
-               "permission": "repository.admin",
-               "type": "user"
-             },
-             {
-               "name": "owner-name",
-               "origin": "owner",
-               "permission": "repository.admin",
-               "type": "user"
-             },
-             {
-               "name": "user-group-name",
-               "origin": "permission",
-               "permission": "repository.write",
-               "type": "user_group"
-             }
-           ],
-           "private": true,
-           "repo_id": 676,
-           "repo_name": "user-group/repo-name",
-           "repo_type": "hg"
-         }
-       }
-
-
-get_repos
----------
-
-.. py:function:: get_repos(apiuser)
-
-   Lists all existing repositories.
-
-   This command can only be run using an |authtoken| with admin rights,
-   or users with at least read rights to |repos|.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-
-   Example output:
-
-   .. code-block:: bash
-
-       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_changeset
-------------------
-
-.. py:function:: get_repo_changeset(apiuser, repoid, revision, details=<Optional:'basic'>)
-
-   Returns information about a changeset.
-
-   Additionally parameters define the amount of details returned by
-   this function.
-
-   This command can only be run using an |authtoken| with admin rights,
-   or users with at least read rights to the |repo|.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: The repository name or repository id
-   :type repoid: str or int
-   :param revision: revision for which listing should be done
-   :type revision: str
-   :param details: details can be 'basic|extended|full' full gives diff
-       info details like the diff itself, and number of changed files etc.
-   :type details: Optional(str)
-
-
-get_repo_changesets
--------------------
-
-.. py:function:: get_repo_changesets(apiuser, repoid, start_rev, limit, details=<Optional:'basic'>)
-
-   Returns a set of changesets limited by the number of commits starting
-   from the `start_rev` option.
-
-   Additional parameters define the amount of details returned by this
-   function.
-
-   This command can only be run using an |authtoken| with admin rights,
-   or users with at least read rights to |repos|.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: The repository name or repository ID.
-   :type repoid: str or int
-   :param start_rev: The starting revision from where to get changesets.
-   :type start_rev: str
-   :param limit: Limit the number of changesets to this amount
-   :type limit: str or int
-   :param details: Set the level of detail returned. Valid option are:
-       ``basic``, ``extended`` and ``full``.
-   :type details: Optional(str)
-
-   .. note::
-
-      Setting the parameter `details` to the value ``full`` is extensive
-      and returns details like the diff itself, and the number
-      of changed files.
-
-
-get_repo_nodes
---------------
-
-.. py:function:: get_repo_nodes(apiuser, repoid, revision, root_path, ret_type=<Optional:'all'>, details=<Optional:'basic'>)
-
-   Returns a list of nodes and 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 only be run using an |authtoken| with admin rights,
-   or users with at least read rights to |repos|.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: The repository name or repository ID.
-   :type repoid: str or int
-   :param revision: The revision for which listing should be done.
-   :type revision: str
-   :param root_path: The path from which to start displaying.
-   :type root_path: str
-   :param ret_type: Set the return type. Valid options are
-       ``all`` (default), ``files`` and ``dirs``.
-   :type ret_type: Optional(str)
-   :param details: Returns extended information about nodes, such as
-       md5, binary, and or content.  The valid options are ``basic`` and
-       ``full``.
-   :type details: Optional(str)
-
-   Example output:
-
-   .. code-block:: bash
-
-       id : <id_given_in_input>
-       result: [
-                 {
-                   "name" : "<name>"
-                   "type" : "<type>",
-                   "binary": "<true|false>" (only in extended mode)
-                   "md5"  : "<md5 of file content>" (only in extended mode)
-                 },
-                 ...
-               ]
-       error:  null
-
-
-create_repo
------------
-
-.. py:function:: create_repo(apiuser, repo_name, repo_type, owner=<Optional:<OptionalAttr:apiuser>>, description=<Optional:''>, private=<Optional:False>, clone_uri=<Optional:None>, landing_rev=<Optional:'rev:tip'>, enable_statistics=<Optional:False>, enable_locking=<Optional:False>, enable_downloads=<Optional:False>, copy_permissions=<Optional:False>)
-
-   Creates a repository.
-
-   * If the repository name contains "/", all the required repository
-     groups will be created.
-
-     For example "foo/bar/baz" will create |repo| groups "foo" and "bar"
-     (with "foo" as parent). It will also create the "baz" repository
-     with "bar" as |repo| group.
-
-   This command can only be run using an |authtoken| with at least
-   write permissions to the |repo|.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repo_name: Set the repository name.
-   :type repo_name: str
-   :param repo_type: Set the repository type; 'hg','git', or 'svn'.
-   :type repo_type: str
-   :param owner: user_id or username
-   :type owner: Optional(str)
-   :param description: Set the repository description.
-   :type description: Optional(str)
-   :param private:
-   :type private: bool
-   :param clone_uri:
-   :type clone_uri: str
-   :param landing_rev: <rev_type>:<rev>
-   :type landing_rev: str
-   :param enable_locking:
-   :type enable_locking: bool
-   :param enable_downloads:
-   :type enable_downloads: bool
-   :param enable_statistics:
-   :type enable_statistics: bool
-   :param copy_permissions: Copy permission from group in which the
-       repository is being created.
-   :type copy_permissions: bool
-
-
-   Example output:
-
-   .. code-block:: bash
-
-       id : <id_given_in_input>
-       result: {
-                 "msg": "Created new repository `<reponame>`",
-                 "success": true,
-                 "task": "<celery task id or None if done sync>"
-               }
-       error:  null
-
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : null
-     error :  {
-        'failed to create repository `<repo_name>`
-     }
-
-
-add_field_to_repo
------------------
-
-.. py:function:: add_field_to_repo(apiuser, repoid, key, label=<Optional:''>, description=<Optional:''>)
-
-   Adds an extra field to a repository.
-
-   This command can only be run using an |authtoken| with at least
-   write permissions to the |repo|.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: Set the repository name or repository id.
-   :type repoid: str or int
-   :param key: Create a unique field key for this repository.
-   :type key: str
-   :param label:
-   :type label: Optional(str)
-   :param description:
-   :type description: Optional(str)
-
-
-remove_field_from_repo
-----------------------
-
-.. py:function:: remove_field_from_repo(apiuser, repoid, key)
-
-   Removes an extra field from a repository.
-
-   This command can only be run using an |authtoken| with at least
-   write permissions to the |repo|.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: Set the repository name or repository ID.
-   :type repoid: str or int
-   :param key: Set the unique field key for this repository.
-   :type key: str
-
-
-update_repo
------------
-
-.. py:function:: update_repo(apiuser, repoid, name=<Optional:None>, owner=<Optional:<OptionalAttr:apiuser>>, group=<Optional:None>, fork_of=<Optional:None>, description=<Optional:''>, private=<Optional:False>, clone_uri=<Optional:None>, landing_rev=<Optional:'rev:tip'>, enable_statistics=<Optional:False>, enable_locking=<Optional:False>, enable_downloads=<Optional:False>, fields=<Optional:''>)
-
-   Updates a repository with the given information.
-
-   This command can only be run using an |authtoken| with at least
-   write permissions to the |repo|.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: repository name or repository ID.
-   :type repoid: str or int
-   :param name: Update the |repo| name.
-   :type name: str
-   :param owner: Set the |repo| owner.
-   :type owner: str
-   :param group: Set the |repo| group the |repo| belongs to.
-   :type group: str
-   :param fork_of: Set the master |repo| name.
-   :type fork_of: str
-   :param description: Update the |repo| description.
-   :type description: str
-   :param private: Set the |repo| as private. (True | False)
-   :type private: bool
-   :param clone_uri: Update the |repo| clone URI.
-   :type clone_uri: str
-   :param landing_rev: Set the |repo| landing revision. Default is
-       ``tip``.
-   :type landing_rev: str
-   :param enable_statistics: Enable statistics on the |repo|,
-       (True | False).
-   :type enable_statistics: bool
-   :param enable_locking: Enable |repo| locking.
-   :type enable_locking: bool
-   :param enable_downloads: Enable downloads from the |repo|,
-       (True | False).
-   :type enable_downloads: bool
-   :param fields: Add extra fields to the |repo|. Use the following
-       example format: ``field_key=field_val,field_key2=fieldval2``.
-       Escape ', ' with \,
-   :type fields: str
-
-
-fork_repo
----------
-
-.. py:function:: fork_repo(apiuser, repoid, fork_name, owner=<Optional:<OptionalAttr:apiuser>>, description=<Optional:''>, copy_permissions=<Optional:False>, private=<Optional:False>, landing_rev=<Optional:'rev:tip'>)
-
-   Creates a fork of the specified |repo|.
-
-   * If using |RCE| with Celery this will immediately return a success
-     message, even though the fork will be created asynchronously.
-
-   This command can only be run using an |authtoken| with fork
-   permissions on the |repo|.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: Set repository name or repository ID.
-   :type repoid: str or int
-   :param fork_name: Set the fork name.
-   :type fork_name: str
-   :param owner: Set the fork owner.
-   :type owner: str
-   :param description: Set the fork descripton.
-   :type description: str
-   :param copy_permissions: Copy permissions from parent |repo|. The
-       default is False.
-   :type copy_permissions: bool
-   :param private: Make the fork private. The default is False.
-   :type private: bool
-   :param landing_rev: Set the landing revision. The default is tip.
-
-   Example output:
-
-   .. code-block:: bash
-
-       id : <id_for_response>
-       api_key : "<api_key>"
-       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>"
-                 }
-
-   Example error output:
-
-   .. code-block:: bash
-
-       id : <id_given_in_input>
-       result: {
-                 "msg": "Created fork of `<reponame>` as `<forkname>`",
-                 "success": true,
-                 "task": "<celery task id or None if done sync>"
-               }
-       error:  null
-
-
-delete_repo
------------
-
-.. py:function:: delete_repo(apiuser, repoid, forks=<Optional:''>)
-
-   Deletes a repository.
-
-   * When the `forks` parameter is set it's possible to detach or delete
-     forks of deleted repository.
-
-   This command can only be run using an |authtoken| with admin
-   permissions on the |repo|.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: Set the repository name or repository ID.
-   :type repoid: str or int
-   :param forks: Set to `detach` or `delete` forks from the |repo|.
-   :type forks: Optional(str)
-
-   Example error output:
-
-   .. code-block:: bash
-
-       id : <id_given_in_input>
-       result: {
-                 "msg": "Deleted repository `<reponame>`",
-                 "success": true
-               }
-       error:  null
-
-
-comment_commit
---------------
-
-.. py:function:: comment_commit(apiuser, repoid, commit_id, message, userid=<Optional:<OptionalAttr:apiuser>>, status=<Optional:None>)
-
-   Set a commit comment, and optionally change the status of the commit.
-   This command can be executed only using api_key belonging to user
-   with admin rights, or repository administrator.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: Set the repository name or repository ID.
-   :type repoid: str or int
-   :param commit_id: Specify the commit_id for which to set a comment.
-   :type commit_id: str
-   :param message: The comment text.
-   :type message: str
-   :param userid: Set the user name of the comment creator.
-   :type userid: Optional(str or int)
-   :param status: status, one of 'not_reviewed', 'approved', 'rejected',
-      'under_review'
-   :type status: str
-
-   Example error output:
-
-   .. code-block:: json
-
-       {
-           "id" : <id_given_in_input>,
-           "result" : {
-               "msg": "Commented on commit `<commit_id>` for repository `<repoid>`",
-               "status_change": null or <status>,
-               "success": true
-           },
-           "error" :  null
-       }
-
-
-changeset_comment
------------------
-
-.. py:function:: changeset_comment(apiuser, repoid, revision, message, userid=<Optional:<OptionalAttr:apiuser>>, status=<Optional:None>)
-
-   .. deprecated:: 3.4.0
-
-      Please use method `comment_commit` instead.
-
-
-   Set a changeset comment, and optionally change the status of the
-   changeset.
-
-   This command can only be run using an |authtoken| with admin
-   permissions on the |repo|.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: Set the repository name or repository ID.
-   :type repoid: str or int
-   :param revision: Specify the revision for which to set a comment.
-   :type revision: str
-   :param message: The comment text.
-   :type message: str
-   :param userid: Set the user name of the comment creator.
-   :type userid: Optional(str or int)
-   :param status: Set the comment status. The following are valid options:
-       * not_reviewed
-       * approved
-       * rejected
-       * under_review
-   :type status: str
-
-   Example error output:
-
-   .. code-block:: json
-
-       {
-           "id" : <id_given_in_input>,
-           "result" : {
-               "msg": "Commented on commit `<revision>` for repository `<repoid>`",
-               "status_change": null or <status>,
-               "success": true
-           },
-           "error" : null
-       }
-
-
-grant_user_permission
----------------------
-
-.. py:function:: grant_user_permission(apiuser, repoid, userid, perm)
-
-   Grant permissions for the specified user on the given repository,
-   or update existing permissions if found.
-
-   This command can only be run using an |authtoken| with admin
-   permissions on the |repo|.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: Set the repository name or repository ID.
-   :type repoid: str or int
-   :param userid: Set the user name.
-   :type userid: str
-   :param perm: Set the user permissions, using the following format
-       ``(repository.(none|read|write|admin))``
-   :type perm: str
-
-   Example output:
-
-   .. code-block:: bash
-
-       id : <id_given_in_input>
-       result: {
-                 "msg" : "Granted perm: `<perm>` for user: `<username>` in repo: `<reponame>`",
-                 "success": true
-               }
-       error:  null
-
-
-revoke_user_permission
-----------------------
-
-.. py:function:: revoke_user_permission(apiuser, repoid, userid)
-
-   Revoke permission for a user on the specified repository.
-
-   This command can only be run using an |authtoken| with admin
-   permissions on the |repo|.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: Set the repository name or repository ID.
-   :type repoid: str or int
-   :param userid: Set the user name of revoked user.
-   :type userid: str or int
-
-   Example error output:
-
-   .. code-block:: bash
-
-       id : <id_given_in_input>
-       result: {
-                 "msg" : "Revoked perm for user: `<username>` in repo: `<reponame>`",
-                 "success": true
-               }
-       error:  null
-
-
-grant_user_group_permission
----------------------------
-
-.. py:function:: grant_user_group_permission(apiuser, repoid, usergroupid, perm)
-
-   Grant permission for a user group on the specified repository,
-   or update existing permissions.
-
-   This command can only be run using an |authtoken| with admin
-   permissions on the |repo|.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: Set the repository name or repository ID.
-   :type repoid: str or int
-   :param usergroupid: Specify the ID of the user group.
-   :type usergroupid: str or int
-   :param perm: Set the user group permissions using the following
-       format: (repository.(none|read|write|admin))
-   :type perm: str
-
-   Example output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : {
-       "msg" : "Granted perm: `<perm>` for group: `<usersgroupname>` in repo: `<reponame>`",
-       "success": true
-
-     }
-     error :  null
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : null
-     error :  {
-       "failed to edit permission for user group: `<usergroup>` in repo `<repo>`'
-     }
-
-
-revoke_user_group_permission
-----------------------------
-
-.. py:function:: revoke_user_group_permission(apiuser, repoid, usergroupid)
-
-   Revoke the permissions of a user group on a given repository.
-
-   This command can only be run using an |authtoken| with admin
-   permissions on the |repo|.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repoid: Set the repository name or repository ID.
-   :type repoid: str or int
-   :param usergroupid: Specify the user group ID.
-   :type usergroupid: str or int
-
-   Example output:
-
-   .. code-block:: bash
-
-       id : <id_given_in_input>
-       result: {
-                 "msg" : "Revoked perm for group: `<usersgroupname>` in repo: `<reponame>`",
-                 "success": true
-               }
-       error:  null
-
-
-get_repo_group
---------------
-
-.. py:function:: get_repo_group(apiuser, repogroupid)
-
-   Return the specified |repo| group, along with permissions,
-   and repositories inside the group
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repogroupid: Specify the name of ID of the repository group.
-   :type repogroupid: str or int
-
-
-   Example output:
-
-   .. code-block:: bash
-
-       {
-         "error": null,
-         "id": repo-group-id,
-         "result": {
-           "group_description": "repo group description",
-           "group_id": 14,
-           "group_name": "group name",
-           "members": [
-             {
-               "name": "super-admin-username",
-               "origin": "super-admin",
-               "permission": "group.admin",
-               "type": "user"
-             },
-             {
-               "name": "owner-name",
-               "origin": "owner",
-               "permission": "group.admin",
-               "type": "user"
-             },
-             {
-               "name": "user-group-name",
-               "origin": "permission",
-               "permission": "group.write",
-               "type": "user_group"
-             }
-           ],
-           "owner": "owner-name",
-           "parent_group": null,
-           "repositories": [ repo-list ]
-         }
-       }
-
-
-get_repo_groups
----------------
-
-.. py:function:: get_repo_groups(apiuser)
-
-   Returns all repository groups.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-
-
-create_repo_group
------------------
-
-.. py:function:: create_repo_group(apiuser, group_name, description=<Optional:''>, owner=<Optional:<OptionalAttr:apiuser>>, copy_permissions=<Optional:False>)
-
-   Creates a repository group.
-
-   * If the repository group name contains "/", all the required repository
-     groups will be created.
-
-     For example "foo/bar/baz" will create |repo| groups "foo" and "bar"
-     (with "foo" as parent). It will also create the "baz" repository
-     with "bar" as |repo| group.
-
-   This command can only be run using an |authtoken| with admin
-   permissions.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param group_name: Set the repository group name.
-   :type group_name: str
-   :param description: Set the |repo| group description.
-   :type description: str
-   :param owner: Set the |repo| group owner.
-   :type owner: str
-   :param copy_permissions:
-   :type copy_permissions:
-
-   Example output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : {
-         "msg": "Created new repo group `<repo_group_name>`"
-         "repo_group": <repogroup_object>
-     }
-     error :  null
-
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : null
-     error :  {
-       failed to create repo group `<repogroupid>`
-     }
-
-
-update_repo_group
------------------
-
-.. py:function:: update_repo_group(apiuser, repogroupid, group_name=<Optional:''>, description=<Optional:''>, owner=<Optional:<OptionalAttr:apiuser>>, parent=<Optional:None>, enable_locking=<Optional:False>)
-
-   Updates repository group with the details given.
-
-   This command can only be run using an |authtoken| with admin
-   permissions.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repogroupid: Set the ID of repository group.
-   :type repogroupid: str or int
-   :param group_name: Set the name of the |repo| group.
-   :type group_name: str
-   :param description: Set a description for the group.
-   :type description: str
-   :param owner: Set the |repo| group owner.
-   :type owner: str
-   :param parent: Set the |repo| group parent.
-   :type parent: str or int
-   :param enable_locking: Enable |repo| locking. The default is false.
-   :type enable_locking: bool
-
-
-delete_repo_group
------------------
-
-.. py:function:: delete_repo_group(apiuser, repogroupid)
-
-   Deletes a |repo| group.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repogroupid: Set the name or ID of repository group to be
-       deleted.
-   :type repogroupid: str or int
-
-   Example output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : {
-       'msg': 'deleted repo group ID:<repogroupid> <repogroupname>
-       'repo_group': null
-     }
-     error :  null
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : null
-     error :  {
-       "failed to delete repo group ID:<repogroupid> <repogroupname>"
-     }
-
-
-grant_user_permission_to_repo_group
------------------------------------
-
-.. py:function:: grant_user_permission_to_repo_group(apiuser, repogroupid, userid, perm, apply_to_children=<Optional:'none'>)
-
-   Grant permission for a user on the given repository group, or update
-   existing permissions if found.
-
-   This command can only be run using an |authtoken| with admin
-   permissions.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repogroupid: Set the name or ID of repository group.
-   :type repogroupid: str or int
-   :param userid: Set the user name.
-   :type userid: str
-   :param perm: (group.(none|read|write|admin))
-   :type perm: str
-   :param apply_to_children: 'none', 'repos', 'groups', 'all'
-   :type apply_to_children: str
-
-   Example output:
-
-   .. code-block:: bash
-
-       id : <id_given_in_input>
-       result: {
-                 "msg" : "Granted perm: `<perm>` (recursive:<apply_to_children>) for user: `<username>` in repo group: `<repo_group_name>`",
-                 "success": true
-               }
-       error:  null
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : null
-     error :  {
-       "failed to edit permission for user: `<userid>` in repo group: `<repo_group_name>`"
-     }
-
-
-revoke_user_permission_from_repo_group
---------------------------------------
-
-.. py:function:: revoke_user_permission_from_repo_group(apiuser, repogroupid, userid, apply_to_children=<Optional:'none'>)
-
-   Revoke permission for a user in a given repository group.
-
-   This command can only be run using an |authtoken| with admin
-   permissions on the |repo| group.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repogroupid: Set the name or ID of the repository group.
-   :type repogroupid: str or int
-   :param userid: Set the user name to revoke.
-   :type userid: str
-   :param apply_to_children: 'none', 'repos', 'groups', 'all'
-   :type apply_to_children: str
-
-   Example output:
-
-   .. code-block:: bash
-
-       id : <id_given_in_input>
-       result: {
-                 "msg" : "Revoked perm (recursive:<apply_to_children>) for user: `<username>` in repo group: `<repo_group_name>`",
-                 "success": true
-               }
-       error:  null
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : null
-     error :  {
-       "failed to edit permission for user: `<userid>` in repo group: `<repo_group_name>`"
-     }
-
-
-grant_user_group_permission_to_repo_group
------------------------------------------
-
-.. py:function:: grant_user_group_permission_to_repo_group(apiuser, repogroupid, usergroupid, perm, apply_to_children=<Optional:'none'>)
-
-   Grant permission for a user group on given repository group, or update
-   existing permissions if found.
-
-   This command can only be run using an |authtoken| with admin
-   permissions on the |repo| group.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repogroupid: Set the name or id of repository group
-   :type repogroupid: str or int
-   :param usergroupid: id of usergroup
-   :type usergroupid: str or int
-   :param perm: (group.(none|read|write|admin))
-   :type perm: str
-   :param apply_to_children: 'none', 'repos', 'groups', 'all'
-   :type apply_to_children: str
-
-   Example output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : {
-       "msg" : "Granted perm: `<perm>` (recursive:<apply_to_children>) for user group: `<usersgroupname>` in repo group: `<repo_group_name>`",
-       "success": true
-
-     }
-     error :  null
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : null
-     error :  {
-       "failed to edit permission for user group: `<usergroup>` in repo group: `<repo_group_name>`"
-     }
-
-
-revoke_user_group_permission_from_repo_group
---------------------------------------------
-
-.. py:function:: revoke_user_group_permission_from_repo_group(apiuser, repogroupid, usergroupid, apply_to_children=<Optional:'none'>)
-
-   Revoke permission for user group on given repository.
-
-   This command can only be run using an |authtoken| with admin
-   permissions on the |repo| group.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param repogroupid: name or id of repository group
-   :type repogroupid: str or int
-   :param usergroupid:
-   :param apply_to_children: 'none', 'repos', 'groups', 'all'
-   :type apply_to_children: str
-
-   Example output:
-
-   .. code-block:: bash
-
-       id : <id_given_in_input>
-       result: {
-                 "msg" : "Revoked perm (recursive:<apply_to_children>) for user group: `<usersgroupname>` in repo group: `<repo_group_name>`",
-                 "success": true
-               }
-       error:  null
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : null
-     error :  {
-       "failed to edit permission for user group: `<usergroup>` in repo group: `<repo_group_name>`"
-     }
-
-
-get_gist
---------
-
-.. py:function:: get_gist(apiuser, gistid, content=<Optional:False>)
-
-   Get the specified gist, based on the gist ID.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param gistid: Set the id of the private or public gist
-   :type gistid: str
-   :param content: Return the gist content. Default is false.
-   :type content: Optional(bool)
-
-
-get_gists
----------
-
-.. py:function:: get_gists(apiuser, userid=<Optional:<OptionalAttr:apiuser>>)
-
-   Get all gists for given user. If userid is empty returned gists
-   are for user who called the api
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param userid: user to get gists for
-   :type userid: Optional(str or int)
-
-
-create_gist
------------
-
-.. py:function:: create_gist(apiuser, files, owner=<Optional:<OptionalAttr:apiuser>>, gist_type=<Optional:u'public'>, lifetime=<Optional:-1>, acl_level=<Optional:u'acl_public'>, description=<Optional:''>)
-
-   Creates a new Gist.
-
-   :param apiuser: This is filled automatically from the |authtoken|.
-   :type apiuser: AuthUser
-   :param files: files to be added to the gist. The data structure has
-       to match the following example::
-
-         {'filename': {'content':'...', 'lexer': null},
-          'filename2': {'content':'...', 'lexer': null}}
-
-   :type files: dict
-   :param owner: Set the gist owner, defaults to api method caller
-   :type owner: Optional(str or int)
-   :param gist_type: type of gist ``public`` or ``private``
-   :type gist_type: Optional(str)
-   :param lifetime: time in minutes of gist lifetime
-   :type lifetime: Optional(int)
-   :param acl_level: acl level for this gist, can be
-       ``acl_public`` or ``acl_private`` If the value is set to
-       ``acl_private`` only logged in users are able to access this gist.
-       If not set it defaults to ``acl_public``.
-   :type acl_level: Optional(str)
-   :param description: gist description
-   :type description: Optional(str)
-
-   Example  output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : {
-       "msg": "created new gist",
-       "gist": {}
-     }
-     error :  null
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : null
-     error :  {
-       "failed to create gist"
-     }
-
-
-delete_gist
------------
-
-.. py:function:: delete_gist(apiuser, gistid)
-
-   Deletes existing gist
-
-   :param apiuser: filled automatically from apikey
-   :type apiuser: AuthUser
-   :param gistid: id of gist to delete
-   :type gistid: str
-
-   Example output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : {
-       "deleted gist ID: <gist_id>",
-       "gist": null
-     }
-     error :  null
-
-   Example error output:
-
-   .. code-block:: bash
-
-     id : <id_given_in_input>
-     result : null
-     error :  {
-       "failed to delete gist ID:<gist_id>"
-     }
-
+   methods/license-methods
+   methods/deprecated-methods
+   methods/gist-methods
+   methods/pull-request-methods
+   methods/repo-methods
+   methods/repo-group-methods
+   methods/server-methods
+   methods/user-methods
+   methods/user-group-methods

docs/code-review/code-review.rst

@@ -1,27 +1,27 b''
 .. _code-review-ref:
 
 Code Review
 ===========
 
 |RCM| provides two ways in which you can review code. You can review |prs| or
 commits. To better understand |prs|, see the :ref:`pull-requests-ref`
 and :ref:`collaborate-ref` sections. For more information about why
 code review matters, see these posts on the topic:
 
 * `Code Review - Fix Bugs Early and Often`_
 * `Code Review - How to Convince a Skeptic`_
 * `Code Review - Learn How NASA Codes`_
 
 You can also use the |RCE| API set up continuous integration servers to leave
 comments from a test suite. See the :ref:`api` and
-:ref:`integrations-ref` sections for examples on how to set this up.
+:ref:`extensions-hooks-ref` sections for examples on how to set this up.
 
 .. toctree::
 
    review-diffs
    approve-changes
    reviewing-best-practices
 
 .. _Code Review - Fix Bugs Early and Often: https://rhodecode.com/blog/code-review-fix-bugs-early-often/
 .. _Code Review - How to Convince a Skeptic: https://rhodecode.com/blog/code-review-convince-skeptic/
 .. _Code Review - Learn How NASA Codes: https://rhodecode.com/blog/code-review-learn-nasa-codes/

docs/common.py

@@ -1,34 +1,36 b''
 # Try and keep this list alphabetical
 # ui is for user interface elements and messages
 # button - that's obvious
 
 rst_epilog = '''
 .. |AE| replace:: Appenlight
 .. |authtoken| replace:: Authentication Token
 .. |authtokens| replace:: **Auth Tokens**
+.. |RCCEshort| replace:: Community
+.. |RCEEshort| replace:: Enterprise
 .. |git| replace:: Git
 .. |hg| replace:: Mercurial
 .. |svn| replace:: Subversion
 .. |LDAP| replace:: LDAP / Active Directory
 .. |os| replace:: operating system
 .. |OS| replace:: Operating System
 .. |PY| replace:: Python
 .. |pr| replace:: pull request
 .. |prs| replace:: pull requests
 .. |psf| replace:: Python Software Foundation
 .. |repo| replace:: repository
 .. |repos| replace:: repositories
 .. |RCI| replace:: RhodeCode Control
 .. |RCC| replace:: RhodeCode Control
 .. |RCV| replace:: RhodeCode Enterprise
 .. |RCM| replace:: RhodeCode Enterprise
 .. |RCE| replace:: RhodeCode Enterprise
 .. |RCCE| replace:: RhodeCode Community
 .. |RCEE| replace:: RhodeCode Enterprise
 .. |RCX| replace:: RhodeCode Extensions
 .. |RCT| replace:: RhodeCode Tools
 .. |RCEBOLD| replace:: **RhodeCode Enterprise**
 .. |RCEITALICS| replace:: `RhodeCode Enterprise`
 .. |RC| replace:: RhodeCode
 .. |RNS| replace:: Release Notes
 '''

docs/contributing/dev-setup.rst

@@ -1,144 +1,157 b''
 .. _dev-setup:
 
 ===================
  Development setup
 ===================
 
 
 RhodeCode Enterprise runs inside a Nix managed environment. This ensures build
 environment dependencies are correctly declared and installed during setup.
 It also enables atomic upgrades, rollbacks, and multiple instances of RhodeCode
 Enterprise running with isolation.
 
 To set up RhodeCode Enterprise inside the Nix environment, use the following steps:
 
 
 
 Setup Nix Package Manager
 -------------------------
 
 To install the Nix Package Manager, please run::
 
    $ curl https://nixos.org/nix/install | sh
 
 or go to https://nixos.org/nix/ and follow the installation instructions.
 Once this is correctly set up on your system, you should be able to use the
 following commands:
 
 * `nix-env`
 
 * `nix-shell`
 
 
 .. tip::
 
    Update your channels frequently by running ``nix-channel --upgrade``.
 
 
 Switch nix to the latest STABLE channel
 ---------------------------------------
 
 run::
 
    nix-channel --add https://nixos.org/channels/nixos-16.03 nixpkgs
 
 Followed by::
 
    nix-channel --update
 
 
 Clone the required repositories
 -------------------------------
 
 After Nix is set up, clone the RhodeCode Enterprise Community Edition and
 RhodeCode VCSServer repositories into the same directory.
 To do this, use the following example::
 
     mkdir rhodecode-develop && cd rhodecode-develop
     hg clone https://code.rhodecode.com/rhodecode-enterprise-ce
     hg clone https://code.rhodecode.com/rhodecode-vcsserver
 
 .. note::
 
    If you cannot clone the repository, please request read permissions
    via [e-mail]
 
 
 
 Enter the Development Shell
 ---------------------------
 
 The final step is to start the development shell. To do this, run the
 following command from inside the cloned repository::
 
    cd ~/rhodecode-enterprise-ce
    nix-shell
 
 .. note::
 
    On the first run, this will take a while to download and optionally compile
    a few things. The following runs will be faster. The development shell works
-   fine on MacOS and Linux platforms.
+   fine on both MacOS and Linux platforms.
 
 
 
 Creating a Development Configuration
 ------------------------------------
 
 To create a development environment for RhodeCode Enterprise,
 use the following steps:
 
 1. Create a copy of `~/rhodecode-enterprise-ce/configs/development.ini`
 2. Adjust the configuration settings to your needs
 
-   .. note::
+.. note::
 
-      It is recommended to use the name `dev.ini`.
+  It is recommended to use the name `dev.ini`.
 
 
 Setup the Development Database
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 To create a development database, use the following example. This is a one
 time operation::
 
     paster setup-rhodecode dev.ini \
         --user=admin --password=secret \
         --email=[e-mail] \
         --repos=~/my_dev_repos
 
 
+Compile CSS and JavaScript
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+To use the application's frontend, you will need to compile the CSS and
+JavaScript with Grunt. This is easily done from within the nix-shell using the
+following command::
+
+    make web-build
+
+You will need to recompile following any changes made to the CSS or JavaScript
+files.
+
+
 Start the Development Server
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-When starting the development server, you should start the vcsserver as a
-separate process. To do this, use one of the following examples:
+From the rhodecode-vcsserver directory, start the development server in another
+nix-shell, using the following command::
 
-1. Set the `start.vcs_server` flag in the ``dev.ini`` file to true. For example:
+      pserve configs/development.ini http_port=9900
 
-   .. code-block:: python
+In the adjacent nix-shell which you created for your development server, you may
+now start CE with the following command::
 
-      ### VCS CONFIG ###
-      ##################
-      vcs.start_server = true
-      vcs.server = localhost:9900
-      vcs.server.log_level = debug
 
-   Then start the server using the following command: ``rcserver dev.ini``
+      rcserver dev.ini
 
-2. Start the development server using the following example::
-
-      rcserver --with-vcsserver dev.ini
+.. note::
 
-3. Start the development server in a different terminal using the following
-   example::
-
-      vcsserver
+  To automatically refresh - and recompile the frontend assets - when changes
+  are made in the source code, you can use the option `--reload`.
 
 
 Run the Environment Tests
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Please make sure that the tests are passing to verify that your environment is
 set up correctly. RhodeCode uses py.test to run tests.
-Please simply run ``make test`` to run the basic test suite.
+While your instance is running, start a new nix-shell and simply run
+``make test`` to run the basic test suite.
+
+
+Need Help?
+^^^^^^^^^^
+
+Join us on Slack via https://rhodecode.com/join or post questions in our
+Community Portal at https://community.rhodecode.com

docs/contributing/overview.rst

@@ -1,111 +1,108 b''
 
 =======================
  Contributing Overview
 =======================
 
 
 RhodeCode Community Edition is an open source code management platform. We
 encourage contributions to our project from the community. This is a basic
 overview of the procedures for adding your contribution to RhodeCode.
 
 
 
 Check the Issue Tracker
 =======================
 
 Make an account at https://issues.rhodecode.com/account/register and browse the
 current tickets for bugs to fix and tasks to do. Have a bug or feature that you
 can't find in the tracker? Create a new issue for it. When you select a ticket,
 make sure to assign it to yourself and mark it "in progress" to avoid duplicated
 work. 
 
 
 
 Sign Up at code.rhodecode.com
 =============================
 
 Make an account at https://code.rhodecode.com/ using an email or your existing
 GitHub, Bitbucket, Google, or Twitter account. Fork the repo you'd like to
 contribute to; we suggest adding your username to the fork name. Clone your fork
 to your computer. We use Mercurial for source control management; see
 https://www.mercurial-scm.org/guide to get started quickly.
 
 
 
 Set Up A Local Instance
 =======================
 
 You will need to set up an instance of RhodeCode CE using VCSServer so that you
 can see your work locally as you make changes. We recommend using Linux for this
 but it can also be built on OSX.
 
 See :doc:`dev-setup` for instructions.
 
 
 
 Code!
 =====
 
 You can now make, see, and test your changes locally. We are always improving to
 keep our code clean and the cost of maintaining it low. This applies in the same
 way for contributions. We run automated checks on our pull requests, and expect
 understandable code. We also aim to provide test coverage for as much of our
 codebase as possible; any new features should be augmented with tests.
 
 Keep in mind that when we accept your contribution, we also take responsibility
 for it; we must understand it to take on that responsibility.
 
 See :doc:`standards` for more detailed information.
 
 
 
 Commit And Push Your Changes
 ============================
 
 We highly recommend making a new bookmark for each feature, bug, or set of
 commits you make so that you can point to it when creating your pull request.
 Please also reference the ticket number in your commit messages. Don't forget to
 push the bookmark!
 
 
 
 Submit a Pull Request
 =====================
 
 Go to your fork, and choose "Create Pull Request" from the Options menu. Use
 your bookmark as the source, and choose someone to review it. Don't worry about
 chosing the right person; we'll assign the best contributor for the job. You'll
 get feedback and an assigned status.
 
 Be prepared to make updates to your pull request after some feedback.
 Collaboration is part of the process and improvements can often be made.
 
 
 
 Sign the Contributor License Agreement
 ======================================
 
 If your contribution is approved, you will need to virtually sign the license
-agreement in order for it to be merged into the project's codebase. You can read
-it on our website here: https://rhodecode.com/static/pdf/RhodeCode-CLA.pdf
+agreement in order for it to be merged into the project's codebase.
 
-To sign, go to code.rhodecode.com
-and clone the CLA repository. Add your name and make a pull request to add it to
-the contributor agreement; this serves as your virtual signature. Once your
-signature is merged, add a link to the relevant commit to your contribution
-pull request.
+You can read it on our website at https://rhodecode.com/rhodecode-cla
+
+To sign electronically, go to https://rhodecode.com/sign-cla
 
 
 
 That's it! We'll take it from there. Thanks for your contribution!
 ------------------------------------------------------------------
 
 .. note:: If you have any questions or comments, feel free to contact us through
           either the community portal(community.rhodecode.com), IRC
           (irc.freenode.net), or Slack (rhodecode.com/join).
 
 
 
 
 
 

docs/default.nix

@@ -1,134 +1,144 b''
 { system ? builtins.currentSystem
 }:
 
 let
 
   pkgs = import <nixpkgs> { inherit system; };
 
   inherit (pkgs) fetchurl fetchgit;
 
   buildPythonPackage = pkgs.python27Packages.buildPythonPackage;
   python = pkgs.python27Packages.python;
 
   Jinja2 = buildPythonPackage rec {
     name = "Jinja2-2.7.3";
     src = fetchurl {
       url = "http://pypi.python.org/packages/source/J/Jinja2/${name}.tar.gz";
       md5 = "b9dffd2f3b43d673802fe857c8445b1a";
     };
     propagatedBuildInputs = [ MarkupSafe ];
   };
 
   MarkupSafe = buildPythonPackage rec {
     name = "MarkupSafe-0.23";
     src = fetchurl {
       url = "https://pypi.python.org/packages/source/M/MarkupSafe/${name}.tar.gz";
       md5 = "f5ab3deee4c37cd6a922fb81e730da6e";
     };
   };
 
   Pygments = buildPythonPackage rec {
-    name = "Pygments-2.0.2";
+    name = "Pygments-2.1.3";
+    doCheck = false;
     src = fetchurl {
-      url = "https://pypi.python.org/packages/source/P/Pygments/${name}.tar.gz";
-      md5 = "238587a1370d62405edabd0794b3ec4a";
+      url = "https://pypi.python.org/packages/b8/67/ab177979be1c81bc99c8d0592ef22d547e70bb4c6815c383286ed5dec504/Pygments-2.1.3.tar.gz";
+      md5 = "ed3fba2467c8afcda4d317e4ef2c6150";
     };
   };
 
   alabaster = buildPythonPackage rec {
     name = "alabaster-0.7.3";
     src = fetchurl {
       url = "https://pypi.python.org/packages/source/a/alabaster/${name}.tar.gz";
       md5 = "67428d1383fd833f1282fed5deba0898";
     };
   };
 
   six = buildPythonPackage rec {
     name = "six-1.9.0";
     src = fetchurl {
       url = "https://pypi.python.org/packages/source/s/six/${name}.tar.gz";
       md5 = "476881ef4012262dfc8adc645ee786c4";
     };
   };
 
   snowballstemmer = buildPythonPackage rec {
     name = "snowballstemmer-1.2.0";
     src = fetchurl {
       url = "https://pypi.python.org/packages/source/s/snowballstemmer/${name}.tar.gz";
       md5 = "51f2ef829db8129dd0f2354f0b209970";
     };
   };
 
   pytz = buildPythonPackage rec {
     name = "pytz-2015.2";
     src = fetchurl {
       url = "https://pypi.python.org/packages/source/p/pytz/${name}.tar.gz";
       md5 = "08440d994cfbbf13d3343362cc3173f7";
     };
   };
 
   babel = buildPythonPackage rec {
     name = "Babel-1.3";
     src = fetchurl {
       url = "https://pypi.python.org/packages/source/B/Babel/${name}.tar.gz";
       md5 = "5264ceb02717843cbc9ffce8e6e06bdb";
     };
     propagatedBuildInputs = [
     pytz
     ];
   };
 
-  Sphinx = buildPythonPackage (rec {
-    name = "Sphinx-1.3.1";
+  imagesize = buildPythonPackage rec {
+    name = "imagesize-0.7.1";
     src = fetchurl {
-      url = "http://pypi.python.org/packages/source/S/Sphinx/${name}.tar.gz";
-      md5 = "8786a194acf9673464c5455b11fd4332";
+      url = "https://pypi.python.org/packages/53/72/6c6f1e787d9cab2cc733cf042f125abec07209a58308831c9f292504e826/${name}.tar.gz";
+      md5 = "976148283286a6ba5f69b0f81aef8052";
+    };
+  };
+
+  Sphinx = buildPythonPackage (rec {
+    name = "Sphinx-1.4.4";
+    src = fetchurl {
+      url = "https://pypi.python.org/packages/20/a2/72f44c84f6c4115e3fef58d36d657ec311d80196eab9fd5ec7bcde76143b/${name}.tar.gz";
+      md5 = "64ce2ec08d37ed56313a98232cbe2aee";
     };
     propagatedBuildInputs = [
       docutils
       Jinja2
       Pygments
       alabaster
       six
       snowballstemmer
       pytz
       babel
+      imagesize
 
       # TODO: johbo: Had to include it here so that can be imported
       sphinx_rtd_theme
     ];
   });
 
   docutils = buildPythonPackage rec {
     name = "docutils-0.12";
     src = fetchurl {
       url = "https://pypi.python.org/packages/source/d/docutils/${name}.tar.gz";
       md5 = "4622263b62c5c771c03502afa3157768";
     };
   };
 
   sphinx_rtd_theme = buildPythonPackage rec {
     name = "sphinx_rtd_theme-0.1.9";
     src = fetchurl {
       url = "https://pypi.python.org/packages/source/s/sphinx_rtd_theme/${name}.tar.gz";
       md5 = "86a25c8d47147c872e42dc84cc66f97b";
     };
 
     # Note: johbo: Sphinx needs this package and this package needs sphinx,
     # ignore the requirements file to solve this cycle.
     postPatch = ''
       rm requirements.txt
       touch requirements.txt
     '';
 
     # TODO: johbo: Tests would require sphinx and this creates recursion issues
     doCheck = false;
   };
 
 in python.buildEnv.override {
   inherit python;
   extraLibs = [
     Sphinx
     sphinx_rtd_theme
   ];
 }

docs/index.rst

@@ -1,84 +1,85 b''
 |RCM|
 =====
 
 |RCM| is a high-performance source code management and collaboration system.
 It enables you to develop projects securely behind the firewall while
 providing collaboration tools that work with |git|, |hg|,
 and |svn| |repos|. The user interface allows you to create, edit,
 and commit files and |repos| while managing their security permissions.
 
 |RCM| provides the following features:
 
 * Source code management.
 * Extended permissions management.
 * Integrated code collaboration tools.
 * Integrated code review and notifications.
 * Scalability provided by multi-node setup.
 * Fully programmable automation API.
 * Web-based hook management.
 * Native |svn| support.
 * Migration from existing databases.
 * |RCM| SDK.
 * Built-in analytics
 * Pluggable authentication system.
 * Support for |LDAP|, Crowd, CAS, PAM.
 * Debug modes of operation.
 * Private and public gists.
 * Gists with limited lifetimes and within instance only sharing.
 * Fully integrated code search function.
 * Always on SSL connectivity.
 
 .. only:: html
 
    Table of Contents
    -----------------
 
 .. toctree::
    :maxdepth: 1
    :caption: Admin Documentation
 
    install/quick-start
    install/install-database
    install/install-steps
    admin/system-overview
    nix/default-env
    admin/system-admin
    admin/user-admin
    admin/setting-repo-perms
    admin/security-tips
    auth/auth
    issue-trackers/issue-trackers
    admin/lab-settings
 
 .. toctree::
    :maxdepth: 1
    :caption: Feature Documentation
 
    collaboration/collaboration
    collaboration/review-notifications
    collaboration/pull-requests
    code-review/code-review
+   integrations/integrations
 
 .. toctree::
    :maxdepth: 1
    :caption: Developer Documentation
 
    api/api
    tools/rhodecode-tools
-   integrations/integrations
+   extensions/extensions-hooks
    contributing/contributing
 
 .. toctree::
    :maxdepth: 1
    :caption: User Documentation
 
    usage/basic-usage
    tutorials/tutorials
 
 .. toctree::
    :maxdepth: 1
    :caption: About
 
    known-issues/known-issues
    release-notes/release-notes
    admin/glossary

docs/install/quick-start.rst

@@ -1,109 +1,109 b''
 .. _quick-start:
 
-Quick Start Guide
-=================
+Quick Start Installation Guide
+==============================
 
 .. important::
 
     These are quick start instructions. To optimize your |RCE|,
     |RCC|, and |RCT| usage, read the more detailed instructions in our guides.
     For detailed installation instructions, see
     :ref:`RhodeCode Control Documentation <control:rcc>`
 
 .. tip::
 
    If using a non-SQLite database, install and configure the database, create
    a new user, and grant permissions. You will be prompted for this user's
    credentials during |RCE| installation. See the relevant database
    documentation for more details.
 
 To get |RCE| up and running, run through the below steps:
 
 1. Download the latest |RCC| installer from your `rhodecode.com`_ profile
    or main page.
    If you don't have an account, sign up at `rhodecode.com/register`_.
 
 2. Run the |RCC| installer and accept the End User Licence using the
    following example:
 
 .. code-block:: bash
 
     $ chmod 755 RhodeCode-installer-linux-*
     $ ./RhodeCode-installer-linux-*
 
 3. Install a VCS Server, and configure it to start at boot.
 
 .. code-block:: bash
 
     $ rccontrol install VCSServer
 
     Agree to the licence agreement? [y/N]: y
     IP to start the server on [127.0.0.1]:
     Port for the server to start [10005]:
     Creating new instance: vcsserver-1
     Installing RhodeCode VCSServer
     Configuring RhodeCode VCS Server ...
     Supervisord state is: RUNNING
     Added process group vcsserver-1
 
 
 4. Install |RCEE| or |RCCE|. If using MySQL or PostgreSQL, during
    installation you'll be asked for your database credentials, so have them at hand.
    Mysql or Postgres needs to be running and a new database needs to be created.
    You don't need any credentials or to create a database for SQLite.
 
 .. code-block:: bash
    :emphasize-lines: 11-16
 
     $ rccontrol install Community
 
     or
 
     $ rccontrol install Enterprise
 
     Username [admin]: username
     Password (min 6 chars):
     Repeat for confirmation:
     Email: [e-mail]
     Respositories location [/home/brian/repos]:
     IP to start the Enterprise server on [127.0.0.1]:
     Port for the Enterprise server to use [10004]:
     Database type - [s]qlite, [m]ysql, [p]ostresql:
     PostgreSQL selected
     Database host [127.0.0.1]:
     Database port [5432]:
     Database username: db-user-name
     Database password: somepassword
     Database name: example-db-name
 
 5. Check the status of your installation. You |RCEE|/|RCCE| instance runs
    on the URL displayed in the status message.
 
 .. code-block:: bash
 
     $ rccontrol status
 
     - NAME: enterprise-1
     - STATUS: RUNNING
     - TYPE: Enterprise
     - VERSION: 4.1.0
     - URL: http://127.0.0.1:10003
 
     - NAME: vcsserver-1
     - STATUS: RUNNING
     - TYPE: VCSServer
     - VERSION: 4.1.0
     - URL: http://127.0.0.1:10001
 
 .. note::
 
    Recommended post quick start install instructions:
 
    * Read the documentation
    * Carry out the :ref:`rhodecode-post-instal-ref`
    * Set up :ref:`indexing-ref`
    * Familiarise yourself with the :ref:`rhodecode-admin-ref` section.
 
 .. _rhodecode.com/download/: https://rhodecode.com/download/
 .. _rhodecode.com: https://rhodecode.com/
 .. _rhodecode.com/register: https://rhodecode.com/register/

docs/integrations/integrations.rst

@@ -1,25 +1,52 b''
-.. _integrations-ref:
+.. _integrations:
+
+Integrations
+------------
 
-Integrations and Extensions
-===========================
+Rhodecode supports integrations with external services for various events,
+such as commit pushes and pull requests. Multiple integrations of the same type
+can be added at the same time; this is useful for posting different events to
+different Slack channels, for example.
 
-The integrations section references three concepts regularly,
-so to clarify what is meant each time, read the following definitions:
+Supported integrations
+^^^^^^^^^^^^^^^^^^^^^^
 
-* **Plugin**: A Plugin is software that adds a specific feature to
-  an existing software application.
-* **Extension**: An extension extends the capabilities of,
-  or the data available to, an existing software application.
-* **Hook**: A hook intercepts function calls, messages, or events passed
-  between software components and can be used to trigger plugins, or their
-  extensions.
+============================    ============    =====================================
+Type/Name                       |RC| Edition    Description
+============================    ============    =====================================
+:ref:`integrations-slack`       |RCCEshort|     https://slack.com/
+:ref:`integrations-hipchat`     |RCCEshort|     https://www.hipchat.com/
+:ref:`integrations-webhook`     |RCCEshort|     POST events as `json` to a custom url
+:ref:`integrations-email`       |RCEEshort|     Send repo push commits by email
+:ref:`integrations-redmine`     |RCEEshort|     Close/Resolve/Reference redmine issues
+:ref:`integrations-jira`        |RCEEshort|     Close/Resolve/Reference JIRA issues
+============================    ============    =====================================
+
+.. _creating-integrations:
+
+Creating an Integration
+^^^^^^^^^^^^^^^^^^^^^^^
+
+Integrations can be added globally via the admin UI:
+
+:menuselection:`Admin --> Integrations`
+
+or per repository in each repository's settings:
+
+:menuselection:`Admin --> Repositories --> Edit --> Integrations`
+
+To create an integration, select the type from the list in the *Create New
+Integration* section.
+
+The *Current Integrations* section shows existing integrations that have been
+created along with their type (eg. Slack) and enabled status.
+
+See pages specific to each type of integration for more instructions:
 
 .. toctree::
 
-   rcx
-   install-ext
-   config-ext
-   extensions
-   hooks
-   full-blown-example
-   int-slack
+   slack
+   hipchat
+   redmine
+   jira
+   webhook

docs/issue-trackers/issue-trackers.rst

@@ -1,82 +1,81 b''
 .. _rhodecode-issue-trackers-ref:
 
 Issue Tracker Integration
 =========================
 
 You can set an issue tracker connection in two ways with |RCE|.
 
-* At instance level you can set a default issue tracker.
-* At |repo| level you can configure an integration with a different issue
+* At the instance level, you can set a default issue tracker.
+* At the |repo| level, you can configure an integration with a different issue
   tracker.
 
-To integrate |RCM| with an issue tracker you need to define a regular
-expression that will fetch the issue ID stored in commit messages and replace
+To integrate |RCM| with an issue tracker, you need to define a regular
+expression that will fetch the issue ID stored in commit messages, and replace
 it with a URL. This enables |RCE| to generate a link matching each issue to the
 target |repo|.
 
 Default Issue Tracker Configuration
 -----------------------------------
 
 To integrate your issue tracker, use the following steps:
 
 1. Open :menuselection:`Admin --> Settings --> Issue Tracker`.
 2. In the new entry field, enter the following information:
 
     * :guilabel:`Description`: A name for this set of rules.
     * :guilabel:`Pattern`: The regular expression that will match issues
       tagged in commit messages, or more see :ref:`issue-tr-eg-ref`.
     * :guilabel:`URL`: The URL to your issue tracker.
     * :guilabel:`Prefix`: The prefix with which you want to mark issues.
 
 3. Select **Add** so save the rule to your issue tracker configuration.
 
 Repository Issue Tracker Configuration
 --------------------------------------
 
-You can configure specific |repos| to use a different issue tracker if
-you need to connect to a non-default one. See the instructions in
-:ref:`repo-it`
+You can configure specific |repos| to use a different issue tracker than the
+default one. See the instructions in :ref:`repo-it`
 
 .. _issue-tr-eg-ref:
 
 Jira Integration
 ----------------
 
 * Regex = ``(?:^#|\s#)(\w+-\d+)``
 * URL = ``https://myissueserver.com/issue/${id}``
 * Issue Prefix = ``#``
 
 Confluence (Wiki)
 -----------------
 
 * Regex = ``(?:conf-)([A-Z0-9]+)``
 * URL = ``https://example.atlassian.net/display/wiki/${id}/${repo_name}``
 * issue prefix = ``CONF-``
 
 Redmine Integration
 -------------------
 
 * Regex = ``(issue-+\d+)``
 * URL = ``https://myissueserver.com/redmine/issue/${id}``
 * Issue Prefix = ``issue-``
 
 Redmine (wiki)
 --------------
 
 * Regex = ``(?:wiki-)([a-zA-Z0-9]+)``
 * URL = ``https://example.com/redmine/projects/wiki/${repo_name}``
 * Issue prefix = ``Issue-``
 
 Pivotal Tracker
 ---------------
 
 * Regex = ``(?:pivot-)(?<project_id>\d+)-(?<story>\d+)``
 * URL = ``https://www.pivotaltracker.com/s/projects/${project_id}/stories/${story}``
 * Issue prefix = ``Piv-``
 
 Trello
 ------
 
 * Regex = ``(?:trello-)(?<card_id>[a-zA-Z0-9]+)``
 * URL = ``https://trello.com/example.com/${card_id}``
 * Issue prefix = ``Trello-``

docs/release-notes/release-notes-4.2.1.rst

@@ -1,14 +1,14 b''
 |RCE| 4.2.1 |RNS|
 -----------------
 
 Release Date
 ^^^^^^^^^^^^
 
 - 2016-07-04
 
 Fixes
 ^^^^^
 
-- ui: fixed empty labels caused by missing translation of JS components
-- login: fixed bad routing URL in comments when user is not logged in.
-- celery: make sure to run tasks in sync mode if connection to celery is lost.
+- UI: fixed empty labels caused by missing translation of JS components.
+- Login: fixed bad routing URL in comments when user is not logged in.
+- Celery: make sure to run tasks in sync mode if connection to celery is lost.

docs/release-notes/release-notes.rst

@@ -1,84 +1,85 b''
 .. _rhodecode-release-notes-ref:
 
 Release Notes
 =============
 
 |RCE| 4.x Versions
 ------------------
 
 .. toctree::
    :maxdepth: 1
 
+   release-notes-4.3.0.rst
    release-notes-4.2.1.rst
    release-notes-4.2.0.rst
    release-notes-4.1.2.rst
    release-notes-4.1.1.rst
    release-notes-4.1.0.rst
    release-notes-4.0.1.rst
    release-notes-4.0.0.rst
 
 |RCE| 3.x Versions
 ------------------
 
 .. toctree::
    :maxdepth: 1
 
    release-notes-3.8.4.rst
    release-notes-3.8.3.rst
    release-notes-3.8.2.rst
    release-notes-3.8.1.rst
    release-notes-3.8.0.rst
    release-notes-3.7.1.rst
    release-notes-3.7.0.rst
    release-notes-3.6.1.rst
    release-notes-3.6.0.rst
    release-notes-3.5.2.rst
    release-notes-3.5.1.rst
    release-notes-3.5.0.rst
    release-notes-3.4.1.rst
    release-notes-3.4.0.rst
    release-notes-3.3.4.rst
    release-notes-3.3.3.rst
    release-notes-3.3.2.rst
    release-notes-3.3.1.rst
    release-notes-3.3.0.rst
    release-notes-3.2.3.rst
    release-notes-3.2.2.rst
    release-notes-3.2.1.rst
    release-notes-3.2.0.rst
    release-notes-3.1.1.rst
    release-notes-3.1.0.rst
    release-notes-3.0.2.rst
    release-notes-3.0.1.rst
    release-notes-3.0.0.rst
 
 |RCE| 2.x Versions
 ------------------
 
 .. toctree::
    :maxdepth: 1
 
    release-notes-2.2.8.rst
    release-notes-2.2.7.rst
    release-notes-2.2.6.rst
    release-notes-2.2.5.rst
    release-notes-2.2.4.rst
    release-notes-2.2.3.rst
    release-notes-2.2.2.rst
    release-notes-2.2.1.rst
    release-notes-2.2.0.rst
    release-notes-2.1.0.rst
    release-notes-2.0.2.rst
    release-notes-2.0.1.rst
    release-notes-2.0.0.rst
 
 |RCE| 1.x Versions
 ------------------
 
 .. toctree::
    :maxdepth: 1
 
    release-notes-1.7.2.rst
    release-notes-1.7.1.rst
    release-notes-1.7.0.rst
    release-notes-1.6.0.rst

docs/tools/tools-cli.rst

@@ -1,677 +1,677 b''
 .. _tools-cli:
 
 |RCT| CLI
 ---------
 
 The commands available with |RCT| can be split into three categories:
 
 - Remotely executable commands that can be run from your local machine once you
   have your connection details to |RCE| configured.
 - Locally executable commands the can be run on the server to carry out
   general maintenance.
 - Local configuration commands used to help set up your |RCT| configuration.
 
 
 rhodecode-tools
 ---------------
 
 Use |RCT| to setup automation, run the indexer, and install extensions for
 your |RCM| instances. Options:
 
 .. rst-class:: dl-horizontal
 
     \ - -apihost <api_host>
         Set the API host value.
 
     \ - -apikey <apikey_value>
         Set the API key value.
 
     \-c, - -config <config_file>
         Create a configuration file. The default file is created
         in ``~/.rhoderc``
 
     \ - -save-config
         Save the configuration file.
 
     \ - -show-config
         Show the current configuration values.
 
     \ - -format {json,pretty}
         Set the formatted representation.
 
 Example usage:
 
 .. code-block:: bash
 
    $ rhodecode-tools --apikey=key --apihost=http://rhodecode.server \
        --save-config
 
 rhodecode-api
 -------------
 
 The |RC| API lets you connect to |RCE| and carry out management tasks from a
 remote machine, for more information about the API, see the :ref:`api`. To
 pass arguments on the command-line use the ``method:option`` syntax.
 
 Example usage:
 
 .. code-block:: bash
 
     # Run the get_repos API call and sample output
     $ rhodecode-api --instance-name=enterprise-1 create_repo \
         repo_name:brand-new repo_type:hg description:repo-desc
 
     {
       "error": null,
       "id": 1110,
       "result": {
         "msg": "Created new repository `brand-new`",
         "success": true,
         "task": null
       }
     }
 
 Options:
 
 .. rst-class:: dl-horizontal
 
     \ - -api-cache-only
         Requires a cache to be present when running this call
 
     \ - -api-cache-rebuild
         Replaces existing cached values with new ones from server
 
     \ - -api-cache <PATH>
         Use a special cache dir to read responses from instead of the server
 
     \ - -api-cert-verify
          Verify the endpoint ssl certificate
 
     \ - -api-cert <PATH>
          Path to alternate CA bundle.
 
     \ - -apihost <api_host>
         Set the API host value.
 
     \ - -apikey <apikey_value>
         Set the API key value.
 
     \ - -instance-name <instance-id>
         Set the instance name
 
     \-I, - -install-dir <DIR>
         Location of application instances
 
     \-c, - -config <.rhoderc-file>
         Location of the :file:`.rhoderc`
 
     \-F, - -format {json,pretty}
         Set the formatted representation.
 
     \-h, - -help
         Show help messages.
 
     \-v, - -verbose
         Enable verbose messaging
 
 rhodecode-cleanup-gists
 -----------------------
 
 Use this to delete gists within |RCM|. Options:
 
 .. rst-class:: dl-horizontal
 
     \-c, - -config <config_file>
         Set the file path to the configuration file. The default file is
         :file:`/home/{user}/.rhoderc`
 
     \ - -corrupted
         Remove gists with corrupted metadata.
 
     \ - -dont-ask
         Remove gists without asking for confirmation.
 
     \-h, - -help
         Show help messages. current configuration values.
 
     \ - -instance-name <instance-id>
         Set the instance name.
 
     \-R, - -repo-dir
         Set the repository file path.
 
     \ - -version
         Display your |RCT| version.
 
 Example usage:
 
 .. code-block:: bash
 
     # Clean up gists related to an instance
     $ rhodecode-cleanup-gists --instance-name=enterprise-1
     Scanning for gists in /home/brian/repos/.rc_gist_store...
     preparing to remove [3] found gists
 
     # Clean up corrupted gists in an instance
     $ rhodecode-cleanup-gists --instance-name=enterprise-1 --corrupted
     Scanning for gists in /home/brian/repos/.rc_gist_store...
     preparing to remove [2] found gists
     the following gists will be archived:
       * EXPIRED: BAD METADATA        | /home/brian/repos/.rc_gist_store/5
       * EXPIRED: BAD METADATA        | /home/brian/repos/.rc_gist_store/8FtC
     are you sure you want to archive them? [y/N]: y
     removing gist /home/brian/repos/.rc_gist_store/5
     removing gist /home/brian/repos/.rc_gist_store/8FtCKdcbRKmEvRzTVsEt
 
 rhodecode-cleanup-repos
 -----------------------
 
 Use this to manage |repos| and |repo| groups within |RCM|. Options:
 
 .. rst-class:: dl-horizontal
 
     \-c, - -config <config_file>
         Set the file path to the configuration file. The default file is
         :file:`/home/{user}/.rhoderc`.
 
     \-h, - -help
         Show help messages. current configuration values.
 
     \ - -interactive
         Enable an interactive prompt for each repository when deleting.
 
     \ - -include-groups
         Remove repository groups.
 
     \ - -instance-name <instance-id>
         Set the instance name.
 
     \ - -list-only
         Display repositories selected for deletion.
 
     \ - -older-than <str>
         Delete repositories older that a specified time.
         You can use the following suffixes; d for days, h for hours,
         m for minutes, s for seconds.
 
     \-R, - -repo-dir
         Set the repository file path
 
 Example usage:
 
 .. code-block:: bash
 
     # Cleaning up repos using tools installed with RCE 350 and above
     $ ~/.rccontrol/enterprise-4/profile/bin/rhodecode-cleanup-repos \
         --instance-name=enterprise-4 --older-than=1d
     Scanning for repositories in /home/brian/repos...
     preparing to remove [2] found repositories older than 1 day, 0:00:00 (1d)
 
     the following repositories will be deleted completely:
     * REMOVED: 2015-08-05 00:23:18 | /home/brian/repos/rm__20150805_002318_831
     * REMOVED: 2015-08-04 01:22:10 | /home/brian/repos/rm__20150804_012210_336
     are you sure you want to remove them? [y/N]:
 
     # Clean up repos older than 1 year
     # If using virtualenv and pre RCE 350 tools installation
     (venv)$ rhodecode-cleanup-repos --instance-name=enterprise-1 \
         --older-than=365d
 
     Scanning for repositories in /home/brian/repos...
     preparing to remove [343] found repositories older than 365 days
 
     # clean up repos older than 3 days
     # If using virtualenv and pre RCE 350 tools installation
     (venv)$ rhodecode-cleanup-repos --instance-name=enterprise-1 \
         --older-than=3d
     Scanning for repositories in /home/brian/repos...
     preparing to remove [3] found repositories older than 3 days
 
 .. _tools-config:
 
 rhodecode-config
 ----------------
 
 Use this to create or update a |RCE| configuration file on the local machine.
 
 .. rst-class:: dl-horizontal
 
     \- -filename </path/to/config_file>
         Set the file path to the |RCE| configuration file.
 
     \- -show-defaults
         Display the defaults set in the |RCE| configuration file.
 
     \- -update
         Update the configuration with the new settings passed on the command
         line.
 
 .. code-block:: bash
 
     # Create a new config file
     $ rhodecode-config --filename=dev.ini
     Wrote new config file in /Users/user/dev.ini
 
     # Update config value for given section:
     $ rhodecode-config --update --filename=prod.ini [handler_console]level=INFO
 
     $ rhodecode-config --filename=dev.ini --show-defaults
     lang=en
     cpu_number=4
     uuid=<function <lambda> at 0x10d86ac08>
     license_token=ff1e-aa9c-bb66-11e5
     host=127.0.0.1
     here=/Users/brian
     error_aggregation_service=None
     database_url=sqlite:///%(here)s/rhodecode.db?timeout=30
     git_path=git
     http_server=waitress
     port=5000
 
 .. _tools-rhodecode-extensions:
 
 rhodecode-extensions
 --------------------
 
 |RCT| adds additional mapping for :ref:`indexing-ref`, statistics, and adds
 additional code for push/pull/create/delete |repo| hooks. These hooks can be
 used to send signals to build-bots such as jenkins. Options:
 
 .. rst-class:: dl-horizontal
 
     \-c, - -config <config_file>
         Create a configuration file. The default file is created
         in ``~/.rhoderc``
 
     \-h, - -help
          Show help messages.
 
     \-F, - -format {json,pretty}
         Set the formatted representation.
 
     \-I, - -install-dir <str>
         Set the location of the |RCE| installation. The default location is
         :file:`/home/{user}/.rccontrol/`.
 
     \ - -ini-file <str>
         Path to the :file:`rhodecode.ini` file for that instance.
 
     \ - -instance-name <instance-id>
         Set the instance name.
 
     \ - -plugins
          Add plugins to your |RCE| installation. See the
-         :ref:`integrations-ref` section for more details.
+         :ref:`extensions-hooks-ref` section for more details.
 
     \ - -version
          Display your |RCT| version.
 
 
 Once installed, you will see a :file:`rcextensions` folder in the instance
 directory, for example :file:`home/{user}/.rccontrol/{instance-id}/rcextensions`
 
 To install ``rcextensions``, use the following example:
 
 .. code-block:: bash
 
     # install extensions on the given instance
     # If using virtualenv prior to RCE 350
     (venv)$ rhodecode-extensions --instance-name=enterprise-1 \
         --ini-file=rhodecode.ini
     Writen new extensions file to rcextensions
 
     # install extensions with additional plugins on the given instance
     (venv)$ rhodecode-extensions --instance-name=enterprise-1 \
         --ini-file=rhodecode.ini --plugins
     Writen new extensions file to rcextensions
 
     # installing extensions from 350 onwards
     # as they are packaged with RCE
     $ .rccontrol/enterprise-4/profile/bin/rhodecode-extensions --plugins \
       --instance-name=enterprise-4 --ini-file=rhodecode.ini
 
     Writen new extensions file to rcextensions
 
 See the new extensions inside this directory for more details about the
 additional hooks available, for example see the ``push_post.py`` file.
 
 .. code-block:: python
 
     import urllib
     import urllib2
 
     def run(*args, **kwargs):
         """
         Extra params
 
         :param URL: url to send the data to
         """
 
         url = kwargs.pop('URL', None)
         if url:
             from rhodecode.lib.compat import json
             from rhodecode.model.db import Repository
 
             repo = Repository.get_by_repo_name(kwargs['repository'])
             changesets = []
             vcs_repo = repo.scm_instance_no_cache()
             for r in kwargs['pushed_revs']:
                 cs = vcs_repo.get_changeset(r)
                 changesets.append(json.dumps(cs))
 
             kwargs['pushed_revs'] = changesets
             headers = {
                 'User-Agent': 'RhodeCode-SCM web hook',
                 'Content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
                 'Accept': 'text/javascript, text/html, application/xml, '
                           'text/xml, */*',
                 'Accept-Encoding': 'gzip,deflate,sdch',
             }
 
             data = kwargs
             data = urllib.urlencode(data)
             req = urllib2.Request(url, data, headers)
             response = urllib2.urlopen(req)
             response.read()
             return 0
 
 
 rhodecode-gist
 --------------
 
 Use this to create, list, show, or delete gists within |RCM|. Options:
 
 .. rst-class:: dl-horizontal
 
     \ - -api-cache-only
         Requires a cache to be present when running this call
 
     \ - -api-cache-rebuild
         Replaces existing cached values with new ones from server
 
     \ - -api-cache PATH
         Use a special cache dir to read responses from instead of the server
 
     \ - -api-cert-verify
          Verify the endpoint ssl certificate
 
     \ - -api-cert PATH
          Path to alternate CA bundle.
 
     \ - -apihost <api_host>
         Set the API host value.
 
     \ - -apikey <apikey_value>
         Set the API key value.
 
     \-c, - -config <config_file>
         Create a configuration file.
         The default file is created in :file:`~/.rhoderc`
 
     \ - -create <gistname>
         create the gist
 
     \-d, - -description <str>
         Set gist description
 
     \ - -delete <gistid>
         Delete the gist
 
     \-f, - -file
         Specify the filename The file extension will enable syntax highlighting.
 
     \-F, - -format {json,pretty}
         Set the formatted representation.
 
     \ - -help
         Show help messages.
 
     \-I, - -install-dir <DIR>
         Location of application instances
 
     \ - -instance-name <instance-id>
         Set the instance name.
 
     \ - -list
         Display instance gists.
 
     \-l, --lifetime <minutes>
         Set the gist lifetime. The default value is (-1) forever
 
     \ - -show <gistname>
         Show the content of the gist
 
     \-o, - -open
         After creating Gist open it in browser
 
     \-p, - -private
         Create a private gist
 
     \ - -version
          Display your |RCT| version.
 
 Example usage:
 
 .. code-block:: bash
 
     # List the gists in an instance
     (venv)brian@ubuntu:~$ rhodecode-gist --instance-name=enterprise-1 list
     {
       "error": null,
       "id": 7102,
       "result": [
         {
           "access_id": "2",
           "content": null,
           "created_on": "2015-01-19T12:52:26.494",
           "description": "A public gust",
           "expires": -1.0,
           "gist_id": 2,
           "type": "public",
           "url": "http://127.0.0.1:10003/_admin/gists/2"
         },
         {
           "access_id": "7gs6BsSEC4pKUEPLz5AB",
           "content": null,
           "created_on": "2015-01-19T11:27:40.812",
           "description": "Gist testing API",
           "expires": -1.0,
           "gist_id": 1,
           "type": "private",
           "url": "http://127.0.0.1:10003/_admin/gists/7gs6BsSEC4pKUEPLz5AB"
         }
       ]
     }
 
     # delete a particular gist
     # You use the access_id to specify the gist to delete
     (venv)brian@ubuntu:~$ rhodecode-gist delete 2  --instance-name=enterprise-1
     {
       "error": null,
       "id": 6284,
       "result": {
         "gist": null,
         "msg": "deleted gist ID:2"
       }
     }
 
     # cat a file and pipe to new gist
     # This is if you are using virtualenv
     (venv)$ cat ~/.rhoderc | rhodecode-gist --instance-name=enterprise-1 \
         -d '.rhoderc copy' create
 
     {
       "error": null,
       "id": 5374,
       "result": {
         "gist": {
           "access_id": "7",
           "content": null,
           "created_on": "2015-01-26T11:31:58.774",
           "description": ".rhoderc copy",
           "expires": -1.0,
           "gist_id": 7,
           "type": "public",
           "url": "http://127.0.0.1:10003/_admin/gists/7"
         },
         "msg": "created new gist"
       }
     }
 
     # Cat a file and pipe to gist
     # in RCE 3.5.0 tools and above
     $ cat ~/.rhoderc | ~/.rccontrol/{instance-id}/profile/bin/rhodecode-gist \
        --instance-name=enterprise-4 -d '.rhoderc copy' create
     {
       "error": null,
       "id": 9253,
       "result": {
         "gist": {
           "access_id": "4",
           "acl_level": "acl_public",
           "content": null,
           "created_on": "2015-08-20T05:54:11.250",
           "description": ".rhoderc copy",
           "expires": -1.0,
           "gist_id": 4,
           "modified_at": "2015-08-20T05:54:11.250",
           "type": "public",
           "url": "http://127.0.0.1:10000/_admin/gists/4"
         },
         "msg": "created new gist"
       }
     }
 
 
 rhodecode-index
 ---------------
 
 More detailed information regarding setting up the indexer is available in
 the :ref:`indexing-ref` section. Options:
 
 .. rst-class:: dl-horizontal
 
     \ - -api-cache-only
         Requires a cache to be present when running this call
 
     \ - -api-cache-rebuild
         Replaces existing cached values with new ones from server
 
     \ - -api-cache PATH
         Use a special cache dir to read responses from instead of the server
 
     \ - -api-cert-verify
          Verify the endpoint ssl certificate
 
     \ - -api-cert PATH
          Path to alternate CA bundle.
 
     \ - -apihost <api_host>
         Set the API host value.
 
     \ - -apikey <apikey_value>
         Set the API key value.
 
     \-c, --config <config_file>
         Create a configuration file.
         The default file is created in :file:`~/.rhoderc`
 
     \ - -create-mapping <PATH>
          Creates an example mapping configuration for indexer.
 
     \-F, - -format {json,pretty}
          Set the formatted representation.
 
     \-h, - -help
          Show help messages.
 
     \ - -instance-name <instance-id>
         Set the instance name
 
     \-I, - -install-dir <DIR>
         Location of application instances
 
     \-m, - -mapping <file_name>
          Parse the output to the .ini mapping file.
 
     \ - -optimize
          Optimize index for performance by amalgamating multiple index files
          into one. Greatly increases incremental indexing speed.
 
     \-R, - -repo-dir <DIRECTORY>
          Location of repositories
 
     \ - -source <PATH>
          Use a special source JSON file to feed the indexer
 
     \ - -version
          Display your |RCT| version.
 
 Example usage:
 
 .. code-block:: bash
 
     # Run the indexer
     $ ~/.rccontrol/enterprise-4/profile/bin/rhodecode-index \
         --instance-name=enterprise-4
 
     # Run indexer based on mapping.ini file
     # This is using pre-350 virtualenv
     (venv)$ rhodecode-index --instance-name=enterprise-1
 
     # Index from the command line without creating
     # the .rhoderc file
     $ rhodecode-index --apikey=key --apihost=http://rhodecode.server \
         --instance-name=enterprise-2 --save-config
 
     # Create the indexing mapping file
     $ ~/.rccontrol/enterprise-4/profile/bin/rhodecode-index \
         --create-mapping mapping.ini --instance-name=enterprise-4
 
 .. _tools-rhodecode-list-instance:
 
 rhodecode-list-instances
 ------------------------
 
 Use this command to list the instance details configured in the
 :file:`~/.rhoderc` file.
 
 .. code-block:: bash
 
    $ .rccontrol/enterprise-1/profile/bin/rhodecode-list-instances
    [instance:production] - Config only
    API-HOST: https://some.url.com
    API-KEY:  some.auth.token
 
    [instance:development] - Config only
    API-HOST: http://some.ip.address
    API-KEY:  some.auth.token
 
 
 .. _tools-setup-config:
 
 rhodecode-setup-config
 ----------------------
 
 Use this command to create the ``~.rhoderc`` file required by |RCT| to access
 remote instances.
 
 .. rst-class:: dl-horizontal
 
     \- -instance-name <name>
         Specify the instance name in the :file:`~/.rhoderc`
 
     \api_host <hostname>
         Create a configuration file. The default file is created
         in ``~/.rhoderc``
 
     \api_key <auth-token>
         Create a configuration file. The default file is created
         in ``~/.rhoderc``
 
 
 .. code-block:: bash
 
     (venv)$ rhodecode-setup-config --instance-name=tea api_host=URL api_key=xyz
     Config not found under /Users/username/.rhoderc, creating a new one
     Wrote new configuration into /Users/username/.rhoderc

pkgs/patch-rhodecode-tools-setup.diff

@@ -1,12 +1,12 b''
 diff --git a/requirements.txt b/requirements.txt
 --- a/requirements.txt
 +++ b/requirements.txt
-@@ -3,7 +3,7 @@future==0.14.3
+@@ -3,7 +3,7 @@ future==0.14.3
  six==1.9.0
  mako==1.0.1
  markupsafe==0.23
 -requests==2.5.1
 +requests
- #responses
  whoosh==2.7.0
- elasticsearch==2.3.0
  No newline at end of file
+ elasticsearch==2.3.0
+ elasticsearch-dsl==2.0.0
  No newline at end of file

pkgs/python-packages-overrides.nix

@@ -1,273 +1,281 b''
 # Overrides for the generated python-packages.nix
 #
 # This function is intended to be used as an extension to the generated file
 # python-packages.nix. The main objective is to add needed dependencies of C
 # libraries and tweak the build instructions where needed.
 
 { pkgs, basePythonPackages }:
 
 let
   sed = "sed -i";
   localLicenses = {
     repoze = {
       fullName = "Repoze License";
       url =  http://www.repoze.org/LICENSE.txt;
     };
   };
 in
 
 self: super: {
 
   appenlight-client = super.appenlight-client.override (attrs: {
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   });
 
   future = super.future.override (attrs: {
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   });
 
   gnureadline = super.gnureadline.override (attrs: {
     buildInputs = attrs.buildInputs ++ [
       pkgs.ncurses
     ];
     patchPhase = ''
       substituteInPlace setup.py --replace "/bin/bash" "${pkgs.bash}/bin/bash"
     '';
   });
 
   gunicorn = super.gunicorn.override (attrs: {
     propagatedBuildInputs = attrs.propagatedBuildInputs ++ [
       # johbo: futures is needed as long as we are on Python 2, otherwise
       # gunicorn explodes if used with multiple threads per worker.
       self.futures
     ];
   });
 
   ipython = super.ipython.override (attrs: {
     propagatedBuildInputs = attrs.propagatedBuildInputs ++ [
       self.gnureadline
     ];
   });
 
   kombu = super.kombu.override (attrs: {
     # The current version of kombu needs some patching to work with the
     # other libs. Should be removed once we update celery and kombu.
     patches = [
       ./patch-kombu-py-2-7-11.diff
       ./patch-kombu-msgpack.diff
     ];
   });
 
   lxml = super.lxml.override (attrs: {
     buildInputs = with self; [
       pkgs.libxml2
       pkgs.libxslt
     ];
   });
 
   MySQL-python = super.MySQL-python.override (attrs: {
     buildInputs = attrs.buildInputs ++ [
       pkgs.openssl
     ];
     propagatedBuildInputs = attrs.propagatedBuildInputs ++ [
       pkgs.mysql.lib
       pkgs.zlib
     ];
   });
 
   psutil = super.psutil.override (attrs: {
     buildInputs = attrs.buildInputs ++
       pkgs.lib.optional pkgs.stdenv.isDarwin pkgs.darwin.IOKit;
   });
 
   psycopg2 = super.psycopg2.override (attrs: {
     buildInputs = attrs.buildInputs ++
       pkgs.lib.optional pkgs.stdenv.isDarwin pkgs.openssl;
     propagatedBuildInputs = attrs.propagatedBuildInputs ++ [
       pkgs.postgresql
     ];
     meta = {
       license = pkgs.lib.licenses.lgpl3Plus;
     };
   });
 
+  py-gfm = super.py-gfm.override  {
+    src = pkgs.fetchgit {
+      url = "https://code.rhodecode.com/upstream/py-gfm";
+      rev = "0d66a19bc16e3d49de273c0f797d4e4781e8c0f2";
+      sha256 = "0ryp74jyihd3ckszq31bml5jr3bciimhfp7va7kw6ld92930ksv3";
+    };
+  };
+
   pycurl = super.pycurl.override (attrs: {
     propagatedBuildInputs = attrs.propagatedBuildInputs ++ [
       pkgs.curl
       pkgs.openssl
     ];
     preConfigure = ''
       substituteInPlace setup.py --replace '--static-libs' '--libs'
       export PYCURL_SSL_LIBRARY=openssl
     '';
     meta = {
       # TODO: It is LGPL and MIT
       license = pkgs.lib.licenses.mit;
     };
   });
 
   Pylons = super.Pylons.override (attrs: {
     name = "Pylons-1.0.1-patch1";
     src = pkgs.fetchgit {
       url = "https://code.rhodecode.com/upstream/pylons";
       rev = "707354ee4261b9c10450404fc9852ccea4fd667d";
       sha256 = "b2763274c2780523a335f83a1df65be22ebe4ff413a7bc9e9288d23c1f62032e";
     };
   });
 
   pyramid = super.pyramid.override (attrs: {
     postFixup = ''
       wrapPythonPrograms
       # TODO: johbo: "wrapPython" adds this magic line which
       # confuses pserve.
       ${sed} '/import sys; sys.argv/d' $out/bin/.pserve-wrapped
     '';
     meta = {
       license = localLicenses.repoze;
     };
   });
 
   pyramid-debugtoolbar = super.pyramid-debugtoolbar.override (attrs: {
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal localLicenses.repoze ];
     };
   });
 
   Pyro4 = super.Pyro4.override (attrs: {
     # TODO: Was not able to generate this version, needs further
     # investigation.
     name = "Pyro4-4.35";
     src = pkgs.fetchurl {
       url = "https://pypi.python.org/packages/source/P/Pyro4/Pyro4-4.35.src.tar.gz";
       md5 = "cbe6cb855f086a0f092ca075005855f3";
     };
   });
 
   pysqlite = super.pysqlite.override (attrs: {
     propagatedBuildInputs = [
       pkgs.sqlite
     ];
     meta = {
       license = [ pkgs.lib.licenses.zlib pkgs.lib.licenses.libpng ];
     };
   });
 
   pytest-runner = super.pytest-runner.override (attrs: {
     propagatedBuildInputs = [
       self.setuptools-scm
     ];
   });
 
   python-ldap = super.python-ldap.override (attrs: {
     propagatedBuildInputs = attrs.propagatedBuildInputs ++ [
       pkgs.cyrus_sasl
       pkgs.openldap
       pkgs.openssl
     ];
     NIX_CFLAGS_COMPILE = "-I${pkgs.cyrus_sasl}/include/sasl";
   });
 
   python-pam = super.python-pam.override (attrs:
     let
       includeLibPam = pkgs.stdenv.isLinux;
     in {
       # TODO: johbo: Move the option up into the default.nix, we should
       # include python-pam only on supported platforms.
       propagatedBuildInputs = attrs.propagatedBuildInputs ++
         pkgs.lib.optional includeLibPam [
           pkgs.pam
         ];
       # TODO: johbo: Check if this can be avoided, or transform into
       # a real patch
       patchPhase = pkgs.lib.optionals includeLibPam ''
         substituteInPlace pam.py \
           --replace 'find_library("pam")' '"${pkgs.pam}/lib/libpam.so.0"'
       '';
     });
 
   rhodecode-tools = super.rhodecode-tools.override (attrs: {
     patches = [
       ./patch-rhodecode-tools-setup.diff
     ];
   });
 
   URLObject = super.URLObject.override (attrs: {
     meta = {
       license = {
         spdxId = "Unlicense";
         fullName = "The Unlicense";
         url = http://unlicense.org/;
       };
     };
   });
 
   amqplib = super.amqplib.override (attrs: {
     meta = {
       license = pkgs.lib.licenses.lgpl3;
     };
   });
 
   docutils = super.docutils.override (attrs: {
     meta = {
       license = pkgs.lib.licenses.bsd2;
     };
   });
 
   colander = super.colander.override (attrs: {
     meta = {
       license = localLicenses.repoze;
     };
   });
 
   pyramid-beaker  = super.pyramid-beaker.override (attrs: {
     meta = {
       license = localLicenses.repoze;
     };
   });
 
   pyramid-mako = super.pyramid-mako.override (attrs: {
     meta = {
       license = localLicenses.repoze;
     };
   });
 
   repoze.lru = super.repoze.lru.override (attrs: {
     meta = {
       license = localLicenses.repoze;
     };
   });
 
   recaptcha-client = super.recaptcha-client.override (attrs: {
     meta = {
       # TODO: It is MIT/X11
       license = pkgs.lib.licenses.mit;
     };
   });
 
   python-editor = super.python-editor.override (attrs: {
     meta = {
       license = pkgs.lib.licenses.asl20;
     };
   });
 
   translationstring = super.translationstring.override (attrs: {
     meta = {
       license = localLicenses.repoze;
     };
   });
 
   venusian = super.venusian.override (attrs: {
     meta = {
       license = localLicenses.repoze;
     };
   });
 
   # Avoid that setuptools is replaced, this leads to trouble
   # with buildPythonPackage.
   setuptools = basePythonPackages.setuptools;
 
 }

pkgs/python-packages.nix

@@ -1,1628 +1,1732 b''
 {
   Babel = super.buildPythonPackage {
     name = "Babel-1.3";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [pytz];
     src = fetchurl {
       url = "https://pypi.python.org/packages/33/27/e3978243a03a76398c384c83f7ca879bc6e8f1511233a621fcada135606e/Babel-1.3.tar.gz";
       md5 = "5264ceb02717843cbc9ffce8e6e06bdb";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   Beaker = super.buildPythonPackage {
     name = "Beaker-1.7.0";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/97/8e/409d2e7c009b8aa803dc9e6f239f1db7c3cdf578249087a404e7c27a505d/Beaker-1.7.0.tar.gz";
       md5 = "386be3f7fe427358881eee4622b428b3";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   CProfileV = super.buildPythonPackage {
     name = "CProfileV-1.0.6";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [bottle];
     src = fetchurl {
       url = "https://pypi.python.org/packages/eb/df/983a0b6cfd3ac94abf023f5011cb04f33613ace196e33f53c86cf91850d5/CProfileV-1.0.6.tar.gz";
       md5 = "08c7c242b6e64237bc53c5d13537e03d";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
+  Chameleon = super.buildPythonPackage {
+    name = "Chameleon-2.24";
+    buildInputs = with self; [];
+    doCheck = false;
+    propagatedBuildInputs = with self; [];
+    src = fetchurl {
+      url = "https://pypi.python.org/packages/5a/9e/637379ffa13c5172b5c0e704833ffea6bf51cec7567f93fd6e903d53ed74/Chameleon-2.24.tar.gz";
+      md5 = "1b01f1f6533a8a11d0d2f2366dec5342";
+    };
+    meta = {
+      license = [ { fullName = "BSD-like (http://repoze.org/license.html)"; } ];
+    };
+  };
   Fabric = super.buildPythonPackage {
     name = "Fabric-1.10.0";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [paramiko];
     src = fetchurl {
       url = "https://pypi.python.org/packages/e3/5f/b6ebdb5241d5ec9eab582a5c8a01255c1107da396f849e538801d2fe64a5/Fabric-1.10.0.tar.gz";
       md5 = "2cb96473387f0e7aa035210892352f4a";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   FormEncode = super.buildPythonPackage {
     name = "FormEncode-1.2.4";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/8e/59/0174271a6f004512e0201188593e6d319db139d14cb7490e488bbb078015/FormEncode-1.2.4.tar.gz";
       md5 = "6bc17fb9aed8aea198975e888e2077f4";
     };
     meta = {
       license = [ pkgs.lib.licenses.psfl ];
     };
   };
   Jinja2 = super.buildPythonPackage {
     name = "Jinja2-2.7.3";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [MarkupSafe];
     src = fetchurl {
       url = "https://pypi.python.org/packages/b0/73/eab0bca302d6d6a0b5c402f47ad1760dc9cb2dd14bbc1873ad48db258e4d/Jinja2-2.7.3.tar.gz";
       md5 = "b9dffd2f3b43d673802fe857c8445b1a";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   Mako = super.buildPythonPackage {
     name = "Mako-1.0.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [MarkupSafe];
     src = fetchurl {
       url = "https://pypi.python.org/packages/8e/a4/aa56533ecaa5f22ca92428f74e074d0c9337282933c722391902c8f9e0f8/Mako-1.0.1.tar.gz";
       md5 = "9f0aafd177b039ef67b90ea350497a54";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   Markdown = super.buildPythonPackage {
     name = "Markdown-2.6.2";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/62/8b/83658b5f6c220d5fcde9f9852d46ea54765d734cfbc5a9f4c05bfc36db4d/Markdown-2.6.2.tar.gz";
       md5 = "256d19afcc564dc4ce4c229bb762f7ae";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   MarkupSafe = super.buildPythonPackage {
     name = "MarkupSafe-0.23";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/c0/41/bae1254e0396c0cc8cf1751cb7d9afc90a602353695af5952530482c963f/MarkupSafe-0.23.tar.gz";
       md5 = "f5ab3deee4c37cd6a922fb81e730da6e";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   MySQL-python = super.buildPythonPackage {
     name = "MySQL-python-1.2.5";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/a5/e9/51b544da85a36a68debe7a7091f068d802fc515a3a202652828c73453cad/MySQL-python-1.2.5.zip";
       md5 = "654f75b302db6ed8dc5a898c625e030c";
     };
     meta = {
       license = [ pkgs.lib.licenses.gpl1 ];
     };
   };
   Paste = super.buildPythonPackage {
     name = "Paste-2.0.2";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [six];
     src = fetchurl {
       url = "https://pypi.python.org/packages/d5/8d/0f8ac40687b97ff3e07ebd1369be20bdb3f93864d2dc3c2ff542edb4ce50/Paste-2.0.2.tar.gz";
       md5 = "4bfc8a7eaf858f6309d2ac0f40fc951c";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   PasteDeploy = super.buildPythonPackage {
     name = "PasteDeploy-1.5.2";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/0f/90/8e20cdae206c543ea10793cbf4136eb9a8b3f417e04e40a29d72d9922cbd/PasteDeploy-1.5.2.tar.gz";
       md5 = "352b7205c78c8de4987578d19431af3b";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   PasteScript = super.buildPythonPackage {
     name = "PasteScript-1.7.5";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [Paste PasteDeploy];
     src = fetchurl {
       url = "https://pypi.python.org/packages/a5/05/fc60efa7c2f17a1dbaeccb2a903a1e90902d92b9d00eebabe3095829d806/PasteScript-1.7.5.tar.gz";
       md5 = "4c72d78dcb6bb993f30536842c16af4d";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   Pygments = super.buildPythonPackage {
-    name = "Pygments-2.0.2";
+    name = "Pygments-2.1.3";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/f4/c6/bdbc5a8a112256b2b6136af304dbae93d8b1ef8738ff2d12a51018800e46/Pygments-2.0.2.tar.gz";
-      md5 = "238587a1370d62405edabd0794b3ec4a";
+      url = "https://pypi.python.org/packages/b8/67/ab177979be1c81bc99c8d0592ef22d547e70bb4c6815c383286ed5dec504/Pygments-2.1.3.tar.gz";
+      md5 = "ed3fba2467c8afcda4d317e4ef2c6150";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   Pylons = super.buildPythonPackage {
     name = "Pylons-1.0.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [Routes WebHelpers Beaker Paste PasteDeploy PasteScript FormEncode simplejson decorator nose Mako WebError WebTest Tempita MarkupSafe WebOb];
     src = fetchurl {
       url = "https://pypi.python.org/packages/a2/69/b835a6bad00acbfeed3f33c6e44fa3f936efc998c795bfb15c61a79ecf62/Pylons-1.0.1.tar.gz";
       md5 = "6cb880d75fa81213192142b07a6e4915";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   Pyro4 = super.buildPythonPackage {
     name = "Pyro4-4.41";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [serpent];
     src = fetchurl {
       url = "https://pypi.python.org/packages/56/2b/89b566b4bf3e7f8ba790db2d1223852f8cb454c52cab7693dd41f608ca2a/Pyro4-4.41.tar.gz";
       md5 = "ed69e9bfafa9c06c049a87cb0c4c2b6c";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   Routes = super.buildPythonPackage {
     name = "Routes-1.13";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [repoze.lru];
     src = fetchurl {
       url = "https://pypi.python.org/packages/88/d3/259c3b3cde8837eb9441ab5f574a660e8a4acea8f54a078441d4d2acac1c/Routes-1.13.tar.gz";
       md5 = "d527b0ab7dd9172b1275a41f97448783";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   SQLAlchemy = super.buildPythonPackage {
     name = "SQLAlchemy-0.9.9";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/28/f7/1bbfd0d8597e8c358d5e15a166a486ad82fc5579b4e67b6ef7c05b1d182b/SQLAlchemy-0.9.9.tar.gz";
       md5 = "8a10a9bd13ed3336ef7333ac2cc679ff";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   Sphinx = super.buildPythonPackage {
     name = "Sphinx-1.2.2";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [Pygments docutils Jinja2];
     src = fetchurl {
       url = "https://pypi.python.org/packages/0a/50/34017e6efcd372893a416aba14b84a1a149fc7074537b0e9cb6ca7b7abe9/Sphinx-1.2.2.tar.gz";
       md5 = "3dc73ccaa8d0bfb2d62fb671b1f7e8a4";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   Tempita = super.buildPythonPackage {
     name = "Tempita-0.5.2";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/56/c8/8ed6eee83dbddf7b0fc64dd5d4454bc05e6ccaafff47991f73f2894d9ff4/Tempita-0.5.2.tar.gz";
       md5 = "4c2f17bb9d481821c41b6fbee904cea1";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   URLObject = super.buildPythonPackage {
     name = "URLObject-2.4.0";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/cb/b6/e25e58500f9caef85d664bec71ec67c116897bfebf8622c32cb75d1ca199/URLObject-2.4.0.tar.gz";
       md5 = "2ed819738a9f0a3051f31dc9924e3065";
     };
     meta = {
       license = [  ];
     };
   };
   WebError = super.buildPythonPackage {
     name = "WebError-0.10.3";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [WebOb Tempita Pygments Paste];
     src = fetchurl {
       url = "https://pypi.python.org/packages/35/76/e7e5c2ce7e9c7f31b54c1ff295a495886d1279a002557d74dd8957346a79/WebError-0.10.3.tar.gz";
       md5 = "84b9990b0baae6fd440b1e60cdd06f9a";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   WebHelpers = super.buildPythonPackage {
     name = "WebHelpers-1.3";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [MarkupSafe];
     src = fetchurl {
       url = "https://pypi.python.org/packages/ee/68/4d07672821d514184357f1552f2dad923324f597e722de3b016ca4f7844f/WebHelpers-1.3.tar.gz";
       md5 = "32749ffadfc40fea51075a7def32588b";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   WebHelpers2 = super.buildPythonPackage {
     name = "WebHelpers2-2.0";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [MarkupSafe six];
     src = fetchurl {
       url = "https://pypi.python.org/packages/ff/30/56342c6ea522439e3662427c8d7b5e5b390dff4ff2dc92d8afcb8ab68b75/WebHelpers2-2.0.tar.gz";
       md5 = "0f6b68d70c12ee0aed48c00b24da13d3";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   WebOb = super.buildPythonPackage {
     name = "WebOb-1.3.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/16/78/adfc0380b8a0d75b2d543fa7085ba98a573b1ae486d9def88d172b81b9fa/WebOb-1.3.1.tar.gz";
       md5 = "20918251c5726956ba8fef22d1556177";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   WebTest = super.buildPythonPackage {
     name = "WebTest-1.4.3";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [WebOb];
     src = fetchurl {
       url = "https://pypi.python.org/packages/51/3d/84fd0f628df10b30c7db87895f56d0158e5411206b721ca903cb51bfd948/WebTest-1.4.3.zip";
       md5 = "631ce728bed92c681a4020a36adbc353";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   Whoosh = super.buildPythonPackage {
     name = "Whoosh-2.7.0";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/1c/dc/2f0231ff3875ded36df8c1ab851451e51a237dc0e5a86d3d96036158da94/Whoosh-2.7.0.zip";
       md5 = "7abfd970f16fadc7311960f3fa0bc7a9";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal pkgs.lib.licenses.bsd2 ];
     };
   };
   alembic = super.buildPythonPackage {
     name = "alembic-0.8.4";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [SQLAlchemy Mako python-editor];
     src = fetchurl {
       url = "https://pypi.python.org/packages/ca/7e/299b4499b5c75e5a38c5845145ad24755bebfb8eec07a2e1c366b7181eeb/alembic-0.8.4.tar.gz";
       md5 = "5f95d8ee62b443f9b37eb5bee76c582d";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   amqplib = super.buildPythonPackage {
     name = "amqplib-1.0.2";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/75/b7/8c2429bf8d92354a0118614f9a4d15e53bc69ebedce534284111de5a0102/amqplib-1.0.2.tgz";
       md5 = "5c92f17fbedd99b2b4a836d4352d1e2f";
     };
     meta = {
       license = [ { fullName = "LGPL"; } { fullName = "GNU Library or Lesser General Public License (LGPL)"; } ];
     };
   };
   anyjson = super.buildPythonPackage {
     name = "anyjson-0.3.3";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/c3/4d/d4089e1a3dd25b46bebdb55a992b0797cff657b4477bc32ce28038fdecbc/anyjson-0.3.3.tar.gz";
       md5 = "2ea28d6ec311aeeebaf993cb3008b27c";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   appenlight-client = super.buildPythonPackage {
     name = "appenlight-client-0.6.14";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [WebOb requests];
     src = fetchurl {
       url = "https://pypi.python.org/packages/4d/e0/23fee3ebada8143f707e65c06bcb82992040ee64ea8355e044ed55ebf0c1/appenlight_client-0.6.14.tar.gz";
       md5 = "578c69b09f4356d898fff1199b98a95c";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal { fullName = "DFSG approved"; } ];
     };
   };
   authomatic = super.buildPythonPackage {
     name = "authomatic-0.1.0.post1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/08/1a/8a930461e604c2d5a7a871e1ac59fa82ccf994c32e807230c8d2fb07815a/Authomatic-0.1.0.post1.tar.gz";
       md5 = "be3f3ce08747d776aae6d6cc8dcb49a9";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   backport-ipaddress = super.buildPythonPackage {
     name = "backport-ipaddress-0.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/d3/30/54c6dab05a4dec44db25ff309f1fbb6b7a8bde3f2bade38bb9da67bbab8f/backport_ipaddress-0.1.tar.gz";
       md5 = "9c1f45f4361f71b124d7293a60006c05";
     };
     meta = {
       license = [ pkgs.lib.licenses.psfl ];
     };
   };
   bottle = super.buildPythonPackage {
     name = "bottle-0.12.8";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/52/df/e4a408f3a7af396d186d4ecd3b389dd764f0f943b4fa8d257bfe7b49d343/bottle-0.12.8.tar.gz";
       md5 = "13132c0a8f607bf860810a6ee9064c5b";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   bumpversion = super.buildPythonPackage {
     name = "bumpversion-0.5.3";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/14/41/8c9da3549f8e00c84f0432c3a8cf8ed6898374714676aab91501d48760db/bumpversion-0.5.3.tar.gz";
       md5 = "c66a3492eafcf5ad4b024be9fca29820";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   celery = super.buildPythonPackage {
     name = "celery-2.2.10";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [python-dateutil anyjson kombu pyparsing];
     src = fetchurl {
       url = "https://pypi.python.org/packages/b1/64/860fd50e45844c83442e7953effcddeff66b2851d90b2d784f7201c111b8/celery-2.2.10.tar.gz";
       md5 = "898bc87e54f278055b561316ba73e222";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
+  channelstream = super.buildPythonPackage {
+    name = "channelstream-0.5.2";
+    buildInputs = with self; [];
+    doCheck = false;
+    propagatedBuildInputs = with self; [gevent ws4py pyramid pyramid-jinja2 itsdangerous requests six];
+    src = fetchurl {
+      url = "https://pypi.python.org/packages/2b/31/29a8e085cf5bf97fa88e7b947adabfc581a18a3463adf77fb6dada34a65f/channelstream-0.5.2.tar.gz";
+      md5 = "1c5eb2a8a405be6f1073da94da6d81d3";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.bsdOriginal ];
+    };
+  };
   click = super.buildPythonPackage {
     name = "click-5.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/b7/34/a496632c4fb6c1ee76efedf77bb8d28b29363d839953d95095b12defe791/click-5.1.tar.gz";
       md5 = "9c5323008cccfe232a8b161fc8196d41";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   colander = super.buildPythonPackage {
     name = "colander-1.2";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [translationstring iso8601];
     src = fetchurl {
       url = "https://pypi.python.org/packages/14/23/c9ceba07a6a1dc0eefbb215fc0dc64aabc2b22ee756bc0f0c13278fa0887/colander-1.2.tar.gz";
       md5 = "83db21b07936a0726e588dae1914b9ed";
     };
     meta = {
       license = [ { fullName = "BSD-derived (http://www.repoze.org/LICENSE.txt)"; } ];
     };
   };
   configobj = super.buildPythonPackage {
     name = "configobj-5.0.6";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [six];
     src = fetchurl {
       url = "https://pypi.python.org/packages/64/61/079eb60459c44929e684fa7d9e2fdca403f67d64dd9dbac27296be2e0fab/configobj-5.0.6.tar.gz";
       md5 = "e472a3a1c2a67bb0ec9b5d54c13a47d6";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   cov-core = super.buildPythonPackage {
     name = "cov-core-1.15.0";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [coverage];
     src = fetchurl {
       url = "https://pypi.python.org/packages/4b/87/13e75a47b4ba1be06f29f6d807ca99638bedc6b57fa491cd3de891ca2923/cov-core-1.15.0.tar.gz";
       md5 = "f519d4cb4c4e52856afb14af52919fe6";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   coverage = super.buildPythonPackage {
     name = "coverage-3.7.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/09/4f/89b06c7fdc09687bca507dc411c342556ef9c5a3b26756137a4878ff19bf/coverage-3.7.1.tar.gz";
       md5 = "c47b36ceb17eaff3ecfab3bcd347d0df";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   cssselect = super.buildPythonPackage {
     name = "cssselect-0.9.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/aa/e5/9ee1460d485b94a6d55732eb7ad5b6c084caf73dd6f9cb0bb7d2a78fafe8/cssselect-0.9.1.tar.gz";
       md5 = "c74f45966277dc7a0f768b9b0f3522ac";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   decorator = super.buildPythonPackage {
     name = "decorator-3.4.2";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/35/3a/42566eb7a2cbac774399871af04e11d7ae3fc2579e7dae85213b8d1d1c57/decorator-3.4.2.tar.gz";
       md5 = "9e0536870d2b83ae27d58dbf22582f4d";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
+  deform = super.buildPythonPackage {
+    name = "deform-2.0a2";
+    buildInputs = with self; [];
+    doCheck = false;
+    propagatedBuildInputs = with self; [Chameleon colander peppercorn translationstring zope.deprecation];
+    src = fetchurl {
+      url = "https://pypi.python.org/packages/8d/b3/aab57e81da974a806dc9c5fa024a6404720f890a6dcf2e80885e3cb4609a/deform-2.0a2.tar.gz";
+      md5 = "7a90d41f7fbc18002ce74f39bd90a5e4";
+    };
+    meta = {
+      license = [ { fullName = "BSD-derived (http://www.repoze.org/LICENSE.txt)"; } ];
+    };
+  };
   docutils = super.buildPythonPackage {
     name = "docutils-0.12";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/37/38/ceda70135b9144d84884ae2fc5886c6baac4edea39550f28bcd144c1234d/docutils-0.12.tar.gz";
       md5 = "4622263b62c5c771c03502afa3157768";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal pkgs.lib.licenses.publicDomain pkgs.lib.licenses.gpl1 { fullName = "public domain, Python, 2-Clause BSD, GPL 3 (see COPYING.txt)"; } pkgs.lib.licenses.psfl ];
     };
   };
   dogpile.cache = super.buildPythonPackage {
-    name = "dogpile.cache-0.5.7";
+    name = "dogpile.cache-0.6.1";
     buildInputs = with self; [];
     doCheck = false;
-    propagatedBuildInputs = with self; [dogpile.core];
+    propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/07/74/2a83bedf758156d9c95d112691bbad870d3b77ccbcfb781b4ef836ea7d96/dogpile.cache-0.5.7.tar.gz";
-      md5 = "3e58ce41af574aab41d78e9c4190f194";
+      url = "https://pypi.python.org/packages/f6/a0/6f2142c58c6588d17c734265b103ae1cd0741e1681dd9483a63f22033375/dogpile.cache-0.6.1.tar.gz";
+      md5 = "35d7fb30f22bbd0685763d894dd079a9";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   dogpile.core = super.buildPythonPackage {
     name = "dogpile.core-0.4.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/0e/77/e72abc04c22aedf874301861e5c1e761231c288b5de369c18be8f4b5c9bb/dogpile.core-0.4.1.tar.gz";
       md5 = "01cb19f52bba3e95c9b560f39341f045";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   dulwich = super.buildPythonPackage {
     name = "dulwich-0.12.0";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/6f/04/fbe561b6d45c0ec758330d5b7f5ba4b6cb4f1ca1ab49859d2fc16320da75/dulwich-0.12.0.tar.gz";
       md5 = "f3a8a12bd9f9dd8c233e18f3d49436fa";
     };
     meta = {
       license = [ pkgs.lib.licenses.gpl2Plus ];
     };
   };
   ecdsa = super.buildPythonPackage {
     name = "ecdsa-0.11";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/6c/3f/92fe5dcdcaa7bd117be21e5520c9a54375112b66ec000d209e9e9519fad1/ecdsa-0.11.tar.gz";
       md5 = "8ef586fe4dbb156697d756900cb41d7c";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   elasticsearch = super.buildPythonPackage {
     name = "elasticsearch-2.3.0";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [urllib3];
     src = fetchurl {
       url = "https://pypi.python.org/packages/10/35/5fd52c5f0b0ee405ed4b5195e8bce44c5e041787680dc7b94b8071cac600/elasticsearch-2.3.0.tar.gz";
       md5 = "2550f3b51629cf1ef9636608af92c340";
     };
     meta = {
       license = [ pkgs.lib.licenses.asl20 ];
     };
   };
   elasticsearch-dsl = super.buildPythonPackage {
     name = "elasticsearch-dsl-2.0.0";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [six python-dateutil elasticsearch];
     src = fetchurl {
       url = "https://pypi.python.org/packages/4e/5d/e788ae8dbe2ff4d13426db0a027533386a5c276c77a2654dc0e2007ce04a/elasticsearch-dsl-2.0.0.tar.gz";
       md5 = "4cdfec81bb35383dd3b7d02d7dc5ee68";
     };
     meta = {
       license = [ pkgs.lib.licenses.asl20 ];
     };
   };
   flake8 = super.buildPythonPackage {
     name = "flake8-2.4.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [pyflakes pep8 mccabe];
     src = fetchurl {
       url = "https://pypi.python.org/packages/8f/b5/9a73c66c7dba273bac8758398f060c008a25f3e84531063b42503b5d0a95/flake8-2.4.1.tar.gz";
       md5 = "ed45d3db81a3b7c88bd63c6e37ca1d65";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   future = super.buildPythonPackage {
     name = "future-0.14.3";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/83/80/8ef3a11a15f8eaafafa0937b20c1b3f73527e69ab6b3fa1cf94a5a96aabb/future-0.14.3.tar.gz";
       md5 = "e94079b0bd1fc054929e8769fc0f6083";
     };
     meta = {
       license = [ { fullName = "OSI Approved"; } pkgs.lib.licenses.mit ];
     };
   };
   futures = super.buildPythonPackage {
     name = "futures-3.0.2";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/f8/e7/fc0fcbeb9193ba2d4de00b065e7fd5aecd0679e93ce95a07322b2b1434f4/futures-3.0.2.tar.gz";
       md5 = "42aaf1e4de48d6e871d77dc1f9d96d5a";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
+  gevent = super.buildPythonPackage {
+    name = "gevent-1.1.1";
+    buildInputs = with self; [];
+    doCheck = false;
+    propagatedBuildInputs = with self; [greenlet];
+    src = fetchurl {
+      url = "https://pypi.python.org/packages/12/dc/0b2e57823225de86f6e111a65d212c9e3b64847dddaa19691a6cb94b0b2e/gevent-1.1.1.tar.gz";
+      md5 = "1532f5396ab4d07a231f1935483be7c3";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.mit ];
+    };
+  };
   gnureadline = super.buildPythonPackage {
     name = "gnureadline-6.3.3";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/3a/ee/2c3f568b0a74974791ac590ec742ef6133e2fbd287a074ba72a53fa5e97c/gnureadline-6.3.3.tar.gz";
       md5 = "c4af83c9a3fbeac8f2da9b5a7c60e51c";
     };
     meta = {
       license = [ pkgs.lib.licenses.gpl1 ];
     };
   };
   gprof2dot = super.buildPythonPackage {
-    name = "gprof2dot-2015.12.1";
+    name = "gprof2dot-2015.12.01";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/b9/34/7bf93c1952d40fa5c95ad963f4d8344b61ef58558632402eca18e6c14127/gprof2dot-2015.12.1.tar.gz";
       md5 = "e23bf4e2f94db032750c193384b4165b";
     };
     meta = {
       license = [ { fullName = "LGPL"; } ];
     };
   };
+  greenlet = super.buildPythonPackage {
+    name = "greenlet-0.4.9";
+    buildInputs = with self; [];
+    doCheck = false;
+    propagatedBuildInputs = with self; [];
+    src = fetchurl {
+      url = "https://pypi.python.org/packages/4e/3d/9d421539b74e33608b245092870156b2e171fb49f2b51390aa4641eecb4a/greenlet-0.4.9.zip";
+      md5 = "c6659cdb2a5e591723e629d2eef22e82";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.mit ];
+    };
+  };
   gunicorn = super.buildPythonPackage {
     name = "gunicorn-19.6.0";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/84/ce/7ea5396efad1cef682bbc4068e72a0276341d9d9d0f501da609fab9fcb80/gunicorn-19.6.0.tar.gz";
       md5 = "338e5e8a83ea0f0625f768dba4597530";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   infrae.cache = super.buildPythonPackage {
     name = "infrae.cache-1.0.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [Beaker repoze.lru];
     src = fetchurl {
       url = "https://pypi.python.org/packages/bb/f0/e7d5e984cf6592fd2807dc7bc44a93f9d18e04e6a61f87fdfb2622422d74/infrae.cache-1.0.1.tar.gz";
       md5 = "b09076a766747e6ed2a755cc62088e32";
     };
     meta = {
       license = [ pkgs.lib.licenses.zpt21 ];
     };
   };
   invoke = super.buildPythonPackage {
     name = "invoke-0.13.0";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/47/bf/d07ef52fa1ac645468858bbac7cb95b246a972a045e821493d17d89c81be/invoke-0.13.0.tar.gz";
       md5 = "c0d1ed4bfb34eaab551662d8cfee6540";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   ipdb = super.buildPythonPackage {
     name = "ipdb-0.8";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [ipython];
     src = fetchurl {
       url = "https://pypi.python.org/packages/f0/25/d7dd430ced6cd8dc242a933c8682b5dbf32eb4011d82f87e34209e5ec845/ipdb-0.8.zip";
       md5 = "96dca0712efa01aa5eaf6b22071dd3ed";
     };
     meta = {
       license = [ pkgs.lib.licenses.gpl1 ];
     };
   };
   ipython = super.buildPythonPackage {
     name = "ipython-3.1.0";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/06/91/120c0835254c120af89f066afaabf81289bc2726c1fc3ca0555df6882f58/ipython-3.1.0.tar.gz";
       md5 = "a749d90c16068687b0ec45a27e72ef8f";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   iso8601 = super.buildPythonPackage {
     name = "iso8601-0.1.11";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/c0/75/c9209ee4d1b5975eb8c2cba4428bde6b61bd55664a98290dd015cdb18e98/iso8601-0.1.11.tar.gz";
       md5 = "b06d11cd14a64096f907086044f0fe38";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   itsdangerous = super.buildPythonPackage {
     name = "itsdangerous-0.24";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/dc/b4/a60bcdba945c00f6d608d8975131ab3f25b22f2bcfe1dab221165194b2d4/itsdangerous-0.24.tar.gz";
       md5 = "a3d55aa79369aef5345c036a8a26307f";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   kombu = super.buildPythonPackage {
     name = "kombu-1.5.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [anyjson amqplib];
     src = fetchurl {
       url = "https://pypi.python.org/packages/19/53/74bf2a624644b45f0850a638752514fc10a8e1cbd738f10804951a6df3f5/kombu-1.5.1.tar.gz";
       md5 = "50662f3c7e9395b3d0721fb75d100b63";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   lxml = super.buildPythonPackage {
     name = "lxml-3.4.4";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/63/c7/4f2a2a4ad6c6fa99b14be6b3c1cece9142e2d915aa7c43c908677afc8fa4/lxml-3.4.4.tar.gz";
       md5 = "a9a65972afc173ec7a39c585f4eea69c";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   mccabe = super.buildPythonPackage {
     name = "mccabe-0.3";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/c9/2e/75231479e11a906b64ac43bad9d0bb534d00080b18bdca8db9da46e1faf7/mccabe-0.3.tar.gz";
       md5 = "81640948ff226f8c12b3277059489157";
     };
     meta = {
       license = [ { fullName = "Expat license"; } pkgs.lib.licenses.mit ];
     };
   };
   meld3 = super.buildPythonPackage {
     name = "meld3-1.0.2";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/45/a0/317c6422b26c12fe0161e936fc35f36552069ba8e6f7ecbd99bbffe32a5f/meld3-1.0.2.tar.gz";
       md5 = "3ccc78cd79cffd63a751ad7684c02c91";
     };
     meta = {
       license = [ { fullName = "BSD-derived (http://www.repoze.org/LICENSE.txt)"; } ];
     };
   };
   mock = super.buildPythonPackage {
     name = "mock-1.0.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/15/45/30273ee91feb60dabb8fbb2da7868520525f02cf910279b3047182feed80/mock-1.0.1.zip";
       md5 = "869f08d003c289a97c1a6610faf5e913";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   msgpack-python = super.buildPythonPackage {
     name = "msgpack-python-0.4.6";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/15/ce/ff2840885789ef8035f66cd506ea05bdb228340307d5e71a7b1e3f82224c/msgpack-python-0.4.6.tar.gz";
       md5 = "8b317669314cf1bc881716cccdaccb30";
     };
     meta = {
       license = [ pkgs.lib.licenses.asl20 ];
     };
   };
   nose = super.buildPythonPackage {
     name = "nose-1.3.6";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/70/c7/469e68148d17a0d3db5ed49150242fd70a74a8147b8f3f8b87776e028d99/nose-1.3.6.tar.gz";
       md5 = "0ca546d81ca8309080fc80cb389e7a16";
     };
     meta = {
       license = [ { fullName = "GNU Library or Lesser General Public License (LGPL)"; } { fullName = "GNU LGPL"; } ];
     };
   };
   objgraph = super.buildPythonPackage {
     name = "objgraph-2.0.0";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/d7/33/ace750b59247496ed769b170586c5def7202683f3d98e737b75b767ff29e/objgraph-2.0.0.tar.gz";
       md5 = "25b0d5e5adc74aa63ead15699614159c";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   packaging = super.buildPythonPackage {
     name = "packaging-15.2";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/24/c4/185da1304f07047dc9e0c46c31db75c0351bd73458ac3efad7da3dbcfbe1/packaging-15.2.tar.gz";
       md5 = "c16093476f6ced42128bf610e5db3784";
     };
     meta = {
       license = [ pkgs.lib.licenses.asl20 ];
     };
   };
   paramiko = super.buildPythonPackage {
     name = "paramiko-1.15.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [pycrypto ecdsa];
     src = fetchurl {
       url = "https://pypi.python.org/packages/04/2b/a22d2a560c1951abbbf95a0628e245945565f70dc082d9e784666887222c/paramiko-1.15.1.tar.gz";
       md5 = "48c274c3f9b1282932567b21f6acf3b5";
     };
     meta = {
       license = [ { fullName = "LGPL"; } { fullName = "GNU Library or Lesser General Public License (LGPL)"; } ];
     };
   };
   pep8 = super.buildPythonPackage {
     name = "pep8-1.5.7";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/8b/de/259f5e735897ada1683489dd514b2a1c91aaa74e5e6b68f80acf128a6368/pep8-1.5.7.tar.gz";
       md5 = "f6adbdd69365ecca20513c709f9b7c93";
     };
     meta = {
       license = [ { fullName = "Expat license"; } pkgs.lib.licenses.mit ];
     };
   };
+  peppercorn = super.buildPythonPackage {
+    name = "peppercorn-0.5";
+    buildInputs = with self; [];
+    doCheck = false;
+    propagatedBuildInputs = with self; [];
+    src = fetchurl {
+      url = "https://pypi.python.org/packages/45/ec/a62ec317d1324a01567c5221b420742f094f05ee48097e5157d32be3755c/peppercorn-0.5.tar.gz";
+      md5 = "f08efbca5790019ab45d76b7244abd40";
+    };
+    meta = {
+      license = [ { fullName = "BSD-derived (http://www.repoze.org/LICENSE.txt)"; } ];
+    };
+  };
   psutil = super.buildPythonPackage {
     name = "psutil-2.2.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/df/47/ee54ef14dd40f8ce831a7581001a5096494dc99fe71586260ca6b531fe86/psutil-2.2.1.tar.gz";
       md5 = "1a2b58cd9e3a53528bb6148f0c4d5244";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   psycopg2 = super.buildPythonPackage {
-    name = "psycopg2-2.6";
+    name = "psycopg2-2.6.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/dd/c7/9016ff8ff69da269b1848276eebfb264af5badf6b38caad805426771f04d/psycopg2-2.6.tar.gz";
-      md5 = "fbbb039a8765d561a1c04969bbae7c74";
+      url = "https://pypi.python.org/packages/86/fd/cc8315be63a41fe000cce20482a917e874cdc1151e62cb0141f5e55f711e/psycopg2-2.6.1.tar.gz";
+      md5 = "842b44f8c95517ed5b792081a2370da1";
     };
     meta = {
       license = [ pkgs.lib.licenses.zpt21 { fullName = "GNU Library or Lesser General Public License (LGPL)"; } { fullName = "LGPL with exceptions or ZPL"; } ];
     };
   };
   py = super.buildPythonPackage {
     name = "py-1.4.29";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/2a/bc/a1a4a332ac10069b8e5e25136a35e08a03f01fd6ab03d819889d79a1fd65/py-1.4.29.tar.gz";
       md5 = "c28e0accba523a29b35a48bb703fb96c";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   py-bcrypt = super.buildPythonPackage {
     name = "py-bcrypt-0.4";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/68/b1/1c3068c5c4d2e35c48b38dcc865301ebfdf45f54507086ac65ced1fd3b3d/py-bcrypt-0.4.tar.gz";
       md5 = "dd8b367d6b716a2ea2e72392525f4e36";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
+  py-gfm = super.buildPythonPackage {
+    name = "py-gfm-0.1.3";
+    buildInputs = with self; [];
+    doCheck = false;
+    propagatedBuildInputs = with self; [setuptools Markdown];
+    src = fetchurl {
+      url = "https://pypi.python.org/packages/12/e4/6b3d8678da04f97d7490d8264d8de51c2dc9fb91209ccee9c515c95e14c5/py-gfm-0.1.3.tar.gz";
+      md5 = "e588d9e69640a241b97e2c59c22527a6";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.bsdOriginal ];
+    };
+  };
   pycrypto = super.buildPythonPackage {
     name = "pycrypto-2.6.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/60/db/645aa9af249f059cc3a368b118de33889219e0362141e75d4eaf6f80f163/pycrypto-2.6.1.tar.gz";
       md5 = "55a61a054aa66812daf5161a0d5d7eda";
     };
     meta = {
       license = [ pkgs.lib.licenses.publicDomain ];
     };
   };
   pycurl = super.buildPythonPackage {
     name = "pycurl-7.19.5";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/6c/48/13bad289ef6f4869b1d8fc11ae54de8cfb3cc4a2eb9f7419c506f763be46/pycurl-7.19.5.tar.gz";
       md5 = "47b4eac84118e2606658122104e62072";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit { fullName = "LGPL/MIT"; } { fullName = "GNU Library or Lesser General Public License (LGPL)"; } ];
     };
   };
   pyflakes = super.buildPythonPackage {
     name = "pyflakes-0.8.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/75/22/a90ec0252f4f87f3ffb6336504de71fe16a49d69c4538dae2f12b9360a38/pyflakes-0.8.1.tar.gz";
       md5 = "905fe91ad14b912807e8fdc2ac2e2c23";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   pyparsing = super.buildPythonPackage {
     name = "pyparsing-1.5.7";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/2e/26/e8fb5b4256a5f5036be7ce115ef8db8d06bc537becfbdc46c6af008314ee/pyparsing-1.5.7.zip";
       md5 = "b86854857a368d6ccb4d5b6e76d0637f";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   pyramid = super.buildPythonPackage {
     name = "pyramid-1.6.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [setuptools WebOb repoze.lru zope.interface zope.deprecation venusian translationstring PasteDeploy];
     src = fetchurl {
       url = "https://pypi.python.org/packages/30/b3/fcc4a2a4800cbf21989e00454b5828cf1f7fe35c63e0810b350e56d4c475/pyramid-1.6.1.tar.gz";
       md5 = "b18688ff3cc33efdbb098a35b45dd122";
     };
     meta = {
       license = [ { fullName = "Repoze Public License"; } { fullName = "BSD-derived (http://www.repoze.org/LICENSE.txt)"; } ];
     };
   };
   pyramid-beaker = super.buildPythonPackage {
     name = "pyramid-beaker-0.8";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [pyramid Beaker];
     src = fetchurl {
       url = "https://pypi.python.org/packages/d9/6e/b85426e00fd3d57f4545f74e1c3828552d8700f13ededeef9233f7bca8be/pyramid_beaker-0.8.tar.gz";
       md5 = "22f14be31b06549f80890e2c63a93834";
     };
     meta = {
       license = [ { fullName = "BSD-derived (http://www.repoze.org/LICENSE.txt)"; } ];
     };
   };
   pyramid-debugtoolbar = super.buildPythonPackage {
     name = "pyramid-debugtoolbar-2.4.2";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [pyramid pyramid-mako repoze.lru Pygments];
     src = fetchurl {
       url = "https://pypi.python.org/packages/89/00/ed5426ee41ed747ba3ffd30e8230841a6878286ea67d480b1444d24f06a2/pyramid_debugtoolbar-2.4.2.tar.gz";
       md5 = "073ea67086cc4bd5decc3a000853642d";
     };
     meta = {
       license = [ { fullName = "Repoze Public License"; } pkgs.lib.licenses.bsdOriginal ];
     };
   };
   pyramid-jinja2 = super.buildPythonPackage {
     name = "pyramid-jinja2-2.5";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [pyramid zope.deprecation Jinja2 MarkupSafe];
     src = fetchurl {
       url = "https://pypi.python.org/packages/a1/80/595e26ffab7deba7208676b6936b7e5a721875710f982e59899013cae1ed/pyramid_jinja2-2.5.tar.gz";
       md5 = "07cb6547204ac5e6f0b22a954ccee928";
     };
     meta = {
       license = [ { fullName = "Repoze Public License"; } { fullName = "BSD-derived (http://www.repoze.org/LICENSE.txt)"; } ];
     };
   };
   pyramid-mako = super.buildPythonPackage {
     name = "pyramid-mako-1.0.2";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [pyramid Mako];
     src = fetchurl {
       url = "https://pypi.python.org/packages/f1/92/7e69bcf09676d286a71cb3bbb887b16595b96f9ba7adbdc239ffdd4b1eb9/pyramid_mako-1.0.2.tar.gz";
       md5 = "ee25343a97eb76bd90abdc2a774eb48a";
     };
     meta = {
       license = [ { fullName = "Repoze Public License"; } { fullName = "BSD-derived (http://www.repoze.org/LICENSE.txt)"; } ];
     };
   };
   pysqlite = super.buildPythonPackage {
     name = "pysqlite-2.6.3";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/5c/a6/1c429cd4c8069cf4bfbd0eb4d592b3f4042155a8202df83d7e9b93aa3dc2/pysqlite-2.6.3.tar.gz";
       md5 = "7ff1cedee74646b50117acff87aa1cfa";
     };
     meta = {
       license = [ { fullName = "zlib/libpng License"; } { fullName = "zlib/libpng license"; } ];
     };
   };
   pytest = super.buildPythonPackage {
     name = "pytest-2.8.5";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [py];
     src = fetchurl {
       url = "https://pypi.python.org/packages/b1/3d/d7ea9b0c51e0cacded856e49859f0a13452747491e842c236bbab3714afe/pytest-2.8.5.zip";
       md5 = "8493b06f700862f1294298d6c1b715a9";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   pytest-catchlog = super.buildPythonPackage {
     name = "pytest-catchlog-1.2.2";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [py pytest];
     src = fetchurl {
       url = "https://pypi.python.org/packages/f2/2b/2faccdb1a978fab9dd0bf31cca9f6847fbe9184a0bdcc3011ac41dd44191/pytest-catchlog-1.2.2.zip";
       md5 = "09d890c54c7456c818102b7ff8c182c8";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   pytest-cov = super.buildPythonPackage {
     name = "pytest-cov-1.8.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [py pytest coverage cov-core];
     src = fetchurl {
       url = "https://pypi.python.org/packages/11/4b/b04646e97f1721878eb21e9f779102d84dd044d324382263b1770a3e4838/pytest-cov-1.8.1.tar.gz";
       md5 = "76c778afa2494088270348be42d759fc";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   pytest-profiling = super.buildPythonPackage {
     name = "pytest-profiling-1.0.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [six pytest gprof2dot];
     src = fetchurl {
       url = "https://pypi.python.org/packages/d8/67/8ffab73406e22870e07fa4dc8dce1d7689b26dba8efd00161c9b6fc01ec0/pytest-profiling-1.0.1.tar.gz";
       md5 = "354404eb5b3fd4dc5eb7fffbb3d9b68b";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   pytest-runner = super.buildPythonPackage {
     name = "pytest-runner-2.7.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/99/6b/c4ff4418d3424d4475b7af60724fd4a5cdd91ed8e489dc9443281f0052bc/pytest-runner-2.7.1.tar.gz";
       md5 = "e56f0bc8d79a6bd91772b44ef4215c7e";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   pytest-timeout = super.buildPythonPackage {
     name = "pytest-timeout-0.4";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [pytest];
     src = fetchurl {
       url = "https://pypi.python.org/packages/24/48/5f6bd4b8026a26e1dd427243d560a29a0f1b24a5c7cffca4bf049a7bb65b/pytest-timeout-0.4.tar.gz";
       md5 = "03b28aff69cbbfb959ed35ade5fde262";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit { fullName = "DFSG approved"; } ];
     };
   };
   python-dateutil = super.buildPythonPackage {
     name = "python-dateutil-1.5";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/b4/7c/df59c89a753eb33c7c44e1dd42de0e9bc2ccdd5a4d576e0bfad97cc280cb/python-dateutil-1.5.tar.gz";
       md5 = "0dcb1de5e5cad69490a3b6ab63f0cfa5";
     };
     meta = {
       license = [ pkgs.lib.licenses.psfl ];
     };
   };
   python-editor = super.buildPythonPackage {
     name = "python-editor-1.0.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/2b/c0/df7b87d5cf016f82eab3b05cd35f53287c1178ad8c42bfb6fa61b89b22f6/python-editor-1.0.1.tar.gz";
       md5 = "e1fa63535b40e022fa4fd646fd8b511a";
     };
     meta = {
       license = [ pkgs.lib.licenses.asl20 ];
     };
   };
   python-ldap = super.buildPythonPackage {
     name = "python-ldap-2.4.19";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [setuptools];
     src = fetchurl {
       url = "https://pypi.python.org/packages/42/81/1b64838c82e64f14d4e246ff00b52e650a35c012551b891ada2b85d40737/python-ldap-2.4.19.tar.gz";
       md5 = "b941bf31d09739492aa19ef679e94ae3";
     };
     meta = {
       license = [ pkgs.lib.licenses.psfl ];
     };
   };
   python-memcached = super.buildPythonPackage {
     name = "python-memcached-1.57";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [six];
     src = fetchurl {
       url = "https://pypi.python.org/packages/52/9d/eebc0dcbc5c7c66840ad207dfc1baa376dadb74912484bff73819cce01e6/python-memcached-1.57.tar.gz";
       md5 = "de21f64b42b2d961f3d4ad7beb5468a1";
     };
     meta = {
       license = [ pkgs.lib.licenses.psfl ];
     };
   };
   python-pam = super.buildPythonPackage {
     name = "python-pam-1.8.2";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/de/8c/f8f5d38b4f26893af267ea0b39023d4951705ab0413a39e0cf7cf4900505/python-pam-1.8.2.tar.gz";
       md5 = "db71b6b999246fb05d78ecfbe166629d";
     };
     meta = {
       license = [ { fullName = "License :: OSI Approved :: MIT License"; } pkgs.lib.licenses.mit ];
     };
   };
   pytz = super.buildPythonPackage {
     name = "pytz-2015.4";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/7e/1a/f43b5c92df7b156822030fed151327ea096bcf417e45acc23bd1df43472f/pytz-2015.4.zip";
       md5 = "233f2a2b370d03f9b5911700cc9ebf3c";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   pyzmq = super.buildPythonPackage {
     name = "pyzmq-14.6.0";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/8a/3b/5463d5a9d712cd8bbdac335daece0d69f6a6792da4e3dd89956c0db4e4e6/pyzmq-14.6.0.tar.gz";
       md5 = "395b5de95a931afa5b14c9349a5b8024";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal { fullName = "LGPL+BSD"; } { fullName = "GNU Library or Lesser General Public License (LGPL)"; } ];
     };
   };
   recaptcha-client = super.buildPythonPackage {
     name = "recaptcha-client-1.0.6";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/0a/ea/5f2fbbfd894bdac1c68ef8d92019066cfcf9fbff5fe3d728d2b5c25c8db4/recaptcha-client-1.0.6.tar.gz";
       md5 = "74228180f7e1fb76c4d7089160b0d919";
     };
     meta = {
       license = [ { fullName = "MIT/X11"; } ];
     };
   };
   repoze.lru = super.buildPythonPackage {
     name = "repoze.lru-0.6";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/6e/1e/aa15cc90217e086dc8769872c8778b409812ff036bf021b15795638939e4/repoze.lru-0.6.tar.gz";
       md5 = "2c3b64b17a8e18b405f55d46173e14dd";
     };
     meta = {
       license = [ { fullName = "Repoze Public License"; } { fullName = "BSD-derived (http://www.repoze.org/LICENSE.txt)"; } ];
     };
   };
   requests = super.buildPythonPackage {
     name = "requests-2.9.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/f9/6d/07c44fb1ebe04d069459a189e7dab9e4abfe9432adcd4477367c25332748/requests-2.9.1.tar.gz";
       md5 = "0b7f480d19012ec52bab78292efd976d";
     };
     meta = {
       license = [ pkgs.lib.licenses.asl20 ];
     };
   };
   rhodecode-enterprise-ce = super.buildPythonPackage {
-    name = "rhodecode-enterprise-ce-4.2.1";
+    name = "rhodecode-enterprise-ce-4.3.0";
     buildInputs = with self; [WebTest configobj cssselect flake8 lxml mock pytest pytest-cov pytest-runner];
     doCheck = true;
-    propagatedBuildInputs = with self; [Babel Beaker FormEncode Mako Markdown MarkupSafe MySQL-python Paste PasteDeploy PasteScript Pygments Pylons Pyro4 Routes SQLAlchemy Tempita URLObject WebError WebHelpers WebHelpers2 WebOb WebTest Whoosh alembic amqplib anyjson appenlight-client authomatic backport-ipaddress celery colander decorator docutils gunicorn infrae.cache ipython iso8601 kombu msgpack-python packaging psycopg2 pycrypto pycurl pyparsing pyramid pyramid-debugtoolbar pyramid-mako pyramid-beaker pysqlite python-dateutil python-ldap python-memcached python-pam recaptcha-client repoze.lru requests simplejson waitress zope.cachedescriptors psutil py-bcrypt];
+    propagatedBuildInputs = with self; [Babel Beaker FormEncode Mako Markdown MarkupSafe MySQL-python Paste PasteDeploy PasteScript Pygments Pylons Pyro4 Routes SQLAlchemy Tempita URLObject WebError WebHelpers WebHelpers2 WebOb WebTest Whoosh alembic amqplib anyjson appenlight-client authomatic backport-ipaddress celery channelstream colander decorator deform docutils gevent gunicorn infrae.cache ipython iso8601 kombu msgpack-python packaging psycopg2 py-gfm pycrypto pycurl pyparsing pyramid pyramid-debugtoolbar pyramid-mako pyramid-beaker pysqlite python-dateutil python-ldap python-memcached python-pam recaptcha-client repoze.lru requests simplejson waitress zope.cachedescriptors dogpile.cache dogpile.core psutil py-bcrypt];
     src = ./.;
     meta = {
       license = [ { fullName = "AGPLv3, and Commercial License"; } ];
     };
   };
   rhodecode-tools = super.buildPythonPackage {
-    name = "rhodecode-tools-0.8.3";
+    name = "rhodecode-tools-0.10.0";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [click future six Mako MarkupSafe requests Whoosh elasticsearch elasticsearch-dsl];
     src = fetchurl {
-      url = "https://code.rhodecode.com/rhodecode-tools-ce/archive/v0.8.3.zip";
-      md5 = "9acdfd71b8ddf4056057065f37ab9ccb";
+      url = "https://code.rhodecode.com/rhodecode-tools-ce/archive/v0.10.0.zip";
+      md5 = "4762391473ded761bead3aa58c748044";
     };
     meta = {
       license = [ { fullName = "AGPLv3 and Proprietary"; } ];
     };
   };
   serpent = super.buildPythonPackage {
     name = "serpent-1.12";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/3b/19/1e0e83b47c09edaef8398655088036e7e67386b5c48770218ebb339fbbd5/serpent-1.12.tar.gz";
       md5 = "05869ac7b062828b34f8f927f0457b65";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   setproctitle = super.buildPythonPackage {
     name = "setproctitle-1.1.8";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/33/c3/ad367a4f4f1ca90468863ae727ac62f6edb558fc09a003d344a02cfc6ea6/setproctitle-1.1.8.tar.gz";
       md5 = "728f4c8c6031bbe56083a48594027edd";
     };
     meta = {
       license = [ pkgs.lib.licenses.bsdOriginal ];
     };
   };
   setuptools = super.buildPythonPackage {
     name = "setuptools-20.8.1";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/c4/19/c1bdc88b53da654df43770f941079dbab4e4788c2dcb5658fb86259894c7/setuptools-20.8.1.zip";
       md5 = "fe58a5cac0df20bb83942b252a4b0543";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   setuptools-scm = super.buildPythonPackage {
     name = "setuptools-scm-1.11.0";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/cd/5f/e3a038292358058d83d764a47d09114aa5a8003ed4529518f9e580f1a94f/setuptools_scm-1.11.0.tar.gz";
       md5 = "4c5c896ba52e134bbc3507bac6400087";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   simplejson = super.buildPythonPackage {
     name = "simplejson-3.7.2";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/6d/89/7f13f099344eea9d6722779a1f165087cb559598107844b1ac5dbd831fb1/simplejson-3.7.2.tar.gz";
       md5 = "a5fc7d05d4cb38492285553def5d4b46";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit pkgs.lib.licenses.afl21 ];
     };
   };
   six = super.buildPythonPackage {
     name = "six-1.9.0";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/16/64/1dc5e5976b17466fd7d712e59cbe9fb1e18bec153109e5ba3ed6c9102f1a/six-1.9.0.tar.gz";
       md5 = "476881ef4012262dfc8adc645ee786c4";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   subprocess32 = super.buildPythonPackage {
     name = "subprocess32-3.2.6";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/28/8d/33ccbff51053f59ae6c357310cac0e79246bbed1d345ecc6188b176d72c3/subprocess32-3.2.6.tar.gz";
       md5 = "754c5ab9f533e764f931136974b618f1";
     };
     meta = {
       license = [ pkgs.lib.licenses.psfl ];
     };
   };
   supervisor = super.buildPythonPackage {
-    name = "supervisor-3.1.3";
+    name = "supervisor-3.3.0";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [meld3];
     src = fetchurl {
-      url = "https://pypi.python.org/packages/a6/41/65ad5bd66230b173eb4d0b8810230f3a9c59ef52ae066e540b6b99895db7/supervisor-3.1.3.tar.gz";
-      md5 = "aad263c4fbc070de63dd354864d5e552";
+      url = "https://pypi.python.org/packages/44/80/d28047d120bfcc8158b4e41127706731ee6a3419c661e0a858fb0e7c4b2d/supervisor-3.3.0.tar.gz";
+      md5 = "46bac00378d1eddb616752b990c67416";
     };
     meta = {
       license = [ { fullName = "BSD-derived (http://www.repoze.org/LICENSE.txt)"; } ];
     };
   };
   transifex-client = super.buildPythonPackage {
     name = "transifex-client-0.10";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/f3/4e/7b925192aee656fb3e04fa6381c8b3dc40198047c3b4a356f6cfd642c809/transifex-client-0.10.tar.gz";
       md5 = "5549538d84b8eede6b254cd81ae024fa";
     };
     meta = {
       license = [ pkgs.lib.licenses.gpl2 ];
     };
   };
   translationstring = super.buildPythonPackage {
     name = "translationstring-1.3";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/5e/eb/bee578cc150b44c653b63f5ebe258b5d0d812ddac12497e5f80fcad5d0b4/translationstring-1.3.tar.gz";
       md5 = "a4b62e0f3c189c783a1685b3027f7c90";
     };
     meta = {
       license = [ { fullName = "BSD-like (http://repoze.org/license.html)"; } ];
     };
   };
   trollius = super.buildPythonPackage {
     name = "trollius-1.0.4";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [futures];
     src = fetchurl {
       url = "https://pypi.python.org/packages/aa/e6/4141db437f55e6ee7a3fb69663239e3fde7841a811b4bef293145ad6c836/trollius-1.0.4.tar.gz";
       md5 = "3631a464d49d0cbfd30ab2918ef2b783";
     };
     meta = {
       license = [ pkgs.lib.licenses.asl20 ];
     };
   };
   uWSGI = super.buildPythonPackage {
     name = "uWSGI-2.0.11.2";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/9b/78/918db0cfab0546afa580c1e565209c49aaf1476bbfe491314eadbe47c556/uwsgi-2.0.11.2.tar.gz";
       md5 = "1f02dcbee7f6f61de4b1fd68350cf16f";
     };
     meta = {
       license = [ pkgs.lib.licenses.gpl2 ];
     };
   };
   urllib3 = super.buildPythonPackage {
     name = "urllib3-1.16";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/3b/f0/e763169124e3f5db0926bc3dbfcd580a105f9ca44cf5d8e6c7a803c9f6b5/urllib3-1.16.tar.gz";
       md5 = "fcaab1c5385c57deeb7053d3d7d81d59";
     };
     meta = {
       license = [ pkgs.lib.licenses.mit ];
     };
   };
   venusian = super.buildPythonPackage {
     name = "venusian-1.0";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/86/20/1948e0dfc4930ddde3da8c33612f6a5717c0b4bc28f591a5c5cf014dd390/venusian-1.0.tar.gz";
       md5 = "dccf2eafb7113759d60c86faf5538756";
     };
     meta = {
       license = [ { fullName = "BSD-derived (http://www.repoze.org/LICENSE.txt)"; } ];
     };
   };
   waitress = super.buildPythonPackage {
     name = "waitress-0.8.9";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [setuptools];
     src = fetchurl {
       url = "https://pypi.python.org/packages/ee/65/fc9dee74a909a1187ca51e4f15ad9c4d35476e4ab5813f73421505c48053/waitress-0.8.9.tar.gz";
       md5 = "da3f2e62b3676be5dd630703a68e2a04";
     };
     meta = {
       license = [ pkgs.lib.licenses.zpt21 ];
     };
   };
+  ws4py = super.buildPythonPackage {
+    name = "ws4py-0.3.5";
+    buildInputs = with self; [];
+    doCheck = false;
+    propagatedBuildInputs = with self; [];
+    src = fetchurl {
+      url = "https://pypi.python.org/packages/b6/4f/34af703be86939629479e74d6e650e39f3bd73b3b09212c34e5125764cbc/ws4py-0.3.5.zip";
+      md5 = "a261b75c20b980e55ce7451a3576a867";
+    };
+    meta = {
+      license = [ pkgs.lib.licenses.bsdOriginal ];
+    };
+  };
   wsgiref = super.buildPythonPackage {
     name = "wsgiref-0.1.2";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [];
     src = fetchurl {
       url = "https://pypi.python.org/packages/41/9e/309259ce8dff8c596e8c26df86dbc4e848b9249fd36797fd60be456f03fc/wsgiref-0.1.2.zip";
       md5 = "29b146e6ebd0f9fb119fe321f7bcf6cb";
     };
     meta = {
       license = [ { fullName = "PSF or ZPL"; } ];
     };
   };
   zope.cachedescriptors = super.buildPythonPackage {
     name = "zope.cachedescriptors-4.0.0";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [setuptools];
     src = fetchurl {
       url = "https://pypi.python.org/packages/40/33/694b6644c37f28553f4b9f20b3c3a20fb709a22574dff20b5bdffb09ecd5/zope.cachedescriptors-4.0.0.tar.gz";
       md5 = "8d308de8c936792c8e758058fcb7d0f0";
     };
     meta = {
       license = [ pkgs.lib.licenses.zpt21 ];
     };
   };
   zope.deprecation = super.buildPythonPackage {
     name = "zope.deprecation-4.1.2";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [setuptools];
     src = fetchurl {
       url = "https://pypi.python.org/packages/c1/d3/3919492d5e57d8dd01b36f30b34fc8404a30577392b1eb817c303499ad20/zope.deprecation-4.1.2.tar.gz";
       md5 = "e9a663ded58f4f9f7881beb56cae2782";
     };
     meta = {
       license = [ pkgs.lib.licenses.zpt21 ];
     };
   };
   zope.event = super.buildPythonPackage {
     name = "zope.event-4.0.3";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [setuptools];
     src = fetchurl {
       url = "https://pypi.python.org/packages/c1/29/91ba884d7d6d96691df592e9e9c2bfa57a47040ec1ff47eff18c85137152/zope.event-4.0.3.tar.gz";
       md5 = "9a3780916332b18b8b85f522bcc3e249";
     };
     meta = {
       license = [ pkgs.lib.licenses.zpt21 ];
     };
   };
   zope.interface = super.buildPythonPackage {
     name = "zope.interface-4.1.3";
     buildInputs = with self; [];
     doCheck = false;
     propagatedBuildInputs = with self; [setuptools];
     src = fetchurl {
       url = "https://pypi.python.org/packages/9d/81/2509ca3c6f59080123c1a8a97125eb48414022618cec0e64eb1313727bfe/zope.interface-4.1.3.tar.gz";
       md5 = "9ae3d24c0c7415deb249dd1a132f0f79";
     };
     meta = {
       license = [ pkgs.lib.licenses.zpt21 ];
     };
   };
 
 ### Test requirements
 
   
 }

requirements.txt

@@ -1,150 +1,151 b''
 Babel==1.3
 Beaker==1.7.0
 CProfileV==1.0.6
 Fabric==1.10.0
 FormEncode==1.2.4
 Jinja2==2.7.3
 Mako==1.0.1
 Markdown==2.6.2
 MarkupSafe==0.23
 MySQL-python==1.2.5
 Paste==2.0.2
 PasteDeploy==1.5.2
 PasteScript==1.7.5
-Pygments==2.0.2
+Pygments==2.1.3
 
 # TODO: This version is not available on PyPI
 # Pylons==1.0.2.dev20160108
 Pylons==1.0.1
 
 # TODO: This version is not available, but newer ones are
 # Pyro4==4.35
 Pyro4==4.41
 
 # TODO: This should probably not be in here
 # -e hg+https://[e-mail]/johbo/rhodecode-fork@3a454bd1f17c0b2b2a951cf2b111e0320d7942a9#egg=RhodeCodeEnterprise-dev
 
-# TODO: This is not really a dependency, we should add it only
-# into the development environment, since there it is useful.
-# RhodeCodeVCSServer==3.9.0
-
 Routes==1.13
 SQLAlchemy==0.9.9
 Sphinx==1.2.2
 Tempita==0.5.2
 URLObject==2.4.0
 WebError==0.10.3
 
 # TODO: This is modified by us, needs a better integration. For now
 # using the latest version before.
 # WebHelpers==1.3.dev20150807
 WebHelpers==1.3
 
 WebHelpers2==2.0
 WebOb==1.3.1
 WebTest==1.4.3
 Whoosh==2.7.0
 alembic==0.8.4
 amqplib==1.0.2
 anyjson==0.3.3
 appenlight-client==0.6.14
 authomatic==0.1.0.post1;
 backport-ipaddress==0.1
 bottle==0.12.8
 bumpversion==0.5.3
 celery==2.2.10
+channelstream==0.5.2
 click==5.1
 colander==1.2
 configobj==5.0.6
 cov-core==1.15.0
 coverage==3.7.1
 cssselect==0.9.1
 decorator==3.4.2
+deform==2.0a2
 docutils==0.12
-dogpile.cache==0.5.7
+dogpile.cache==0.6.1
 dogpile.core==0.4.1
 dulwich==0.12.0
 ecdsa==0.11
 flake8==2.4.1
 future==0.14.3
 futures==3.0.2
+gevent==1.1.1
 gprof2dot==2015.12.1
+greenlet==0.4.9
 gunicorn==19.6.0
 
 # TODO: Needs subvertpy and blows up without Subversion headers,
 # actually we should not need this for Enterprise at all.
 # hgsubversion==1.8.2
 
 gnureadline==6.3.3
 infrae.cache==1.0.1
 invoke==0.13.0
 ipdb==0.8
 ipython==3.1.0
 iso8601==0.1.11
 itsdangerous==0.24
 kombu==1.5.1
 lxml==3.4.4
 mccabe==0.3
 meld3==1.0.2
 mock==1.0.1
 msgpack-python==0.4.6
 nose==1.3.6
 objgraph==2.0.0
 packaging==15.2
 paramiko==1.15.1
 pep8==1.5.7
 psutil==2.2.1
-psycopg2==2.6
+psycopg2==2.6.1
 py==1.4.29
 py-bcrypt==0.4
+py-gfm==0.1.3
 pycrypto==2.6.1
 pycurl==7.19.5
 pyflakes==0.8.1
 pyparsing==1.5.7
 pyramid==1.6.1
 pyramid-beaker==0.8
 pyramid-debugtoolbar==2.4.2
 pyramid-jinja2==2.5
 pyramid-mako==1.0.2
 pysqlite==2.6.3
 pytest==2.8.5
 pytest-runner==2.7.1
 pytest-catchlog==1.2.2
 pytest-cov==1.8.1
 pytest-profiling==1.0.1
 pytest-timeout==0.4
 python-dateutil==1.5
 python-ldap==2.4.19
 python-memcached==1.57
 python-pam==1.8.2
 pytz==2015.4
 pyzmq==14.6.0
 
 # TODO: This is not available in public
 # rc-testdata==0.2.0
 
-https://code.rhodecode.com/rhodecode-tools-ce/archive/v0.8.3.zip#md5=9acdfd71b8ddf4056057065f37ab9ccb
+https://code.rhodecode.com/rhodecode-tools-ce/archive/v0.10.0.zip#md5=4762391473ded761bead3aa58c748044
 
 
 recaptcha-client==1.0.6
 repoze.lru==0.6
 requests==2.9.1
 serpent==1.12
 setproctitle==1.1.8
 setuptools==20.8.1
 setuptools-scm==1.11.0
 simplejson==3.7.2
 six==1.9.0
 subprocess32==3.2.6
-supervisor==3.1.3
+supervisor==3.3.0
 transifex-client==0.10
 translationstring==1.3
 trollius==1.0.4
 uWSGI==2.0.11.2
 venusian==1.0
 waitress==0.8.9
 wsgiref==0.1.2
 zope.cachedescriptors==4.0.0
 zope.deprecation==4.1.2
 zope.event==4.0.3
 zope.interface==4.1.3

rhodecode/VERSION

@@ -1,1 +1,1 b''
-4.2.1
  No newline at end of file
+4.3.0
  No newline at end of file

rhodecode/__init__.py

@@ -1,58 +1,62 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 
 RhodeCode, a web based repository management software
 versioning implementation: http://www.python.org/dev/peps/pep-0386/
 """
 
 import os
 import sys
 import platform
 
 VERSION = tuple(open(os.path.join(
     os.path.dirname(__file__), 'VERSION')).read().split('.'))
 
 BACKENDS = {
     'hg': 'Mercurial repository',
     'git': 'Git repository',
     'svn': 'Subversion repository',
 }
 
 CELERY_ENABLED = False
 CELERY_EAGER = False
 
 # link to config for pylons
 CONFIG = {}
 
+# Populated with the settings dictionary from application init in
+# rhodecode.conf.environment.load_pyramid_environment
+PYRAMID_SETTINGS = {}
+
 # Linked module for extensions
 EXTENSIONS = {}
 
 __version__ = ('.'.join((str(each) for each in VERSION[:3])))
-__dbversion__ = 54  # defines current db version for migrations
+__dbversion__ = 55  # defines current db version for migrations
 __platform__ = platform.system()
 __license__ = 'AGPLv3, and Commercial License'
 __author__ = 'RhodeCode GmbH'
 __url__ = 'http://rhodecode.com'
 
 is_windows = __platform__ in ['Windows']
 is_unix = not is_windows
 is_test = False

rhodecode/admin/navigation.py

@@ -1,124 +1,126 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 import logging
 import collections
 
 from pylons import url
 from zope.interface import implementer
 
 from rhodecode.admin.interfaces import IAdminNavigationRegistry
 from rhodecode.lib.utils import get_registry
 from rhodecode.translation import _
 
 
 log = logging.getLogger(__name__)
 
 NavListEntry = collections.namedtuple('NavListEntry', ['key', 'name', 'url'])
 
 
 class NavEntry(object):
     """
     Represents an entry in the admin navigation.
 
     :param key: Unique identifier used to store reference in an OrderedDict.
     :param name: Display name, usually a translation string.
     :param view_name: Name of the view, used generate the URL.
     :param pyramid: Indicator to use pyramid for URL generation. This should
         be removed as soon as we are fully migrated to pyramid.
     """
 
     def __init__(self, key, name, view_name, pyramid=False):
         self.key = key
         self.name = name
         self.view_name = view_name
         self.pyramid = pyramid
 
     def generate_url(self, request):
         if self.pyramid:
             if hasattr(request, 'route_path'):
                 return request.route_path(self.view_name)
             else:
                 # TODO: johbo: Remove this after migrating to pyramid.
                 # We need the pyramid request here to generate URLs to pyramid
                 # views from within pylons views.
                 from pyramid.threadlocal import get_current_request
                 pyramid_request = get_current_request()
                 return pyramid_request.route_path(self.view_name)
         else:
             return url(self.view_name)
 
 
 @implementer(IAdminNavigationRegistry)
 class NavigationRegistry(object):
 
     _base_entries = [
         NavEntry('global', _('Global'), 'admin_settings_global'),
         NavEntry('vcs', _('VCS'), 'admin_settings_vcs'),
         NavEntry('visual', _('Visual'), 'admin_settings_visual'),
         NavEntry('mapping', _('Remap and Rescan'), 'admin_settings_mapping'),
         NavEntry('issuetracker', _('Issue Tracker'),
                  'admin_settings_issuetracker'),
         NavEntry('email', _('Email'), 'admin_settings_email'),
         NavEntry('hooks', _('Hooks'), 'admin_settings_hooks'),
         NavEntry('search', _('Full Text Search'), 'admin_settings_search'),
+        NavEntry('integrations', _('Integrations'),
+                 'global_integrations_home', pyramid=True),
         NavEntry('system', _('System Info'), 'admin_settings_system'),
         NavEntry('open_source', _('Open Source Licenses'),
                  'admin_settings_open_source', pyramid=True),
         # TODO: marcink: we disable supervisor now until the supervisor stats
         # page is fixed in the nix configuration
         # NavEntry('supervisor', _('Supervisor'), 'admin_settings_supervisor'),
     ]
 
     _labs_entry = NavEntry('labs', _('Labs'),
                            'admin_settings_labs')
 
     def __init__(self, labs_active=False):
         self._registered_entries = collections.OrderedDict([
             (item.key, item) for item in self.__class__._base_entries
         ])
 
         if labs_active:
             self.add_entry(self._labs_entry)
 
     def add_entry(self, entry):
         self._registered_entries[entry.key] = entry
 
     def get_navlist(self, request):
         navlist = [NavListEntry(i.key, i.name, i.generate_url(request))
                    for i in self._registered_entries.values()]
         return navlist
 
 
 def navigation_registry(request):
     """
     Helper that returns the admin navigation registry.
     """
     pyramid_registry = get_registry(request)
     nav_registry = pyramid_registry.queryUtility(IAdminNavigationRegistry)
     return nav_registry
 
 
 def navigation_list(request):
     """
     Helper that returns the admin navigation as list of NavListEntry objects.
     """
     return navigation_registry(request).get_navlist(request)

rhodecode/api/__init__.py

@@ -1,497 +1,505 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2011-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import inspect
 import itertools
 import logging
 import types
 
 import decorator
 import venusian
+from collections import OrderedDict
+
 from pyramid.exceptions import ConfigurationError
 from pyramid.renderers import render
 from pyramid.response import Response
 from pyramid.httpexceptions import HTTPNotFound
 
-from rhodecode.api.exc import JSONRPCBaseError, JSONRPCError, JSONRPCForbidden
+from rhodecode.api.exc import (
+    JSONRPCBaseError, JSONRPCError, JSONRPCForbidden, JSONRPCValidationError)
 from rhodecode.lib.auth import AuthUser
 from rhodecode.lib.base import get_ip_addr
 from rhodecode.lib.ext_json import json
 from rhodecode.lib.utils2 import safe_str
 from rhodecode.lib.plugins.utils import get_plugin_settings
 from rhodecode.model.db import User, UserApiKeys
 
 log = logging.getLogger(__name__)
 
 DEFAULT_RENDERER = 'jsonrpc_renderer'
 DEFAULT_URL = '/_admin/apiv2'
 
 
 class ExtJsonRenderer(object):
     """
     Custom renderer that mkaes use of our ext_json lib
 
     """
 
     def __init__(self, serializer=json.dumps, **kw):
         """ Any keyword arguments will be passed to the ``serializer``
         function."""
         self.serializer = serializer
         self.kw = kw
 
     def __call__(self, info):
         """ Returns a plain JSON-encoded string with content-type
         ``application/json``. The content-type may be overridden by
         setting ``request.response.content_type``."""
 
         def _render(value, system):
             request = system.get('request')
             if request is not None:
                 response = request.response
                 ct = response.content_type
                 if ct == response.default_content_type:
                     response.content_type = 'application/json'
 
             return self.serializer(value, **self.kw)
 
         return _render
 
 
 def jsonrpc_response(request, result):
     rpc_id = getattr(request, 'rpc_id', None)
     response = request.response
 
     # store content_type before render is called
     ct = response.content_type
 
     ret_value = ''
     if rpc_id:
         ret_value = {
             'id': rpc_id,
             'result': result,
             'error': None,
         }
 
         # fetch deprecation warnings, and store it inside results
         deprecation = getattr(request, 'rpc_deprecation', None)
         if deprecation:
             ret_value['DEPRECATION_WARNING'] = deprecation
 
     raw_body = render(DEFAULT_RENDERER, ret_value, request=request)
     response.body = safe_str(raw_body, response.charset)
 
     if ct == response.default_content_type:
         response.content_type = 'application/json'
 
     return response
 
 
 def jsonrpc_error(request, message, retid=None, code=None):
     """
     Generate a Response object with a JSON-RPC error body
 
     :param code:
     :param retid:
     :param message:
     """
     err_dict = {'id': retid, 'result': None, 'error': message}
     body = render(DEFAULT_RENDERER, err_dict, request=request).encode('utf-8')
     return Response(
         body=body,
         status=code,
         content_type='application/json'
     )
 
 
 def exception_view(exc, request):
     rpc_id = getattr(request, 'rpc_id', None)
 
     fault_message = 'undefined error'
     if isinstance(exc, JSONRPCError):
         fault_message = exc.message
         log.debug('json-rpc error rpc_id:%s "%s"', rpc_id, fault_message)
+    elif isinstance(exc, JSONRPCValidationError):
+        colander_exc = exc.colander_exception
+        #TODO: think maybe of nicer way to serialize errors ?
+        fault_message = colander_exc.asdict()
+        log.debug('json-rpc error rpc_id:%s "%s"', rpc_id, fault_message)
     elif isinstance(exc, JSONRPCForbidden):
         fault_message = 'Access was denied to this resource.'
         log.warning('json-rpc forbidden call rpc_id:%s "%s"', rpc_id, fault_message)
     elif isinstance(exc, HTTPNotFound):
         method = request.rpc_method
         log.debug('json-rpc method `%s` not found in list of '
                   'api calls: %s, rpc_id:%s',
                   method, request.registry.jsonrpc_methods.keys(), rpc_id)
         fault_message = "No such method: {}".format(method)
 
     return jsonrpc_error(request, fault_message, rpc_id)
 
 
 def request_view(request):
     """
     Main request handling method. It handles all logic to call a specific
     exposed method
     """
 
     # check if we can find this session using api_key, get_by_auth_token
     # search not expired tokens only
 
     try:
         u = User.get_by_auth_token(request.rpc_api_key)
 
         if u is None:
             return jsonrpc_error(
                 request, retid=request.rpc_id, message='Invalid API KEY')
 
         if not u.active:
             return jsonrpc_error(
                 request, retid=request.rpc_id,
                 message='Request from this user not allowed')
 
         # check if we are allowed to use this IP
         auth_u = AuthUser(
             u.user_id, request.rpc_api_key, ip_addr=request.rpc_ip_addr)
         if not auth_u.ip_allowed:
             return jsonrpc_error(
                 request, retid=request.rpc_id,
                 message='Request from IP:%s not allowed' % (
                 request.rpc_ip_addr,))
         else:
             log.info('Access for IP:%s allowed' % (request.rpc_ip_addr,))
 
         # now check if token is valid for API
         role = UserApiKeys.ROLE_API
         extra_auth_tokens = [
             x.api_key for x in User.extra_valid_auth_tokens(u, role=role)]
         active_tokens = [u.api_key] + extra_auth_tokens
 
         log.debug('Checking if API key has proper role')
         if request.rpc_api_key not in active_tokens:
             return jsonrpc_error(
                 request, retid=request.rpc_id,
                 message='API KEY has bad role for an API call')
 
     except Exception as e:
         log.exception('Error on API AUTH')
         return jsonrpc_error(
             request, retid=request.rpc_id, message='Invalid API KEY')
 
     method = request.rpc_method
     func = request.registry.jsonrpc_methods[method]
 
     # now that we have a method, add request._req_params to
     # self.kargs and dispatch control to WGIController
     argspec = inspect.getargspec(func)
     arglist = argspec[0]
     defaults = map(type, argspec[3] or [])
     default_empty = types.NotImplementedType
 
     # kw arguments required by this method
     func_kwargs = dict(itertools.izip_longest(
         reversed(arglist), reversed(defaults), fillvalue=default_empty))
 
     # This attribute will need to be first param of a method that uses
     # api_key, which is translated to instance of user at that name
     user_var = 'apiuser'
     request_var = 'request'
 
     for arg in [user_var, request_var]:
         if arg not in arglist:
             return jsonrpc_error(
                 request,
                 retid=request.rpc_id,
                 message='This method [%s] does not support '
                         'required parameter `%s`' % (func.__name__, arg))
 
     # get our arglist and check if we provided them as args
     for arg, default in func_kwargs.items():
         if arg in [user_var, request_var]:
             # user_var and request_var are pre-hardcoded parameters and we
             # don't need to do any translation
             continue
 
         # skip the required param check if it's default value is
         # NotImplementedType (default_empty)
         if default == default_empty and arg not in request.rpc_params:
             return jsonrpc_error(
                 request,
                 retid=request.rpc_id,
                 message=('Missing non optional `%s` arg in JSON DATA' % arg)
             )
 
     # sanitze extra passed arguments
     for k in request.rpc_params.keys()[:]:
         if k not in func_kwargs:
             del request.rpc_params[k]
 
     call_params = request.rpc_params
     call_params.update({
         'request': request,
         'apiuser': auth_u
     })
     try:
         ret_value = func(**call_params)
         return jsonrpc_response(request, ret_value)
     except JSONRPCBaseError:
         raise
     except Exception:
         log.exception('Unhandled exception occured on api call: %s', func)
         return jsonrpc_error(request, retid=request.rpc_id,
                              message='Internal server error')
 
 
 def setup_request(request):
     """
     Parse a JSON-RPC request body. It's used inside the predicates method
     to validate and bootstrap requests for usage in rpc calls.
 
     We need to raise JSONRPCError here if we want to return some errors back to
     user.
     """
     log.debug('Executing setup request: %r', request)
     request.rpc_ip_addr = get_ip_addr(request.environ)
     # TODO: marcink, deprecate GET at some point
     if request.method not in ['POST', 'GET']:
         log.debug('unsupported request method "%s"', request.method)
         raise JSONRPCError(
             'unsupported request method "%s". Please use POST' % request.method)
 
     if 'CONTENT_LENGTH' not in request.environ:
         log.debug("No Content-Length")
         raise JSONRPCError("Empty body, No Content-Length in request")
 
     else:
         length = request.environ['CONTENT_LENGTH']
         log.debug('Content-Length: %s', length)
 
         if length == 0:
             log.debug("Content-Length is 0")
             raise JSONRPCError("Content-Length is 0")
 
     raw_body = request.body
     try:
         json_body = json.loads(raw_body)
     except ValueError as e:
         # catch JSON errors Here
         raise JSONRPCError("JSON parse error ERR:%s RAW:%r" % (e, raw_body))
 
     request.rpc_id = json_body.get('id')
     request.rpc_method = json_body.get('method')
 
     # check required base parameters
     try:
         api_key = json_body.get('api_key')
         if not api_key:
             api_key = json_body.get('auth_token')
 
         if not api_key:
             raise KeyError('api_key or auth_token')
 
         request.rpc_api_key = api_key
         request.rpc_id = json_body['id']
         request.rpc_method = json_body['method']
         request.rpc_params = json_body['args'] \
             if isinstance(json_body['args'], dict) else {}
 
         log.debug(
             'method: %s, params: %s' % (request.rpc_method, request.rpc_params))
     except KeyError as e:
         raise JSONRPCError('Incorrect JSON data. Missing %s' % e)
 
     log.debug('setup complete, now handling method:%s rpcid:%s',
               request.rpc_method, request.rpc_id, )
 
 
 class RoutePredicate(object):
     def __init__(self, val, config):
         self.val = val
 
     def text(self):
         return 'jsonrpc route = %s' % self.val
 
     phash = text
 
     def __call__(self, info, request):
         if self.val:
             # potentially setup and bootstrap our call
             setup_request(request)
 
             # Always return True so that even if it isn't a valid RPC it
             # will fall through to the underlaying handlers like notfound_view
             return True
 
 
 class NotFoundPredicate(object):
     def __init__(self, val, config):
         self.val = val
 
     def text(self):
         return 'jsonrpc method not found = %s' % self.val
 
     phash = text
 
     def __call__(self, info, request):
         return hasattr(request, 'rpc_method')
 
 
 class MethodPredicate(object):
     def __init__(self, val, config):
         self.method = val
 
     def text(self):
         return 'jsonrpc method = %s' % self.method
 
     phash = text
 
     def __call__(self, context, request):
         # we need to explicitly return False here, so pyramid doesn't try to
         # execute our view directly. We need our main handler to execute things
         return getattr(request, 'rpc_method') == self.method
 
 
 def add_jsonrpc_method(config, view, **kwargs):
     # pop the method name
     method = kwargs.pop('method', None)
 
     if method is None:
         raise ConfigurationError(
             'Cannot register a JSON-RPC method without specifying the '
             '"method"')
 
     # we define custom predicate, to enable to detect conflicting methods,
     # those predicates are kind of "translation" from the decorator variables
     # to internal predicates names
 
     kwargs['jsonrpc_method'] = method
 
     # register our view into global view store for validation
     config.registry.jsonrpc_methods[method] = view
 
     # we're using our main request_view handler, here, so each method
     # has a unified handler for itself
     config.add_view(request_view, route_name='apiv2', **kwargs)
 
 
 class jsonrpc_method(object):
     """
     decorator that works similar to @add_view_config decorator,
     but tailored for our JSON RPC
     """
 
     venusian = venusian  # for testing injection
 
     def __init__(self, method=None, **kwargs):
         self.method = method
         self.kwargs = kwargs
 
     def __call__(self, wrapped):
         kwargs = self.kwargs.copy()
         kwargs['method'] = self.method or wrapped.__name__
         depth = kwargs.pop('_depth', 0)
 
         def callback(context, name, ob):
             config = context.config.with_package(info.module)
             config.add_jsonrpc_method(view=ob, **kwargs)
 
         info = venusian.attach(wrapped, callback, category='pyramid',
                                depth=depth + 1)
         if info.scope == 'class':
             # ensure that attr is set if decorating a class method
             kwargs.setdefault('attr', wrapped.__name__)
 
         kwargs['_info'] = info.codeinfo  # fbo action_method
         return wrapped
 
 
 class jsonrpc_deprecated_method(object):
     """
     Marks method as deprecated, adds log.warning, and inject special key to
     the request variable to mark method as deprecated.
     Also injects special docstring that extract_docs will catch to mark
     method as deprecated.
 
     :param use_method: specify which method should be used instead of
         the decorated one
 
     Use like::
 
         @jsonrpc_method()
         @jsonrpc_deprecated_method(use_method='new_func', deprecated_at_version='3.0.0')
         def old_func(request, apiuser, arg1, arg2):
             ...
     """
 
     def __init__(self, use_method, deprecated_at_version):
         self.use_method = use_method
         self.deprecated_at_version = deprecated_at_version
         self.deprecated_msg = ''
 
     def __call__(self, func):
         self.deprecated_msg = 'Please use method `{method}` instead.'.format(
             method=self.use_method)
 
         docstring = """\n
         .. deprecated:: {version}
 
            {deprecation_message}
 
         {original_docstring}
         """
         func.__doc__ = docstring.format(
             version=self.deprecated_at_version,
             deprecation_message=self.deprecated_msg,
             original_docstring=func.__doc__)
         return decorator.decorator(self.__wrapper, func)
 
     def __wrapper(self, func, *fargs, **fkwargs):
         log.warning('DEPRECATED API CALL on function %s, please '
                     'use `%s` instead', func, self.use_method)
         # alter function docstring to mark as deprecated, this is picked up
         # via fabric file that generates API DOC.
         result = func(*fargs, **fkwargs)
 
         request = fargs[0]
         request.rpc_deprecation = 'DEPRECATED METHOD ' + self.deprecated_msg
         return result
 
 
 def includeme(config):
     plugin_module = 'rhodecode.api'
     plugin_settings = get_plugin_settings(
         plugin_module, config.registry.settings)
 
     if not hasattr(config.registry, 'jsonrpc_methods'):
-        config.registry.jsonrpc_methods = {}
+        config.registry.jsonrpc_methods = OrderedDict()
 
     # match filter by given method only
     config.add_view_predicate(
         'jsonrpc_method', MethodPredicate)
 
     config.add_renderer(DEFAULT_RENDERER, ExtJsonRenderer(
         serializer=json.dumps, indent=4))
     config.add_directive('add_jsonrpc_method', add_jsonrpc_method)
 
     config.add_route_predicate(
         'jsonrpc_call', RoutePredicate)
 
     config.add_route(
         'apiv2', plugin_settings.get('url', DEFAULT_URL), jsonrpc_call=True)
 
     config.scan(plugin_module, ignore='rhodecode.api.tests')
     # register some exception handling view
     config.add_view(exception_view, context=JSONRPCBaseError)
     config.add_view_predicate('jsonrpc_method_not_found', NotFoundPredicate)
     config.add_notfound_view(exception_view, jsonrpc_method_not_found=True)

rhodecode/api/exc.py

@@ -1,31 +1,39 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2011-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 class JSONRPCBaseError(Exception):
     pass
 
 
 class JSONRPCError(JSONRPCBaseError):
     pass
 
 
+class JSONRPCValidationError(JSONRPCBaseError):
+
+    def __init__(self, *args, **kwargs):
+        self.colander_exception = kwargs.pop('colander_exc')
+        super(JSONRPCValidationError, self).__init__(*args, **kwargs)
+
+
 class JSONRPCForbidden(JSONRPCBaseError):
     pass
+

rhodecode/api/tests/test_create_gist.py

@@ -1,76 +1,102 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import mock
 import pytest
 
 from rhodecode.model.db import Gist
 from rhodecode.model.gist import GistModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash)
 from rhodecode.tests.fixture import Fixture
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestApiCreateGist(object):
     @pytest.mark.parametrize("lifetime, gist_type, gist_acl_level", [
         (10, Gist.GIST_PUBLIC, Gist.ACL_LEVEL_PUBLIC),
         (20, Gist.GIST_PUBLIC, Gist.ACL_LEVEL_PRIVATE),
         (40, Gist.GIST_PRIVATE, Gist.ACL_LEVEL_PUBLIC),
         (80, Gist.GIST_PRIVATE, Gist.ACL_LEVEL_PRIVATE),
     ])
     def test_api_create_gist(self, lifetime, gist_type, gist_acl_level):
         id_, params = build_data(
             self.apikey_regular, 'create_gist',
             lifetime=lifetime,
             description='foobar-gist',
             gist_type=gist_type,
             acl_level=gist_acl_level,
-            files={'foobar': {'content': 'foo'}})
+            files={'foobar_ąć': {'content': 'foo'}})
         response = api_call(self.app, params)
         response_json = response.json
         gist = response_json['result']['gist']
         expected = {
             'gist': {
                 'access_id': gist['access_id'],
                 'created_on': gist['created_on'],
                 'modified_at': gist['modified_at'],
                 'description': 'foobar-gist',
                 'expires': gist['expires'],
                 'gist_id': gist['gist_id'],
                 'type': gist_type,
                 'url': gist['url'],
                 # content is empty since we don't show it here
                 'content': None,
                 'acl_level': gist_acl_level,
             },
             'msg': 'created new gist'
         }
         try:
             assert_ok(id_, expected, given=response.body)
         finally:
             Fixture().destroy_gists()
 
+    @pytest.mark.parametrize("expected, lifetime, gist_type, gist_acl_level, files", [
+        ({'gist_type': '"ups" is not one of private, public'},
+         10, 'ups', Gist.ACL_LEVEL_PUBLIC, {'f': {'content': 'f'}}),
+
+        ({'lifetime': '-120 is less than minimum value -1'},
+         -120, Gist.GIST_PUBLIC, Gist.ACL_LEVEL_PUBLIC, {'f': {'content': 'f'}}),
+
+        ({'0.content': 'Required'},
+         10, Gist.GIST_PUBLIC, Gist.ACL_LEVEL_PUBLIC, {'f': {'x': 'f'}}),
+    ])
+    def test_api_try_create_gist(
+            self, expected, lifetime, gist_type, gist_acl_level, files):
+        id_, params = build_data(
+            self.apikey_regular, 'create_gist',
+            lifetime=lifetime,
+            description='foobar-gist',
+            gist_type=gist_type,
+            acl_level=gist_acl_level,
+            files=files)
+        response = api_call(self.app, params)
+
+        try:
+            assert_error(id_, expected, given=response.body)
+        finally:
+            Fixture().destroy_gists()
+
     @mock.patch.object(GistModel, 'create', crash)
     def test_api_create_gist_exception_occurred(self):
         id_, params = build_data(self.apikey_regular, 'create_gist', files={})
         response = api_call(self.app, params)
         expected = 'failed to create gist'
         assert_error(id_, expected, given=response.body)

rhodecode/api/tests/test_deprecated_api.py

@@ -1,79 +1,79 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 import pytest
 
-from rhodecode.api.views import depracated_api
+from rhodecode.api.views import deprecated_api
 from rhodecode.lib.ext_json import json
 from rhodecode.api.tests.utils import (
     build_data, api_call)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestCommitComment(object):
     def test_deprecated_message_in_docstring(self):
-        docstring = depracated_api.changeset_comment.__doc__
+        docstring = deprecated_api.changeset_comment.__doc__
         assert '.. deprecated:: 3.4.0' in docstring
         assert 'Please use method `comment_commit` instead.' in docstring
 
     def test_deprecated_message_in_retvalue(self):
 
         id_, params = build_data(
             self.apikey, 'show_ip')
         response = api_call(self.app, params)
 
         expected = {
             'id': id_,
             'error': None,
             'result': json.loads(response.body)['result'],
             'DEPRECATION_WARNING':
                 'DEPRECATED METHOD Please use method `get_ip` instead.'
         }
         assert expected == json.loads(response.body)
 
     # def test_calls_comment_commit(self, backend, no_notifications):
     #     data = {
     #         'repoid': backend.repo_name,
     #         'status': ChangesetStatus.STATUS_APPROVED,
     #         'message': 'Approved',
     #         'revision': 'tip'
     #     }
     #     with patch.object(repo_api, 'changeset_commit') as comment_mock:
     #         id_, params = build_data(self.apikey, 'comment_commit', **data)
     #         api_call(self.app, params)
     #
     #     _, call_args = comment_mock.call_args
     #     data['commit_id'] = data.pop('revision')
     #     for key in data:
     #         assert call_args[key] == data[key]
 
     # def test_warning_log_contains_deprecation_message(self):
     #     api = self.SampleApi()
     #     with patch.object(utils, 'log') as log_mock:
     #         api.api_method()
     #
     #     assert log_mock.warning.call_count == 1
     #     call_args = log_mock.warning.call_args[0]
     #     assert (
     #         call_args[0] ==
     #         'DEPRECATED API CALL on function %s, please use `%s` instead')
     #     assert call_args[1].__name__ == 'api_method'
     #     assert call_args[2] == 'new_method'
  No newline at end of file

rhodecode/api/tests/test_get_repo_nodes.py

@@ -1,119 +1,142 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 import pytest
 
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestGetRepoNodes(object):
     @pytest.mark.parametrize("name, ret_type", [
         ('all', 'all'),
         ('dirs', 'dirs'),
         ('files', 'files'),
     ])
     def test_api_get_repo_nodes(self, name, ret_type, backend):
         commit_id = 'tip'
         path = '/'
         id_, params = build_data(
             self.apikey, 'get_repo_nodes',
             repoid=backend.repo_name, revision=commit_id,
             root_path=path,
             ret_type=ret_type)
         response = api_call(self.app, params)
 
         # we don't the actual return types here since it's tested somewhere
         # else
         expected = response.json['result']
         assert_ok(id_, expected, given=response.body)
 
     def test_api_get_repo_nodes_bad_commits(self, backend):
         commit_id = 'i-dont-exist'
         path = '/'
         id_, params = build_data(
             self.apikey, 'get_repo_nodes',
             repoid=backend.repo_name, revision=commit_id,
             root_path=path, )
         response = api_call(self.app, params)
 
         expected = 'failed to get repo: `%s` nodes' % (backend.repo_name,)
         assert_error(id_, expected, given=response.body)
 
     def test_api_get_repo_nodes_bad_path(self, backend):
         commit_id = 'tip'
         path = '/idontexits'
         id_, params = build_data(
             self.apikey, 'get_repo_nodes',
             repoid=backend.repo_name, revision=commit_id,
             root_path=path, )
         response = api_call(self.app, params)
 
         expected = 'failed to get repo: `%s` nodes' % (backend.repo_name,)
         assert_error(id_, expected, given=response.body)
 
+    def test_api_get_repo_nodes_max_file_bytes(self, backend):
+        commit_id = 'tip'
+        path = '/'
+        max_file_bytes = 500
+
+        id_, params = build_data(
+            self.apikey, 'get_repo_nodes',
+            repoid=backend.repo_name, revision=commit_id, details='full',
+            root_path=path)
+        response = api_call(self.app, params)
+        assert any(file['content'] and len(file['content']) > max_file_bytes
+                   for file in response.json['result'])
+
+        id_, params = build_data(
+            self.apikey, 'get_repo_nodes',
+            repoid=backend.repo_name, revision=commit_id,
+            root_path=path, details='full',
+            max_file_bytes=max_file_bytes)
+        response = api_call(self.app, params)
+        assert all(
+            file['content'] is None if file['size'] > max_file_bytes else True
+            for file in response.json['result'])
+
     def test_api_get_repo_nodes_bad_ret_type(self, backend):
         commit_id = 'tip'
         path = '/'
         ret_type = 'error'
         id_, params = build_data(
             self.apikey, 'get_repo_nodes',
             repoid=backend.repo_name, revision=commit_id,
             root_path=path,
             ret_type=ret_type)
         response = api_call(self.app, params)
 
         expected = ('ret_type must be one of %s'
                     % (','.join(['all', 'dirs', 'files'])))
         assert_error(id_, expected, given=response.body)
 
     @pytest.mark.parametrize("name, ret_type, grant_perm", [
         ('all', 'all', 'repository.write'),
         ('dirs', 'dirs', 'repository.admin'),
         ('files', 'files', 'repository.read'),
     ])
     def test_api_get_repo_nodes_by_regular_user(
             self, name, ret_type, grant_perm, backend):
         RepoModel().grant_user_permission(repo=backend.repo_name,
                                           user=self.TEST_USER_LOGIN,
                                           perm=grant_perm)
         Session().commit()
 
         commit_id = 'tip'
         path = '/'
         id_, params = build_data(
             self.apikey_regular, 'get_repo_nodes',
             repoid=backend.repo_name, revision=commit_id,
             root_path=path,
             ret_type=ret_type)
         response = api_call(self.app, params)
 
         # we don't the actual return types here since it's tested somewhere
         # else
         expected = response.json['result']
         try:
             assert_ok(id_, expected, given=response.body)
         finally:
             RepoModel().revoke_user_permission(
                 backend.repo_name, self.TEST_USER_LOGIN)

rhodecode/api/tests/test_update_repo.py

@@ -1,158 +1,163 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import mock
 import pytest
 
 from rhodecode.model.repo import RepoModel
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok, crash, jsonify)
 from rhodecode.tests.fixture import Fixture
 
 
 fixture = Fixture()
 
 UPDATE_REPO_NAME = 'api_update_me'
 
 class SAME_AS_UPDATES(object): """ Constant used for tests below """
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestApiUpdateRepo(object):
 
     @pytest.mark.parametrize("updates, expected", [
         ({'owner': TEST_USER_REGULAR_LOGIN}, SAME_AS_UPDATES),
         ({'description': 'new description'}, SAME_AS_UPDATES),
         ({'clone_uri': 'http://foo.com/repo'}, SAME_AS_UPDATES),
         ({'clone_uri': None}, {'clone_uri': ''}),
         ({'clone_uri': ''}, {'clone_uri': ''}),
         ({'landing_rev': 'branch:master'}, {'landing_rev': ['branch','master']}),
         ({'enable_statistics': True}, SAME_AS_UPDATES),
         ({'enable_locking': True}, SAME_AS_UPDATES),
         ({'enable_downloads': True}, SAME_AS_UPDATES),
-        ({'name': 'new_repo_name'}, {'repo_name': 'new_repo_name'}),
-        ({'group': 'test_group_for_update'},
-            {'repo_name': 'test_group_for_update/%s' % UPDATE_REPO_NAME}),
+        ({'name': 'new_repo_name'}, {
+            'repo_name': 'new_repo_name',
+            'url': 'http://test.example.com:80/new_repo_name',
+        }),
+        ({'group': 'test_group_for_update'}, {
+            'repo_name': 'test_group_for_update/%s' % UPDATE_REPO_NAME,
+            'url': 'http://test.example.com:80/test_group_for_update/%s' % UPDATE_REPO_NAME
+        }),
     ])
     def test_api_update_repo(self, updates, expected, backend):
         repo_name = UPDATE_REPO_NAME
         repo = fixture.create_repo(repo_name, repo_type=backend.alias)
         if updates.get('group'):
             fixture.create_repo_group(updates['group'])
 
         expected_api_data = repo.get_api_data(include_secrets=True)
         if expected is SAME_AS_UPDATES:
             expected_api_data.update(updates)
         else:
             expected_api_data.update(expected)
 
 
         id_, params = build_data(
             self.apikey, 'update_repo', repoid=repo_name, **updates)
         response = api_call(self.app, params)
 
         if updates.get('name'):
             repo_name = updates['name']
         if updates.get('group'):
             repo_name = '/'.join([updates['group'], repo_name])
 
         try:
             expected = {
                 'msg': 'updated repo ID:%s %s' % (repo.repo_id, repo_name),
                 'repository': jsonify(expected_api_data)
             }
             assert_ok(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(repo_name)
             if updates.get('group'):
                 fixture.destroy_repo_group(updates['group'])
 
     def test_api_update_repo_fork_of_field(self, backend):
         master_repo = backend.create_repo()
         repo = backend.create_repo()
         updates = {
             'fork_of': master_repo.repo_name
         }
         expected_api_data = repo.get_api_data(include_secrets=True)
         expected_api_data.update(updates)
 
         id_, params = build_data(
             self.apikey, 'update_repo', repoid=repo.repo_name, **updates)
         response = api_call(self.app, params)
         expected = {
             'msg': 'updated repo ID:%s %s' % (repo.repo_id, repo.repo_name),
             'repository': jsonify(expected_api_data)
         }
         assert_ok(id_, expected, given=response.body)
         result = response.json['result']['repository']
         assert result['fork_of'] == master_repo.repo_name
 
     def test_api_update_repo_fork_of_not_found(self, backend):
         master_repo_name = 'fake-parent-repo'
         repo = backend.create_repo()
         updates = {
             'fork_of': master_repo_name
         }
         id_, params = build_data(
             self.apikey, 'update_repo', repoid=repo.repo_name, **updates)
         response = api_call(self.app, params)
         expected = 'repository `{}` does not exist'.format(master_repo_name)
         assert_error(id_, expected, given=response.body)
 
     def test_api_update_repo_with_repo_group_not_existing(self):
         repo_name = 'admin_owned'
         fixture.create_repo(repo_name)
         updates = {'group': 'test_group_for_update'}
         id_, params = build_data(
             self.apikey, 'update_repo', repoid=repo_name, **updates)
         response = api_call(self.app, params)
         try:
             expected = 'repository group `%s` does not exist' % (
                 updates['group'],)
             assert_error(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(repo_name)
 
     def test_api_update_repo_regular_user_not_allowed(self):
         repo_name = 'admin_owned'
         fixture.create_repo(repo_name)
         updates = {'active': False}
         id_, params = build_data(
             self.apikey_regular, 'update_repo', repoid=repo_name, **updates)
         response = api_call(self.app, params)
         try:
             expected = 'repository `%s` does not exist' % (repo_name,)
             assert_error(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(repo_name)
 
     @mock.patch.object(RepoModel, 'update', crash)
     def test_api_update_repo_exception_occurred(self, backend):
         repo_name = UPDATE_REPO_NAME
         fixture.create_repo(repo_name, repo_type=backend.alias)
         id_, params = build_data(
             self.apikey, 'update_repo', repoid=repo_name,
             owner=TEST_USER_ADMIN_LOGIN,)
         response = api_call(self.app, params)
         try:
             expected = 'failed to update repo `%s`' % (repo_name,)
             assert_error(id_, expected, given=response.body)
         finally:
             fixture.destroy_repo(repo_name)

rhodecode/api/utils.py

@@ -1,378 +1,376 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2014-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 JSON RPC utils
 """
 
 import collections
 import logging
 
 from rhodecode.api.exc import JSONRPCError
 from rhodecode.lib.auth import HasPermissionAnyApi, HasRepoPermissionAnyApi
 from rhodecode.lib.utils import safe_unicode
 from rhodecode.controllers.utils import get_commit_from_ref_name
 from rhodecode.lib.vcs.exceptions import RepositoryError
 
 log = logging.getLogger(__name__)
 
 
-
-
 class OAttr(object):
     """
     Special Option that defines other attribute, and can default to them
 
     Example::
 
         def test(apiuser, userid=Optional(OAttr('apiuser')):
             user = Optional.extract(userid, evaluate_locals=local())
             #if we pass in userid, we get it, else it will default to apiuser
             #attribute
     """
 
     def __init__(self, attr_name):
         self.attr_name = attr_name
 
     def __repr__(self):
         return '<OptionalAttr:%s>' % self.attr_name
 
     def __call__(self):
         return self
 
 
 class Optional(object):
     """
     Defines an optional parameter::
 
         param = param.getval() if isinstance(param, Optional) else param
         param = param() if isinstance(param, Optional) else param
 
     is equivalent of::
 
         param = Optional.extract(param)
 
     """
 
     def __init__(self, type_):
         self.type_ = type_
 
     def __repr__(self):
         return '<Optional:%s>' % self.type_.__repr__()
 
     def __call__(self):
         return self.getval()
 
     def getval(self, evaluate_locals=None):
         """
         returns value from this Optional instance
         """
         if isinstance(self.type_, OAttr):
             param_name = self.type_.attr_name
             if evaluate_locals:
                 return evaluate_locals[param_name]
             # use params name
             return param_name
         return self.type_
 
     @classmethod
     def extract(cls, val, evaluate_locals=None):
         """
         Extracts value from Optional() instance
 
         :param val:
         :return: original value if it's not Optional instance else
             value of instance
         """
         if isinstance(val, cls):
             return val.getval(evaluate_locals)
         return val
 
 
 def parse_args(cli_args, key_prefix=''):
     from rhodecode.lib.utils2 import (escape_split)
     kwargs = collections.defaultdict(dict)
     for el in escape_split(cli_args, ','):
         kv = escape_split(el, '=', 1)
         if len(kv) == 2:
             k, v = kv
             kwargs[key_prefix + k] = v
     return kwargs
 
 
 def get_origin(obj):
     """
     Get origin of permission from object.
 
     :param obj:
     """
     origin = 'permission'
 
     if getattr(obj, 'owner_row', '') and getattr(obj, 'admin_row', ''):
         # admin and owner case, maybe we should use dual string ?
         origin = 'owner'
     elif getattr(obj, 'owner_row', ''):
         origin = 'owner'
     elif getattr(obj, 'admin_row', ''):
         origin = 'super-admin'
     return origin
 
 
 def store_update(updates, attr, name):
     """
     Stores param in updates dict if it's not instance of Optional
     allows easy updates of passed in params
     """
     if not isinstance(attr, Optional):
         updates[name] = attr
 
 
 def has_superadmin_permission(apiuser):
     """
     Return True if apiuser is admin or return False
 
     :param apiuser:
     """
     if HasPermissionAnyApi('hg.admin')(user=apiuser):
         return True
     return False
 
 
 def has_repo_permissions(apiuser, repoid, repo, perms):
     """
     Raise JsonRPCError if apiuser is not authorized or return True
 
     :param apiuser:
     :param repoid:
     :param repo:
     :param perms:
     """
     if not HasRepoPermissionAnyApi(*perms)(
             user=apiuser, repo_name=repo.repo_name):
         raise JSONRPCError(
             'repository `%s` does not exist' % repoid)
 
     return True
 
 
 def get_user_or_error(userid):
     """
     Get user by id or name or return JsonRPCError if not found
 
     :param userid:
     """
     from rhodecode.model.user import UserModel
 
     user_model = UserModel()
     try:
         user = user_model.get_user(int(userid))
     except ValueError:
         user = user_model.get_by_username(userid)
 
     if user is None:
         raise JSONRPCError("user `%s` does not exist" % (userid,))
     return user
 
 
 def get_repo_or_error(repoid):
     """
     Get repo by id or name or return JsonRPCError if not found
 
     :param repoid:
     """
     from rhodecode.model.repo import RepoModel
 
     repo = RepoModel().get_repo(repoid)
     if repo is None:
         raise JSONRPCError('repository `%s` does not exist' % (repoid,))
     return repo
 
 
 def get_repo_group_or_error(repogroupid):
     """
     Get repo group by id or name or return JsonRPCError if not found
 
     :param repogroupid:
     """
     from rhodecode.model.repo_group import RepoGroupModel
 
     repo_group = RepoGroupModel()._get_repo_group(repogroupid)
     if repo_group is None:
         raise JSONRPCError(
             'repository group `%s` does not exist' % (repogroupid,))
     return repo_group
 
 
 def get_user_group_or_error(usergroupid):
     """
     Get user group by id or name or return JsonRPCError if not found
 
     :param usergroupid:
     """
     from rhodecode.model.user_group import UserGroupModel
 
     user_group = UserGroupModel().get_group(usergroupid)
     if user_group is None:
         raise JSONRPCError('user group `%s` does not exist' % (usergroupid,))
     return user_group
 
 
 def get_perm_or_error(permid, prefix=None):
     """
     Get permission by id or name or return JsonRPCError if not found
 
     :param permid:
     """
     from rhodecode.model.permission import PermissionModel
 
     perm = PermissionModel.cls.get_by_key(permid)
     if perm is None:
         raise JSONRPCError('permission `%s` does not exist' % (permid,))
     if prefix:
         if not perm.permission_name.startswith(prefix):
             raise JSONRPCError('permission `%s` is invalid, '
                                'should start with %s' % (permid, prefix))
     return perm
 
 
 def get_gist_or_error(gistid):
     """
     Get gist by id or gist_access_id or return JsonRPCError if not found
 
     :param gistid:
     """
     from rhodecode.model.gist import GistModel
 
     gist = GistModel.cls.get_by_access_id(gistid)
     if gist is None:
         raise JSONRPCError('gist `%s` does not exist' % (gistid,))
     return gist
 
 
 def get_pull_request_or_error(pullrequestid):
     """
     Get pull request by id or return JsonRPCError if not found
 
     :param pullrequestid:
     """
     from rhodecode.model.pull_request import PullRequestModel
 
     try:
         pull_request = PullRequestModel().get(int(pullrequestid))
     except ValueError:
         raise JSONRPCError('pullrequestid must be an integer')
     if not pull_request:
         raise JSONRPCError('pull request `%s` does not exist' % (
             pullrequestid,))
     return pull_request
 
 
 def build_commit_data(commit, detail_level):
     parsed_diff = []
     if detail_level == 'extended':
         for f in commit.added:
             parsed_diff.append(_get_commit_dict(filename=f.path, op='A'))
         for f in commit.changed:
             parsed_diff.append(_get_commit_dict(filename=f.path, op='M'))
         for f in commit.removed:
             parsed_diff.append(_get_commit_dict(filename=f.path, op='D'))
 
     elif detail_level == 'full':
         from rhodecode.lib.diffs import DiffProcessor
         diff_processor = DiffProcessor(commit.diff())
         for dp in diff_processor.prepare():
             del dp['stats']['ops']
             _stats = dp['stats']
             parsed_diff.append(_get_commit_dict(
                 filename=dp['filename'], op=dp['operation'],
                 new_revision=dp['new_revision'],
                 old_revision=dp['old_revision'],
                 raw_diff=dp['raw_diff'], stats=_stats))
 
     return parsed_diff
 
 
 def get_commit_or_error(ref, repo):
     try:
         ref_type, _, ref_hash = ref.split(':')
     except ValueError:
         raise JSONRPCError(
             'Ref `{ref}` given in a wrong format. Please check the API'
             ' documentation for more details'.format(ref=ref))
     try:
         # TODO: dan: refactor this to use repo.scm_instance().get_commit()
         # once get_commit supports ref_types
         return get_commit_from_ref_name(repo, ref_hash)
     except RepositoryError:
         raise JSONRPCError('Ref `{ref}` does not exist'.format(ref=ref))
 
 
 def resolve_ref_or_error(ref, repo):
     def _parse_ref(type_, name, hash_=None):
         return type_, name, hash_
 
     try:
         ref_type, ref_name, ref_hash = _parse_ref(*ref.split(':'))
     except TypeError:
         raise JSONRPCError(
             'Ref `{ref}` given in a wrong format. Please check the API'
             ' documentation for more details'.format(ref=ref))
 
     try:
         ref_hash = ref_hash or _get_ref_hash(repo, ref_type, ref_name)
     except (KeyError, ValueError):
         raise JSONRPCError(
             'The specified {type} `{name}` does not exist'.format(
                 type=ref_type, name=ref_name))
 
     return ':'.join([ref_type, ref_name, ref_hash])
 
 
 def _get_commit_dict(
         filename, op, new_revision=None, old_revision=None,
         raw_diff=None, stats=None):
     if stats is None:
         stats = {
             "added": None,
             "binary": None,
             "deleted": None
         }
     return {
         "filename": safe_unicode(filename),
         "op": op,
 
         # extra details
         "new_revision": new_revision,
         "old_revision": old_revision,
 
         "raw_diff": raw_diff,
         "stats": stats
     }
 
 
 # TODO: mikhail: Think about moving this function to some library
 def _get_ref_hash(repo, type_, name):
     vcs_repo = repo.scm_instance()
     if type_ == 'branch' and vcs_repo.alias in ('hg', 'git'):
         return vcs_repo.branches[name]
     elif type_ == 'bookmark' and vcs_repo.alias == 'hg':
         return vcs_repo.bookmarks[name]
     else:
         raise ValueError()

rhodecode/api/views/gist_api.py

@@ -1,226 +1,255 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2011-2016  RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 
 import logging
 import time
 
 from rhodecode.api import jsonrpc_method, JSONRPCError
+from rhodecode.api.exc import JSONRPCValidationError
 from rhodecode.api.utils import (
     Optional, OAttr, get_gist_or_error, get_user_or_error,
     has_superadmin_permission)
 from rhodecode.model.db import Session, or_
 from rhodecode.model.gist import Gist, GistModel
 
 log = logging.getLogger(__name__)
 
 
 @jsonrpc_method()
 def get_gist(request, apiuser, gistid, content=Optional(False)):
     """
     Get the specified gist, based on the gist ID.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param gistid: Set the id of the private or public gist
     :type gistid: str
     :param content: Return the gist content. Default is false.
     :type content: Optional(bool)
     """
 
     gist = get_gist_or_error(gistid)
     content = Optional.extract(content)
     if not has_superadmin_permission(apiuser):
         if gist.gist_owner != apiuser.user_id:
             raise JSONRPCError('gist `%s` does not exist' % (gistid,))
     data = gist.get_api_data()
     if content:
         from rhodecode.model.gist import GistModel
         rev, gist_files = GistModel().get_gist_files(gistid)
         data['content'] = dict([(x.path, x.content) for x in gist_files])
     return data
 
 
 @jsonrpc_method()
 def get_gists(request, apiuser, userid=Optional(OAttr('apiuser'))):
     """
     Get all gists for given user. If userid is empty returned gists
     are for user who called the api
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param userid: user to get gists for
     :type userid: Optional(str or int)
     """
 
     if not has_superadmin_permission(apiuser):
         # make sure normal user does not pass someone else userid,
         # he is not allowed to do that
         if not isinstance(userid, Optional) and userid != apiuser.user_id:
             raise JSONRPCError(
                 'userid is not the same as your user'
             )
 
     if isinstance(userid, Optional):
         user_id = apiuser.user_id
     else:
         user_id = get_user_or_error(userid).user_id
 
     gists = []
     _gists = Gist().query() \
         .filter(or_(
         Gist.gist_expires == -1, Gist.gist_expires >= time.time())) \
         .filter(Gist.gist_owner == user_id) \
         .order_by(Gist.created_on.desc())
     for gist in _gists:
         gists.append(gist.get_api_data())
     return gists
 
 
 @jsonrpc_method()
 def create_gist(
-        request, apiuser, files, owner=Optional(OAttr('apiuser')),
+        request, apiuser, files, gistid=Optional(None),
+        owner=Optional(OAttr('apiuser')),
         gist_type=Optional(Gist.GIST_PUBLIC), lifetime=Optional(-1),
         acl_level=Optional(Gist.ACL_LEVEL_PUBLIC),
         description=Optional('')):
     """
     Creates a new Gist.
 
     :param apiuser: This is filled automatically from the |authtoken|.
     :type apiuser: AuthUser
     :param files: files to be added to the gist. The data structure has
         to match the following example::
 
-          {'filename': {'content':'...', 'lexer': null},
-           'filename2': {'content':'...', 'lexer': null}}
+          {'filename1': {'content':'...'}, 'filename2': {'content':'...'}}
 
     :type files: dict
+    :param gistid: Set a custom id for the gist
+    :type gistid: Optional(str)
     :param owner: Set the gist owner, defaults to api method caller
     :type owner: Optional(str or int)
     :param gist_type: type of gist ``public`` or ``private``
     :type gist_type: Optional(str)
     :param lifetime: time in minutes of gist lifetime
     :type lifetime: Optional(int)
     :param acl_level: acl level for this gist, can be
         ``acl_public`` or ``acl_private`` If the value is set to
         ``acl_private`` only logged in users are able to access this gist.
         If not set it defaults to ``acl_public``.
     :type acl_level: Optional(str)
     :param description: gist description
     :type description: Optional(str)
 
     Example  output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : {
         "msg": "created new gist",
         "gist": {}
       }
       error :  null
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
         "failed to create gist"
       }
 
     """
+    from rhodecode.model import validation_schema
+    from rhodecode.model.validation_schema.schemas import gist_schema
+
+    if isinstance(owner, Optional):
+        owner = apiuser.user_id
+
+    owner = get_user_or_error(owner)
+
+    lifetime = Optional.extract(lifetime)
+    schema = gist_schema.GistSchema().bind(
+        # bind the given values if it's allowed, however the deferred
+        # validator will still validate it according to other rules
+        lifetime_options=[lifetime])
 
     try:
-        if isinstance(owner, Optional):
-            owner = apiuser.user_id
+        nodes = gist_schema.nodes_to_sequence(
+            files, colander_node=schema.get('nodes'))
+
+        schema_data = schema.deserialize(dict(
+            gistid=Optional.extract(gistid),
+            description=Optional.extract(description),
+            gist_type=Optional.extract(gist_type),
+            lifetime=lifetime,
+            gist_acl_level=Optional.extract(acl_level),
+            nodes=nodes
+        ))
 
-        owner = get_user_or_error(owner)
-        description = Optional.extract(description)
-        gist_type = Optional.extract(gist_type)
-        lifetime = Optional.extract(lifetime)
-        acl_level = Optional.extract(acl_level)
+        # convert to safer format with just KEYs so we sure no duplicates
+        schema_data['nodes'] = gist_schema.sequence_to_nodes(
+            schema_data['nodes'], colander_node=schema.get('nodes'))
+
+    except validation_schema.Invalid as err:
+        raise JSONRPCValidationError(colander_exc=err)
 
-        gist = GistModel().create(description=description,
-                                  owner=owner,
-                                  gist_mapping=files,
-                                  gist_type=gist_type,
-                                  lifetime=lifetime,
-                                  gist_acl_level=acl_level)
+    try:
+        gist = GistModel().create(
+            owner=owner,
+            gist_id=schema_data['gistid'],
+            description=schema_data['description'],
+            gist_mapping=schema_data['nodes'],
+            gist_type=schema_data['gist_type'],
+            lifetime=schema_data['lifetime'],
+            gist_acl_level=schema_data['gist_acl_level'])
         Session().commit()
         return {
             'msg': 'created new gist',
             'gist': gist.get_api_data()
         }
     except Exception:
         log.exception('Error occurred during creation of gist')
         raise JSONRPCError('failed to create gist')
 
 
 @jsonrpc_method()
 def delete_gist(request, apiuser, gistid):
     """
     Deletes existing gist
 
     :param apiuser: filled automatically from apikey
     :type apiuser: AuthUser
     :param gistid: id of gist to delete
     :type gistid: str
 
     Example output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : {
         "deleted gist ID: <gist_id>",
         "gist": null
       }
       error :  null
 
     Example error output:
 
     .. code-block:: bash
 
       id : <id_given_in_input>
       result : null
       error :  {
         "failed to delete gist ID:<gist_id>"
       }
 
     """
 
     gist = get_gist_or_error(gistid)
     if not has_superadmin_permission(apiuser):
         if gist.gist_owner != apiuser.user_id:
             raise JSONRPCError('gist `%s` does not exist' % (gistid,))
 
     try:
         GistModel().delete(gist)
         Session().commit()
         return {
             'msg': 'deleted gist ID:%s' % (gist.gist_access_id,),
             'gist': None
         }
     except Exception:
         log.exception('Error occured during gist deletion')
         raise JSONRPCError('failed to delete gist ID:%s'
                            % (gist.gist_access_id,))
  No newline at end of file