:created_on: Jun 3, 2012

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import argparse

import sys

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

    try:

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

    except ValueError:

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

        sys.exit()

    if args.format == FORMAT_PRETTY:

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

    error_prefix = ''

    if json_resp['error']:

        error_prefix = 'ERROR:'

        json_data = json_resp['error']

    else:

        json_data = json_resp['result']

    if args.format == FORMAT_JSON:

    elif args.format == FORMAT_PRETTY:

            error_prefix, json.dumps(json_data, indent=4, sort_keys=True)

    return 0

if __name__ == '__main__':

    sys.exit(main(sys.argv))

Original author and date, and relevant copyright and licensing information is below:

:created_on: Apr 4, 2013

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import sys

import kallithea.bin.kallithea_cli_base as cli_base

from kallithea.model.db import *

@cli_base.register_command(config_file_initialize_app=True)

def ishell():

    """Interactive shell for Kallithea."""

    try:

        from IPython import embed

    except ImportError:

        sys.exit(-1)

    from traitlets.config.loader import Config

    cfg = Config()

    cfg.InteractiveShellEmbed.confirm_exit = False

    embed(config=cfg, banner1="Kallithea IShell.")

:created_on: May 9, 2013

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import argparse

import fileinput

import os

import stat

import sys

            gist_type='private' if args.private else 'public',

            files=files

        )

        json_data = api_call(apikey, host, 'create_gist', **margs)['result']

        if args.format == FORMAT_JSON:

        elif args.format == FORMAT_PRETTY:

    return 0

def main(argv=None):

    """

    Main execution function for cli

    if argv is None:

        argv = sys.argv

    try:

        return _run(argv)

    except Exception as e:

        return 1

if __name__ == '__main__':

    sys.exit(main(sys.argv))

:created_on: Mar 06, 2013

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import urllib2

import uuid

from ConfigParser import ConfigParser

import ldap

                # TODO: handle somehow maybe..

                pass

if __name__ == '__main__':

    sync = LdapSync()

    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

:created_on: Apr 10, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import os

import sys

import uuid

import alembic.command

        log.info("Any existing database is going to be destroyed")

        if self.tests:

            destroy = True

        else:

            destroy = self._ask_ok('Are you sure to destroy old database ? [y/n]')

        if not destroy:

            sys.exit(0)

        if destroy:

            # drop and re-create old schemas

            url = sqlalchemy.engine.url.make_url(self.dburi)

            database = url.database

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

import os

from multiprocessing.util import Finalize

from kallithea.lib.compat import kill

                                  args=(self, debug), exitpriority=10)

    @staticmethod

    def _on_finalize(lock, debug):

        if lock.held:

            if debug:

            lock.release()

    def lock(self):

        """

        locking function, if lock is present it

        will raise LockHeld exception

        """

        lockname = str(os.getpid())

        if self.debug:

        self.trylock()

        self.makelock(lockname, self.pidfile)

        return True

    def trylock(self):

        running_pid = False

        if self.debug:

        try:

            with open(self.pidfile, 'r') as f:

                try:

                    running_pid = int(f.readline())

                except ValueError:

                    running_pid = -1

            if self.debug:

            # Now we check the PID from lock file matches to the current

            # process PID

            if running_pid:

                try:

                    kill(running_pid, 0)

                except OSError as exc:

                    if exc.errno in (errno.ESRCH, errno.EPERM):

                        print ("Lock File is there but"

                               " the program is not running")

                        self.release()

                    else:

                        raise

                else:

                    raise LockHeld()

        except IOError as e:

            if e.errno != 2:

                raise

    def release(self):

        """releases the pid by removing the pidfile

        """

        if self.debug:

        if self.callbackfn:

            #execute callback function on release

            if self.debug:

            self.callbackfn()

        try:

            if self.debug:

            os.remove(self.pidfile)

            self.held = False

        except OSError as e:

            if self.debug:

            pass

    def makelock(self, lockname, pidfile):

        """

        this function will make an actual lock

        :param lockname: actual pid of file

        :param pidfile: the file to write the pid in

        """

        if self.debug:

        dir_, file_ = os.path.split(pidfile)

        if not os.path.isdir(dir_):

            os.makedirs(dir_)

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

            f.write(lockname)

:created_on: Jan 5, 2011

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import binascii

import datetime

import os

import pwd

import re

            return True

        if ok in ('n', 'no', 'nop', 'nope'):

            return False

        retries = retries - 1

        if retries < 0:

            raise IOError

# encoding: UTF-8

import datetime

import string

import sys

from kallithea.lib.vcs.utils.filesize import filesizeformat

    pass

def main():

    import time

    bar = ProgressBar(30)

    for x in xrange(1, 31):

        bar.render(x)

        time.sleep(0.02)

    bar.stream.write('\n')

    bar = ProgressBar(50)

    bar.render(0)

    bar = ColoredProgressBar(20)

    for x in bar:

        time.sleep(0.01)

    bar = AnimatedProgressBar(20)

    for x in bar:

        time.sleep(0.01)

    bar = AnimatedColoredProgressBar(20)

    for x in bar:

        time.sleep(0.01)

    bar = BarOnlyProgressBar(20)

    for x in bar:

        time.sleep(0.01)

    bar = BarOnlyColoredProgressBar(40)

    bar.width = 60

    bar.elements += ['time', 'eta']

    for x in bar:

        time.sleep(0.01)

    total_bytes = 1024 * 1024 * 2

    bar = ProgressBar(total_bytes)

    bar.width = 50

    bar.elements.remove('steps')

    bar.elements += ['transfer', 'time', 'eta', 'speed']

    for x in xrange(0, bar.steps, 1024):

        bar.render(x)

        time.sleep(0.01)

        now = datetime.datetime.now()

        if now - bar.started >= datetime.timedelta(seconds=2):

            break

if __name__ == '__main__':

    main()

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import json

import os

import re

import tempfile

import time

import urllib2

        Runs command on the system with given ``args`` using simple space

        join without safe quoting.

        """

        command = ' '.join(args)

        ignoreReturnCode = environ.pop('ignoreReturnCode', False)

        if DEBUG:

        testenv = dict(os.environ)

        testenv['LANG'] = 'en_US.UTF-8'

        testenv['LANGUAGE'] = 'en_US:en'

        testenv['HGPLAIN'] = ''

        testenv['HGRCPATH'] = ''

        testenv.update(environ)

        p = Popen(command, shell=True, stdout=PIPE, stderr=PIPE, cwd=self.cwd, env=testenv)

        stdout, stderr = p.communicate()

        if DEBUG:

            if stdout:

            if stderr:

        if not ignoreReturnCode:

            assert p.returncode == 0

        return stdout, stderr

def _get_tmp_dir(prefix='vcs_operations-', suffix=''):

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import os

import shutil

import sys

import tempfile

from os.path import dirname

        """Runs command on the system with given ``args``.

        """

        command = cmd + ' ' + ' '.join(args)

        log.debug('Executing %s', command)

        if DEBUG:

        p = Popen(command, shell=True, stdout=PIPE, stderr=PIPE, cwd=self.cwd)

        stdout, stderr = p.communicate()

        if DEBUG:

        return stdout, stderr

def get_session():

    engine = engine_from_config(conf, 'sqlalchemy.')

    init_model(engine)

    sa = meta.Session

    return sa

def create_test_user(force=True):

    sa = get_session()

    user = sa.query(User).filter(User.username == USER).scalar()

    if force and user is not None:

        for repo in sa.query(Repository).filter(Repository.user == user).all():

            sa.delete(repo)

        sa.delete(user)

        sa.commit()

    if user is None or force:

        new_usr = User()

        new_usr.username = USER

        new_usr.password = get_crypt_password(PASS)

        new_usr.email = 'mail@example.com'

        new_usr.name = 'test'

        new_usr.lastname = 'lasttestname'

        new_usr.active = True

        new_usr.admin = True

        sa.add(new_usr)

        sa.commit()

def create_test_repo(force=True):

    from kallithea.model.repo import RepoModel

    sa = get_session()

    user = sa.query(User).filter(User.username == USER).scalar()

    if user is None:

        raise Exception('user not found')

    repo = sa.query(Repository).filter(Repository.repo_name == HG_REPO).scalar()

    if repo is None:

        form_data = {'repo_name': HG_REPO,

                     'repo_type': 'hg',

                     'private': False,

                     'clone_uri': ''}

        rm = RepoModel()

        rm.base_path = '/home/hg'

        rm.create(form_data, user)

def set_anonymous_access(enable=True):

    sa = get_session()

    user = sa.query(User).filter(User.username == 'default').one()

    user.active = enable

        if METHOD == 'pull':

            seq = tempfile._RandomNameSequence().next()

            test_clone_with_credentials(repo=sys.argv[1], method='clone',

                                        backend=backend)

        s = time.time()

        for i in range(1, int(sys.argv[2]) + 1):

            test_clone_with_credentials(repo=sys.argv[1], method=METHOD,

                                        backend=backend)

    except Exception as e:

        sys.exit('stop on %s' % e)

:created_on: Apr 21, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import cookielib

import os

import sys

import tempfile

import time

if len(sys.argv) == 2:

    BASE_URI = sys.argv[1]

if not BASE_URI.endswith('/'):

    BASE_URI += '/'

BASE_URI += '%s'

PROJECT_PATH = os.path.join('/', 'home', 'username', 'repos')

PROJECTS = [

    # 'linux-magx-pbranch',

    'CPython',

    'kallithea',

        assert f.url == full_uri, 'URL:%s does not match %s' % (f.url, full_uri)

        size = len(f.read())

        e = time.time() - s

        total_time += e

def test_changeset_walk(proj, limit=None):

    repo, proj = _get_repo(proj)

    total_time = 0

    cnt = 0

    for i in repo:

        cnt += 1

        raw_cs = '/'.join((proj, 'changeset', i.raw_id))

        if limit and limit == cnt:

            break

        full_uri = (BASE_URI % raw_cs)

        s = time.time()

        f = o.open(full_uri)

        size = len(f.read())

        e = time.time() - s

        total_time += e

def test_files_walk(proj, limit=100):

    repo, proj = _get_repo(proj)

    total_time = 0

    paths_ = OrderedSet([''])

    try:

        tip = repo.get_changeset('tip')

        for topnode, dirs, files in tip.walk('/'):

        cnt += 1

        if limit and limit == cnt:

            break

        file_path = '/'.join((proj, 'files', 'tip', f))

        full_uri = (BASE_URI % file_path)

        s = time.time()

        f = o.open(full_uri)

        size = len(f.read())

        e = time.time() - s

        total_time += e

if __name__ == '__main__':

    for path in PROJECTS:

        repo = vcs.get_repo(os.path.join(PROJECT_PATH, path))

        for i in range(PASES):

            test_changelog_walk(repo, pages=80)

            test_changeset_walk(repo, limit=100)

            test_files_walk(repo, limit=100)

#!/usr/bin/env python2

"""

Consistent formatting of rst section titles

"""

import re

import subprocess

spaces = [

    (0, 1), # we assume this is a over-and-underlined header

headermatch = re.compile(r'''\n*(.+)\n([][!"#$%&'()*+,./:;<=>?@\\^_`{|}~-])\2{2,}\n+''', flags=re.MULTILINE)

def main():

    filenames = subprocess.check_output(['hg', 'loc', 'set:**.rst+kallithea/i18n/how_to']).splitlines()

    for fn in filenames:

        s = open(fn).read()

        # find levels and their styles

        lastpos = 0

        styles = []

        for markup in headermatch.findall(s):

            style = markup[1]

            if style in styles:

                stylepos = styles.index(style)

                if stylepos > lastpos + 1:

            else:

                stylepos = len(styles)

                if stylepos > lastpos + 1:

                else:

                    styles.append(style)

            lastpos = stylepos

        # remove superfluous spacing (may however be restored by header spacing)

        s = re.sub(r'''(\n\n)\n*''', r'\1', s, flags=re.MULTILINE)

        # fix trailing space and spacing before link sections

        s = s.strip() + '\n'

        s = re.sub(r'''\n+((?:\.\. _[^\n]*\n)+)$''', r'\n\n\n\1', s)

        open(fn, 'w').write(s)

if __name__ == '__main__':

    main()

#!/usr/bin/env python2

"""

Based on kallithea/lib/paster_commands/template.ini.mako, generate development.ini

"""

import re

from kallithea.lib import inifile

# files to be generated from the mako template

]

def main():

    # make sure all mako lines starting with '#' (the '##' comments) are marked up as <text>

    makofile = inifile.template_file

    mako_org = open(makofile).read()

    mako_no_text_markup = re.sub(r'</?%text>', '', mako_org)

    mako_marked_up = re.sub(r'\n(##.*)', r'\n<%text>\1</%text>', mako_no_text_markup, flags=re.MULTILINE)

    if mako_marked_up != mako_org:

        open(makofile, 'w').write(mako_marked_up)

    # create ini files

    for fn, settings in ini_files:

        inifile.create(fn, None, settings)

if __name__ == '__main__':

    main()

#!/usr/bin/env python2

import re