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

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

import sys

import platform

BACKENDS = {

    'hg': 'Mercurial repository',

    'git': 'Git repository',

}

CELERY_ON = False

    _rev = get_current_revision(quiet=True)

    if _rev and len(VERSION) > 3:

        VERSION += ('%s' % _rev[0],)

except ImportError:

    pass

__platform__ = platform.system()

__license__ = 'GPLv3'

__py_version__ = sys.version_info

is_windows = __platform__ in ['Windows']

is_unix = not is_windows

"""

Base utils for shell scripts

"""

import os

import sys

import random

import urllib2

import pprint

            "method": method,

            "args": kw

        }

    if not method:

        raise Exception('please specify method name !')

    id_ = random.randrange(1, 9999)

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

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

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

    ret = urllib2.urlopen(req)

    raw_json = ret.read()

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

import ldap

import urllib2

import uuid

try:

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

    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}

        return self.rhodecode_api_post("get_user", args)

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

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

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

import argparse

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

def argparser(argv):

    usage = (

      "rhodecode-api [-h] [--format=FORMAT] [--apikey=APIKEY] [--apihost=APIHOST] "

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

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

    )

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

                                     usage=usage)

    ## config

        sys.stderr.write('Error parsing arguments \n')

        sys.exit()

    if args.format == FORMAT_PRETTY:

        print 'Calling method %s => %s' % (method, apihost)

    json_resp = api_call(apikey, apihost, method, **margs)

    if json_resp['error']:

        json_data = json_resp['error']

    else:

        json_data = json_resp['result']

    if args.format == FORMAT_JSON:

        print json.dumps(json_data)

    elif args.format == FORMAT_PRETTY:

    return 0

if __name__ == '__main__':

    sys.exit(main(sys.argv))

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

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

import os

import sys

import logging

import tarfile

"""

"""

from __future__ import with_statement

import os

import sys

import uuid

import argparse

from mako.template import Template

def _run(argv):

    parser, args, other = argparser(argv)

    if not len(sys.argv) > 1:

        print parser.print_help()

        sys.exit(0)

    # defaults that can be overwritten by arguments

    tmpl_stored_args = {

        'http_server': 'waitress',

        'lang': 'en',

        'database_engine': 'sqlite',

        'host': '127.0.0.1',

        'port': 5000,

    }

    if other:

        # parse arguments, we assume only first is correct

        kwargs = {}

        for el in _escape_split(other[0], ','):

            kv = _escape_split(el, '=')

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

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

import argparse

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

"""

"""

from rhodecode import EXTENSIONS

from rhodecode.lib.utils2 import __get_lem

import os

import logging

import rhodecode

from mako.lookup import TemplateLookup

from pylons.configuration import PylonsConfig

from pylons.error import handle_mako_error

# don't remove this import it does magic for celery

from rhodecode.model import init_model

from rhodecode.model.scm import ScmModel

log = logging.getLogger(__name__)

    """

    Configure the Pylons environment via the ``pylons.config``

    object

    """

    config = PylonsConfig()

        imports=['from webhelpers.html import escape'])

    # sets the c attribute access when don't existing attribute are accessed

    config['pylons.strict_tmpl_context'] = True

    test = os.path.split(config['__file__'])[-1] == 'test.ini'

    if test:

        if os.environ.get('TEST_DB'):

            # swap config if we pass enviroment variable

            config['sqlalchemy.db1.url'] = os.environ.get('TEST_DB')

        from rhodecode.lib.utils import create_test_env, create_test_index

            create_test_env(TESTS_TMP_PATH, config)

            create_test_index(TESTS_TMP_PATH, config, True)

    DbManage.check_waitress()

    # MULTIPLE DB configs

    # Setup the SQLAlchemy database engine

    sa_engine_db1 = engine_from_config(config, 'sqlalchemy.db1.')

    repos_path = make_ui('db').configitems('paths')[0][1]

    config['base_path'] = repos_path

    set_rhodecode_config(config)

    instance_id = rhodecode.CONFIG.get('instance_id')

    if instance_id == '*':

        rhodecode.CONFIG['instance_id'] = instance_id

    # CONFIGURATION OPTIONS HERE (note: all config options will override

    # any Pylons config options)

    # store config reference into our module to skip import magic of

from beaker.middleware import SessionMiddleware

from routes.middleware import RoutesMiddleware

from paste.cascade import Cascade

from paste.registry import RegistryManager

from paste.urlparser import StaticURLParser

import sys

try:

    import rhodecode

    RC_HOOK_VER = '_TMPL_'

    os.environ['RC_HOOK_VER'] = RC_HOOK_VER

except ImportError:

    rhodecode = None

def main():

    if rhodecode is None:

        # exit with success if we cannot import rhodecode !!

    repo_path = os.path.abspath('.')

    push_data = sys.stdin.readlines()

    # os.environ is modified here by a subprocess call that

    # runs git and later git executes this hook.

    # Environ gets some additional info from rhodecode system

    # like IP or username from basic-auth

    sys.exit(0)

if __name__ == '__main__':

    main()

import sys

try:

    import rhodecode

    RC_HOOK_VER = '_TMPL_'

    os.environ['RC_HOOK_VER'] = RC_HOOK_VER

except ImportError:

    rhodecode = None

def main():

    if rhodecode is None:

        # exit with success if we cannot import rhodecode !!

    repo_path = os.path.abspath('.')

    push_data = sys.stdin.readlines()

    # os.environ is modified here by a subprocess call that

    # runs git and later git executes this hook.

    # Environ gets some additional info from rhodecode system

    # like IP or username from basic-auth

    sys.exit(0)

if __name__ == '__main__':

    main()

"""

Routes configuration

The more specific and detailed routes should be defined first so they

may take precedent over the more generic routes. For more information

refer to the routes manual at http://routes.groovie.org/docs/

"""

from __future__ import with_statement

from routes import Mapper

# prefix for non repository related links needs to be prefixed with `/`

ADMIN_PREFIX = '/_admin'

def make_map(config):

    """Create, configure and return the routes Mapper"""

    rmap = Mapper(directory=config['pylons.paths']['controllers'],

    rmap.minimization = False

    rmap.explicit = False

    def check_repo(environ, match_dict):

        """

        check for valid repository for proper 404 handling

        :param environ:

        :param match_dict:

        """

        repo_name = match_dict.get('repo_name')

        if match_dict.get('f_path'):

            #fix for multiple initial slashes that causes errors

            match_dict['f_path'] = match_dict['f_path'].lstrip('/')

        return is_valid_repo(repo_name, config['base_path'])

    def check_group(environ, match_dict):

        """

        check for valid repository group for proper 404 handling

        :param environ:

        :param match_dict:

        """