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

<your_server>/_admin/api

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

Example call for autopulling remotes repos using curl::

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

Simply provide 

 - *api_key* for access and permission validation.

 - *method* is name of method to call

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

RhodeCode API will return always a JSON formatted answer::

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

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

belonging to user with admin rights

INPUT::

OUTPUT::

    result:"Pulled from <repo_name>"

    error:null

create_user

-----------

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

belonging to user with admin rights

INPUT::

    api_key:"<api_key>"

    method: "create_user"

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

           "password": "<password>", 

           "active":   "<bool>", 

           "admin":    "<bool>", 

           "name":     "<firstname>", 

           "lastname": "<lastname>", 

           "email":    "<useremail>"}

OUTPUT::

    result:{"id": <newuserid>,

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

    error:null

create_users_group

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

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

belonging to user with admin rights

INPUT::

    api_key:"<api_key>"

    method: "create_user"

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

           "active":"<bool>"}

OUTPUT::

    result:{"id": <newusersgroupid>,

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

    error:null    

        # rhodecode_user attribute set

        # 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_SESSION_ATTR = 'apiuser'

        if USER_SESSION_ATTR not in arglist:

                                 'authentication (missing %s param)' %

                                 (self._func.__name__, USER_SESSION_ATTR))

            if arg == USER_SESSION_ATTR:

                # USER_SESSION_ATTR is something translated from api key and 

                # this is checked before so we don't need validate it

        self._rpc_args = {USER_SESSION_ATTR:u}

import traceback

import logging

from rhodecode.model.db import User, UsersGroup

log = logging.getLogger(__name__)

    def pull(self, apiuser, repo):

        :param user:

        :param repo:

    @HasPermissionAllDecorator('hg.admin')

    def create_user(self, apiuser, username, password, active, admin, name, 

                    lastname, email):

        """

        Creates new user

        :param apiuser:

        :param username:

        :param password:

        :param active:

        :param admin:

        :param name:

        :param lastname:

        :param email:

        """

        form_data = dict(username=username,

                         password=password,

                         active=active,

                         admin=admin,

                         name=name,

                         lastname=lastname,

                         email=email)

        try:

            u = User.create(form_data)

            return {'id':u.user_id,

                    'msg':'created new user %s' % name}

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to create user %s' % name)

    @HasPermissionAllDecorator('hg.admin')

    def create_users_group(self, apiuser, name, active):

        """

        Creates an new usergroup

        :param name:

        :param active:

        """

        form_data = {'users_group_name':name,

                     'users_group_active':active}

        try:

            ug = UsersGroup.create(form_data)

            return {'id':ug.users_group_id,

                    'msg':'created new users group %s' % name}

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to create group %s' % name)

from vcs.exceptions import VCSError

from rhodecode.lib import str2bool, json, safe_str, get_changeset_safe,\

    generate_api_key

    @classmethod

    def create(cls, form_data):

        from rhodecode.lib.auth import get_crypt_password

        try:

            new_user = cls()

            for k, v in form_data.items():

                if k == 'password':

                    v = get_crypt_password(v)

                setattr(new_user, k, v)

            new_user.api_key = generate_api_key(form_data['username'])

            Session.add(new_user)

            Session.commit()

            return new_user

        except:

            log.error(traceback.format_exc())

            Session.rollback()

            raise

            return new_users_group