^\.rhodecode$

API CLIENT

++++++++++

From version 1.4 RhodeCode adds a binary script that allows to easily

communicate with API. After installing RhodeCode a `rhodecode-api` script

will be available.

To get started quickly simply run::

  rhodecode-api _create_config --apikey=<youapikey> --apihost=<rhodecode host>

This will create a file named .config in the directory you executed it storing

json config file with credentials. You can skip this step and always provide

both of the arguments to be able to communicate with server

after that simply run any api command for example get_repo::

 rhodecode-api get_repo

 calling {"api_key": "<apikey>", "id": 75, "args": {}, "method": "get_repo"} to http://127.0.0.1:5000

 rhodecode said:

 {'error': 'Missing non optional `repoid` arg in JSON DATA',

  'id': 75,

  'result': None}

Ups looks like we forgot to add an argument

Let's try again now giving the repoid as parameters::

    rhodecode-api get_repo repoid:rhodecode   

    calling {"api_key": "<apikey>", "id": 39, "args": {"repoid": "rhodecode"}, "method": "get_repo"} to http://127.0.0.1:5000

    rhodecode said:

    {'error': None,

     'id': 39,

     'result': <json data...>}

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

              "user": {

                "id" :       "<id>",

                "username" : "<username>",

                "firstname": "<firstname>",

                "lastname" : "<lastname>",

                "email" :    "<email>",

                "active" :   "<bool>",

                "admin" :    "<bool>",

                "ldap_dn" :  "<ldap_dn>",

                "last_login": "<last_login>",

              },

updates given user if such user exists. This command can 

              "msg" : "updated user ID:<userid> <username>"

            }

    error:  null

delete_user

-----------

deletes givenuser if such user exists. This command can 

be executed only using api_key belonging to user with admin rights.

INPUT::

    id : <id_for_response>

    api_key : "<api_key>"

    method :  "delete_user"

    args :    {

                "userid" : "<user_id or username>",

              }

OUTPUT::

    result: {

              "id" : "<edited_user_id>",

              "msg" : "deleted user ID:<userid> <username>"

              "repo": {

                "id" :          "<id>",

                "repo_name" :   "<reponame>"

                "type" :        "<type>",

                "description" : "<description>",

                "clone_uri" :   "<clone_uri>",

                "private": :    "<bool>",

                "created_on" :  "<datetimecreated>",

              },

- #464 added links to groups in permission box

- #465 mentions autocomplete inside comments boxes

- #469 added --update-only option to whoosh to re-index only given list

  of repos in index 

- rhodecode-api CLI client

- new git http protocol replaced buggy dulwich implementation.

  Now based on pygrack & gitweb

simplejson==2.5.2

mercurial>=2.2.2,<2.3

    requirements.append("mercurial>=2.2.2,<2.3")

    requirements.append("mercurial>=2.2.2,<2.3")

# -*- coding: utf-8 -*-

"""

    rhodecode.bin.backup_manager

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    Api CLI client for RhodeCode

    :created_on: Jun 3, 2012

    :author: marcink

    :copyright: (C) 2010-2012 Marcin Kuzminski <marcin@python-works.com>

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU 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 General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from __future__ import with_statement

import os

import sys

import random

import urllib2

import pprint

import argparse

try:

    from rhodecode.lib.ext_json import json

except ImportError:

    try:

        import simplejson as json

    except ImportError:

        import json

CONFIG_NAME = '.rhodecode'

FORMAT_PRETTY = 'pretty'

FORMAT_JSON = 'json'

class RcConf(object):

    """

    RhodeCode config for API

    conf = RcConf()

    conf['key']

    """

    def __init__(self, autoload=True, autocreate=False, config=None):

        self._conf_name = CONFIG_NAME

        self._conf = {}

        if autocreate:

            self.make_config(config)

        if autoload:

            self._conf = self.load_config()

    def __getitem__(self, key):

        return self._conf[key]

    def __nonzero__(self):

        if self._conf:

            return True

        return False

    def __eq__(self):

        return self._conf.__eq__()

    def __repr__(self):

        return 'RcConf<%s>' % self._conf.__repr__()

    def make_config(self, config):

        """

        Saves given config as a JSON dump in the _conf_name location

        :param config:

        :type config:

        """

        with open(self._conf_name, 'wb') as f:

            json.dump(config, f, indent=4)

            sys.stdout.write('Updated conf\n')

    def update_config(self, new_config):

        """

        Reads the JSON config updates it's values with new_config and

        saves it back as JSON dump

        :param new_config:

        """

        config = {}

        try:

            with open(self._conf_name, 'rb') as conf:

                config = json.load(conf)

        except IOError, e:

            sys.stderr.write(str(e) + '\n')

        config.update(new_config)

        self.make_config(config)

    def load_config(self):

        """

        Loads config from file and returns loaded JSON object

        """

        try:

            with open(self._conf_name, 'rb') as conf:

                return  json.load(conf)

        except IOError, e:

            #sys.stderr.write(str(e) + '\n')

            pass

def api_call(apikey, apihost, format, method=None, **kw):

    """

    Api_call wrapper for RhodeCode

    :param apikey:

    :param apihost:

    :param format: formatting, pretty means prints and pprint of json

     json returns unparsed json

    :param method:

    """

    def _build_data(random_id):

        """

        Builds API data with given random ID

        :param random_id:

        :type random_id:

        """

        return {

            "id": random_id,

            "api_key": apikey,

            "method": method,

            "args": kw

        }

    if not method:

        raise Exception('please specify method name !')

    id_ = random.randrange(1, 200)

    req = urllib2.Request('%s/_admin/api' % apihost,

                      data=json.dumps(_build_data(id_)),

                      headers={'content-type': 'text/plain'})

    if format == FORMAT_PRETTY:

        sys.stdout.write('calling %s to %s \n' % (req.get_data(), apihost))

    ret = urllib2.urlopen(req)

    raw_json = ret.read()

    json_data = json.loads(raw_json)

    id_ret = json_data['id']

    _formatted_json = pprint.pformat(json_data)

    if id_ret == id_:

        if format == FORMAT_JSON:

            sys.stdout.write(str(raw_json))

        else:

            sys.stdout.write('rhodecode returned:\n%s\n' % (_formatted_json))

    else:

        raise Exception('something went wrong. '

                        'ID mismatch got %s, expected %s | %s' % (

                                            id_ret, id_, _formatted_json))

def argparser(argv):

    usage = ("rhodecode_api [-h] [--format=FORMAT] [--apikey=APIKEY] [--apihost=APIHOST] "

             "_create_config or METHOD <key:val> <key2:val> ...")

    parser = argparse.ArgumentParser(description='RhodeCode API cli',

                                     usage=usage)

    ## config

    group = parser.add_argument_group('config')

    group.add_argument('--apikey', help='api access key')

    group.add_argument('--apihost', help='api host')

    group = parser.add_argument_group('API')

    group.add_argument('method', metavar='METHOD', type=str,

            help='API method name to call followed by key:value attributes',

    )

    group.add_argument('--format', dest='format', type=str,

            help='output format default: `pretty` can '

                 'be also `%s`' % FORMAT_JSON,

            default=FORMAT_PRETTY

    )

    args, other = parser.parse_known_args()

    return parser, args, other

def main(argv=None):

    """

    Main execution function for cli

    :param argv:

    :type argv:

    """

    if argv is None:

        argv = sys.argv

    conf = None

    parser, args, other = argparser(argv)

    api_credentials_given = (args.apikey and args.apihost)

    if args.method == '_create_config':

        if not api_credentials_given:

            raise parser.error('_create_config requires --apikey and --apihost')

        conf = RcConf(autocreate=True, config={'apikey': args.apikey,

                                               'apihost': args.apihost})

        sys.stdout.write('Create new config in %s\n' % CONFIG_NAME)

    if not conf:

        conf = RcConf(autoload=True)

        if not conf:

            if not api_credentials_given:

                parser.error('Could not find config file and missing '

                             '--apikey or --apihost in params')

    apikey = args.apikey or conf['apikey']

    host = args.apihost or conf['apihost']

    method = args.method

    margs = dict(map(lambda s: s.split(':', 1), other))

    api_call(apikey, host, args.format, method, **margs)

    return 0

if __name__ == '__main__':

    sys.exit(main(sys.argv))

    rhodecode.bin.backup_manager

    Repositories backup manager, it allows to backups all

        self.backup_file_name = "rhodecode_repos.%s.tar.gz" % today

    #ADMIN USERS GROUPS REST ROUTES

    rmap.connect('public_journal_rss', '%s/public_journal/rss' % ADMIN_PREFIX,

                 controller='journal', action="public_journal_rss")

    rmap.connect('public_journal_rss_old', '%s/public_journal_rss' % ADMIN_PREFIX,

                 '%s/public_journal/atom' % ADMIN_PREFIX, controller='journal',

                 action="public_journal_atom")

    rmap.connect('public_journal_atom_old',

                              form_result['repo_name_full'], self.ip_addr,

                              self.sa)

                              form_result['repo_name_full'], self.ip_addr,

                              self.sa)

                              changed_name, self.ip_addr, self.sa)

                              repo_name, self.ip_addr, self.sa)

from rhodecode.lib.utils import action_logger

            usr = form_result['username']

            action_logger(self.rhodecode_user, 'admin_created_user:%s' % usr,

                          None, self.ip_addr, self.sa)

            h.flash(_('created user %s') % usr,

            usr = form_result['username']

            action_logger(self.rhodecode_user, 'admin_updated_user:%s' % usr,

                          None, self.ip_addr, self.sa)

from rhodecode.lib.utils import action_logger

            gr = form_result['users_group_name']

            action_logger(self.rhodecode_user,

                          'admin_created_users_group:%s' % gr,

                          None, self.ip_addr, self.sa)

            h.flash(_('created users group %s') % gr, category='success')

            gr = form_result['users_group_name']

            action_logger(self.rhodecode_user,

                          'admin_updated_users_group:%s' % gr,

                          None, self.ip_addr, self.sa)

            h.flash(_('updated users group %s') % gr, category='success')

def jsonrpc_error(message, retid=None, code=None):

    return Response(

            body=json.dumps(dict(id=retid, result=None, error=message)),

            status=code,

            content_type='application/json'

    )

        self._req_id = None

            return jsonrpc_error(retid=self._req_id,

                                 message="No Content-Length in request")

            return jsonrpc_error(retid=self._req_id,

                                 message="Content-Length is 0")

            return jsonrpc_error(retid=self._req_id,

                                 message="JSON parse error ERR:%s RAW:%r" \

            return jsonrpc_error(retid=self._req_id,

                                 message='Incorrect JSON query missing %s' % e)

                return jsonrpc_error(retid=self._req_id,

                                     message='Invalid API KEY')

            return jsonrpc_error(retid=self._req_id,

                                 message='Invalid API KEY')

            return jsonrpc_error(retid=self._req_id,

                                 message=str(e))

            return jsonrpc_error(

                retid=self._req_id,

                message='This method [%s] does not support '

                         'authentication (missing %s param)' % (

                                    self._func.__name__, USER_SESSION_ATTR)

            )

                    retid=self._req_id,

            user = UserModel().create_or_update(

                id=user.user_id,

                msg='created new user %s' % username,

                user=dict(

                    id=user.user_id,

                    username=user.username,

                    firstname=user.name,

                    lastname=user.lastname,

                    email=user.email,

                    active=user.active,

                    admin=user.admin,

                    ldap_dn=user.ldap_dn,

                    last_login=user.last_login,

                )

        usr = UserModel().get_user(userid)

        if not usr:

            raise JSONRPCError("user ID:%s does not exist" % userid)

                msg='updated user ID:%s %s' % (usr.user_id, usr.username)

            raise JSONRPCError('failed to update user %s' % userid)

    @HasPermissionAllDecorator('hg.admin')

    def delete_user(self, apiuser, userid):

        """"

        Deletes an user

        :param apiuser:

        """

        usr = UserModel().get_user(userid)

        if not usr:

            raise JSONRPCError("user ID:%s does not exist" % userid)

        try:

            UserModel().delete(userid)

            Session.commit()

            return dict(

                id=usr.user_id,

                msg='deleted user ID:%s %s' % (usr.user_id, usr.username)

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to delete ID:%s %s' % (usr.user_id,

                                                              usr.username))

            raise JSONRPCError('unknown repository "%s"' % (repo or repoid))

                )

                msg="Created new repository %s" % (repo.repo_name),

                repo=dict(

                    id=repo.repo_id,

                    repo_name=repo.repo_name,

                    type=repo.repo_type,

                    clone_uri=repo.clone_uri,

                    private=repo.private,

                    created_on=repo.created_on,

                    description=repo.description,

                )

    def fork_repo(self, apiuser, repoid):

        repo = RepoModel().get_repo(repoid)

        if repo is None:

            raise JSONRPCError('unknown repository "%s"' % (repo or repoid))

        RepoModel().create_fork(form_data, cur_user)

    @HasPermissionAnyDecorator('hg.admin')

from rhodecode.lib.graphmod import _colored, _dagwalker