++++++++++

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

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:

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:

def argparser(argv):

    usage = (

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

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

    )

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

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)

# 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

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"

# 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

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

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

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

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

    def __init__(self, url, key):

        self.url = url

            "args": args

        }

        """Send a generic API post to Rhodecode.

        This will generate the UUID for validation check after the

            raise InvalidResponseIDError("UUID does not match.")

        if response["error"] is not None:

        return response["result"]

            "group_name": name,

            "active": str(active)

        }

    def add_membership(self, group, username):

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

            "usersgroupid": group,

            "userid": username

        }

        if not result["success"]:

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

                                          (username, group))

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

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

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

        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

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

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

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

    entry_points="""

    [console_scripts]

    [paste.app_factory]

    main = kallithea.config.middleware:make_app