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...>}

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

                    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'

# 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

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(

# 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

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

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

            "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())

        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)

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

    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)

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

            ('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