"error": "null"|<error_message> # JSON formatted error (if any)

    }

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

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

and result will be null.

API CLIENT

++++++++++

From version 1.4 RhodeCode adds a script that allows to easily

will be available.

To get started quickly simply run::

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::

 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::

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

    rhodecode said:

    {'error': None,

     'id': 39,

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

API METHODS

+++++++++++

:license: GPLv3, see LICENSE for more details.

"""

from __future__ import with_statement

import sys

import argparse

from kallithea.bin.base import json, api_call, RcConf, FORMAT_JSON, FORMAT_PRETTY

def argparser(argv):

    usage = (

      "[--config=CONFIG] [--save-config] "

      "METHOD <key:val> <key2:val> ...\n"

    )

    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.add_argument('--config', help='config file')

    group.add_argument('--save-config', action='store_true', help='save the given config into a file')

import logging

import tarfile

import datetime

import subprocess

logging.basicConfig(level=logging.DEBUG,

                    format="%(asctime)s %(levelname)-5.5s %(message)s")

class BackupManager(object):

    def __init__(self, repos_location, rsa_key, backup_server):

        today = datetime.datetime.now().weekday() + 1

        self.id_rsa_path = self.get_id_rsa(rsa_key)

        self.repos_path = self.get_repos_path(repos_location)

        self.backup_server = backup_server

        self.backup_file_path = '/tmp'

        logging.info('starting backup for %s', self.repos_path)

        logging.info('backup target %s', self.backup_file_path)

    def get_id_rsa(self, rsa_key):

        if not os.path.isfile(rsa_key):

# 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/>.

"""

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

configuration generator for RhodeCode

:created_on: Jun 18, 2013

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH.

:license: GPLv3, see LICENSE for more details.

"""

from __future__ import with_statement

import os

import sys

import uuid

import argparse

from mako.template import Template

TMPL = 'template.ini.mako'

here = os.path.dirname(os.path.abspath(__file__))

def argparser(argv):

    usage = (

      "VARS optional specify extra template variable that will be available in "

      "template. Use comma separated key=val format eg.\n"

      "key1=val1,port=5000,host=127.0.0.1,elements='a\,b\,c'\n"

    )

    parser = argparse.ArgumentParser(

        description='RhodeCode CONFIG generator with variable replacement',

        usage=usage

    )

    ## config

    group = parser.add_argument_group('CONFIG')

# 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/>.

"""

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

Gist CLI client for RhodeCode

:created_on: May 9, 2013

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH.

:license: GPLv3, see LICENSE for more details.

"""

from __future__ import with_statement

import os

import sys

import stat

import argparse

import fileinput

from kallithea.bin.base import json, api_call, RcConf, FORMAT_JSON, FORMAT_PRETTY

def argparser(argv):

    usage = (

      "[--config=CONFIG] [--save-config] [GIST OPTIONS] "

      "[filename or stdin use - for terminal stdin ]\n"

    )

    parser = argparse.ArgumentParser(description='RhodeCode Gist 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.add_argument('--config', help='config file path DEFAULT: ~/.config/kallithea')

    group.add_argument('--save-config', action='store_true',

                       help='save the given config into a file')

        import json

from ConfigParser import ConfigParser

config = ConfigParser()

config.read('ldap_sync.conf')

class InvalidResponseIDError(Exception):

    """ Request and response don't have the same UUID. """

    """ Response has an error, something went wrong with request execution. """

class UserAlreadyInGroupError(Exception):

    """ User is already a member of the target group. """

class UserNotInGroupError(Exception):

    """ User is not a member of the target group. """

    def __init__(self, url, key):

        self.url = url

        self.key = key

    def get_api_data(self, uid, method, args):

        """Prepare dict for API post."""

        return {

            "id": uid,

            "api_key": self.key,

            "method": method,

            "args": args

        }

        """Send a generic API post to Rhodecode.

        This will generate the UUID for validation check after the

        response is returned. Handle errors and get the result back.

        """

        uid = str(uuid.uuid1())

        data = self.get_api_data(uid, method, args)

        data = json.dumps(data)

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

        req = urllib2.Request(self.url, data, headers)

        response = urllib2.urlopen(req)

        response = json.load(response)

        if uid != response["id"]:

            raise InvalidResponseIDError("UUID does not match.")

        if response["error"] is not None:

        return response["result"]

    def create_group(self, name, active=True):

        """Create the Rhodecode user group."""

        args = {

            "group_name": name,

            "active": str(active)

        }

    def add_membership(self, group, username):

        """Add specific user to a group."""

        args = {

            "usersgroupid": group,

            "userid": username

        }

        if not result["success"]:

            raise UserAlreadyInGroupError("User %s already in group %s." %

                                          (username, group))

    def remove_membership(self, group, username):

        """Remove specific user from a group."""

        args = {

            "usersgroupid": group,

            "userid": username

        }

        if not result["success"]:

            raise UserNotInGroupError("User %s not in group %s." %

                                      (username, group))

    def get_group_members(self, name):

        """Get the list of member usernames from a user group."""

        args = {"usersgroupid": name}

        member_list = []

        for member in members:

            member_list.append(member["username"])

        return member_list

    def get_group(self, name):

        """Return group info."""

        args = {"usersgroupid": name}

    def get_user(self, username):

        """Return user info."""

        args = {"userid": username}

class LdapClient(object):

    def __init__(self, uri, user, key, base_dn):

        self.client = ldap.initialize(uri, trace_level=0)

        self.client.set_option(ldap.OPT_REFERRALS, 0)

        self.client.simple_bind(user, key)

        self.base_dn = base_dn

    def __del__(self):

        self.client.unbind()

        """

        member = member.split(",")[0]

        return member.split('=')

class LdapSync(object):

    def __init__(self):

        self.ldap_client = LdapClient(config.get("default", "ldap_uri"),

                                      config.get("default", "ldap_user"),

                                      config.get("default", "ldap_key"),

                                      config.get("default", "base_dn"))

                                          config.get("default", "api_key"))

    def update_groups_from_ldap(self):

        """Add all the groups from LDAP to Rhodecode."""

        added = existing = 0

        groups = self.ldap_client.get_groups()

        for group in groups:

            try:

                added += 1

            except Exception:

                existing += 1

        return added, existing

    def update_memberships_from_ldap(self, group):

        groups = self.ldap_client.get_groups()

        group_users = self.ldap_client.get_group_users(groups, group)

        # Delete memberships first from each group which are not part

        # of the group any more.

                try:

                    self.rhodocode_api.remove_membership(group,

                except UserNotInGroupError:

                    pass

        # Add memberships.

        for member in group_users:

            try:

            except UserAlreadyInGroupError:

                # TODO: handle somehow maybe..

                pass

if __name__ == '__main__':

    sync = LdapSync()

    print sync.update_groups_from_ldap()

    for gr in sync.ldap_client.get_groups():

        # TODO: exception when user does not exist during add membership...

        # How should we handle this.. Either sync users as well at this step,

        # or just ignore those who don't exist. If we want the second case,

        # we need to find a way to recognize the right exception (we always get

        sync.update_memberships_from_ldap(gr)

#!/bin/sh

psql -U postgres -h localhost -c 'drop database if exists rhodecode;'

psql -U postgres -h localhost -c 'create database rhodecode;'

paster setup-db rc.ini --force-yes --user=marcink --password=qweqwe --email=marcin@python-blog.com --repos=/home/marcink/repos --no-public-access

API_KEY=`psql -R " " -A -U postgres -h localhost -c "select api_key from users where admin=TRUE" -d rhodecode | awk '{print $2}'`

echo "run those after running server"

paster serve rc.ini --pid-file=rc.pid --daemon

sleep 3

echo "killing server"

kill `cat rc.pid`

rm rc.pid

    include_package_data=True,

    test_suite='nose.collector',

    package_data=package_data,

    message_extractors={'kallithea': [

            ('**.py', 'python', None),

            ('templates/**.mako', 'mako', {'input_encoding': 'utf-8'}),

            ('templates/**.html', 'mako', {'input_encoding': 'utf-8'}),

            ('public/**', 'ignore', None)]},

    zip_safe=False,

    paster_plugins=['PasteScript', 'Pylons'],

    entry_points="""

    [console_scripts]

    [paste.app_factory]

    main = kallithea.config.middleware:make_app

    [paste.app_install]

    main = pylons.util:PylonsInstaller

    [paste.global_paster_command]

    setup-db=kallithea.lib.paster_commands.setup_db:Command

    update-repoinfo=kallithea.lib.paster_commands.update_repoinfo:Command

    make-rcext=kallithea.lib.paster_commands.make_rcextensions:Command

    repo-scan=kallithea.lib.paster_commands.repo_scan:Command