)

    return 0

if __name__ == '__main__':

    sys.exit(main(sys.argv))

        logging.info('Removing file %s', self.backup_file_name)

        os.remove(os.path.join(self.backup_file_path, self.backup_file_name))

if __name__ == "__main__":

    repo_location = '/home/repo_path'

        # Disable transaction manager -- currently Kallithea takes care of transactions itself

        self['tm.enabled'] = False

base_config = KallitheaAppConfig()

# TODO still needed as long as we use pylonslib

        repo2db_mapper(ScmModel().repo_scan(repos_path),

                       remove_obsolete=False, install_git_hooks=False)

hooks.register('configure_new_app', setup_configuration)

        app = HttpsFixup(app, config)

    return app

hooks.register('before_config', setup_application)

# make_base_app will wrap the TurboGears2 app with all the middleware it needs.

make_base_app = base_config.setup_tg_wsgi_app(load_environment)

def make_app_without_logging(global_conf, full_stack=True, **app_conf):

    """The core of make_app for use from gearbox commands (other than 'serve')"""

    return make_base_app(global_conf, full_stack=full_stack, **app_conf)

def make_app(global_conf, full_stack=True, **app_conf):

    """

    Set up Kallithea with the settings found in the PasteDeploy configuration

    _handler(repo_path, push_data, os.environ)

    sys.exit(0)

if __name__ == '__main__':

    main()

    _handler(repo_path, push_data, os.environ)

    sys.exit(0)

if __name__ == '__main__':

    main()

     :param created_by:

    """

    return 0

CREATE_REPO_HOOK = _crrepohook

    """

    reason = 'allowed'

    return True, reason

PRE_CREATE_USER_HOOK = _pre_cruserhook

#==============================================================================

      :param created_by:

    """

    return 0

CREATE_USER_HOOK = _cruserhook

     :param deleted_on:

    """

    return 0

DELETE_REPO_HOOK = _dlrepohook

      :param deleted_by:

    """

    return 0

DELETE_USER_HOOK = _dluserhook

      :param pushed_revs: list of pushed revisions

    """

    return 0

PUSH_HOOK = _pushhook

      :param repository: repository name

    """

    return 0

PULL_HOOK = _pullhook

                  action="delete", conditions=dict(method=["POST"],

                                                   function=check_group_skip_path))

    #ADMIN USER ROUTES

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/users') as m:

        m.connect("edit_user_group_default_perms_update", "/user_groups/{id}/edit/default_perms",

                  action="update_default_perms", conditions=dict(method=["POST"]))

        m.connect("edit_user_group_perms", "/user_groups/{id}/edit/perms",

                  action="edit_perms", conditions=dict(method=["GET"]))

        m.connect("edit_user_group_perms_update", "/user_groups/{id}/edit/perms",

        m.connect("edit_user_group_members", "/user_groups/{id}/edit/members",

                  action="edit_members", conditions=dict(method=["GET"]))

    #ADMIN PERMISSIONS ROUTES

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/permissions') as m:

        m.connect("admin_permissions_perms", "/permissions/perms",

                  action="permission_perms", conditions=dict(method=["GET"]))

    #ADMIN DEFAULTS ROUTES

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/defaults') as m:

        m.connect("new_gist", "/gists/new",

                  action="new", conditions=dict(method=["GET"]))

        m.connect("gist_delete", "/gists/{gist_id}/delete",

                  action="delete", conditions=dict(method=["POST"]))

        m.connect("edit_gist", "/gists/{gist_id}/edit",

        m.connect("edit_gist_check_revision", "/gists/{gist_id}/edit/check_revision",

                  action="check_revision", conditions=dict(method=["POST"]))

        m.connect("gist", "/gists/{gist_id}",

                  action="show", conditions=dict(method=["GET"]))

        m.connect("gist_rev", "/gists/{gist_id}/{revision}",

                 controller='admin/repos', action="delete_repo_field",

                 conditions=dict(method=["POST"], function=check_repo))

    rmap.connect("edit_repo_advanced", "/{repo_name:.*?}/settings/advanced",

                 controller='admin/repos', action="edit_advanced",

                 conditions=dict(method=["GET"], function=check_repo))

                 controller='admin/repos', action="edit_advanced_fork",

                 conditions=dict(method=["POST"], function=check_repo))

    rmap.connect("edit_repo_caches", "/{repo_name:.*?}/settings/caches",

                 controller='admin/repos', action="edit_caches",

                 conditions=dict(method=["GET"], function=check_repo))

                 controller='admin/repos', action="edit_caches",

                 conditions=dict(method=["POST"], function=check_repo))

    rmap.connect("edit_repo_remote", "/{repo_name:.*?}/settings/remote",

                 controller='admin/repos', action="edit_remote",

                 conditions=dict(method=["GET"], function=check_repo))

    """

    def __call__(self, *args, **kwargs):

        return request.environ['routes.url'](*args, **kwargs)

    def current(self, *args, **kwargs):

        return request.environ['routes.url'].current(*args, **kwargs)

url = UrlGenerator()

        success = True

        revision = request.POST.get('revision')

        if revision != last_rev.raw_id:

            log.error('Last revision %s is different than submitted %s',

                      revision, last_rev)

                    force_defaults=False)

            except Exception:

                log.error(traceback.format_exc())

                        % form_result.get('username'), category='error')

        if update:

            raise HTTPFound(location='my_account')

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

                    % request.POST.get('group_name'), category='error')

            parent_group_id = form_result['parent_group_id']

            #TODO: maybe we should get back to the main view, not the admin one

            new_gr = RepoGroupModel().update(group_name, form_result)

            Session().commit()

                    % form_result['group_name'], category='success')

            # we now have new name !

            group_name = new_gr.group_name

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

                    % request.POST.get('group_name'), category='error')

        raise HTTPFound(location=url('edit_repo_group', group_name=group_name))

        except Exception:

            log.error(traceback.format_exc())

                    % repo_name, category='error')

        raise HTTPFound(location=url('edit_repo', repo_name=changed_name))

                    category='error')

        raise HTTPFound(location=url('edit_repo_advanced', repo_name=repo_name))

    @HasRepoPermissionLevelDecorator('admin')

    def edit_advanced_fork(self, repo_name):

        """

        if request.POST:

            rm_obsolete = request.POST.get('destroy', False)

            install_git_hooks = request.POST.get('hooks', False)

            invalidate_cache = request.POST.get('invalidate', False)

            log.debug('rescanning repo location with destroy obsolete=%s, '

                      'install git hooks=%s and '

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

                    % request.POST.get('users_group_name'), category='error')

        raise HTTPFound(location=url('users_groups'))

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

                    % request.POST.get('users_group_name'), category='error')

        raise HTTPFound(location=url('edit_users_group', id=id))

                                     key=lambda u: u.username.lower())

        return render('admin/user_groups/user_group_edit.html')

    @HasUserGroupPermissionLevelDecorator('admin')

    def edit_members(self, id):

        c.user_group = UserGroup.get_or_404(id)

            h.flash(e, 'error')

        except Exception:

            log.error(traceback.format_exc())

                    % request.POST.get('username'), category='error')

        raise HTTPFound(location=url('edit_user', id=user.user_id))

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

                    % form_result.get('username'), category='error')

        raise HTTPFound(location=url('edit_user', id=id))

from kallithea.controllers.error import ErrorController

from tg import config

# This is the main Kallithea entry point; TurboGears will forward all requests

# to an instance of 'controller.root.RootController' in the configured

# 'application' module (set by app_cfg.py).  Requests are forwarded to

            for i in range(fl, fl + lncount):

                if i % st == 0:

                    if aln:

                                     % (la, i, mw, i))

                    else:

                        lines.append('%*d' % (mw, i))

        import bcrypt

        return bcrypt.hashpw(safe_str(password), bcrypt.gensalt(10))

    else:

                        % __platform__)

            log.error('error from bcrypt checking password: %s', e)

            return False

    else:

                        % __platform__)

    for gr, perms in _grouped:

        # since user can be in multiple groups iterate over them and

        # select the lowest permissions first (more explicit)

        if not gr.inherit_default_permissions:

            # NEED TO IGNORE all configurable permissions and

            # replace them with explicitly set

                #log.debug('Initializing lazy formencode object: %s', obj)

                return LazyFormencode(obj, *args, **kwargs)

        class ProxyGet(object):

            def __getattribute__(self, name):

                return LazyCaller(name)

                        username, module)

    return None

def get_managed_fields(user):

    """return list of fields that are managed by the user's auth source, usually some of

    'username', 'firstname', 'lastname', 'email', 'active', 'password'

    """

    v = []

    def visit_bindparam(bind):

        if bind.key in query._params:

            value = query._params[bind.key]

        elif bind.callable:

        f_async.__name__ = f_org.__name__

        from kallithea.lib import celerypylons

        runner = celerypylons.task(ignore_result=True)(f_async)

        def f_wrapped(*args, **kwargs):

            t = runner.apply_async(args=args, kwargs=kwargs)

            log.info('executing task %s in async mode - id %s', f_org, t.task_id)

        return False

    return True

@celerylib.task

@celerylib.dbsession

def create_repo(form_data, cur_user):

    # Verify .ini file configuration has been loaded

    assert config['celery.imports'] == 'kallithea.lib.celerylib.tasks', 'Kallithea Celery configuration has not been loaded'

    celery_config = CeleryConfig()

    PREFIXES = """ADMINS BROKER CASSANDRA CELERYBEAT CELERYD CELERYMON CELERY EMAIL SERVER""".split()

# Python Software Foundation License

# XXX: it feels like using the class with "is" and "is not" instead of "==" and

# "!=" should be faster.

class _Nil(object):

        else:

            return NotImplemented

_nil = _Nil()

from gearbox.command import Command

class UpgradeDb(Command):

    '''(removed)'''

                                ignore_whitespace, context)

    return vcs_gitdiff

NEW_FILENODE = 1

DEL_FILENODE = 2

MOD_FILENODE = 3

    _escape_re = re.compile(r'(&)|(<)|(>)|(\t)|(\r)|(?<=.)( \n| $)')

    def __init__(self, diff, vcs='hg', format='gitdiff', diff_limit=None):

        """

        :param diff:   a text in diff format

        _files = []

        diff_container = lambda arg: arg

        for raw_diff in ('\n' + self._diff).split('\ndiff --git')[1:]:

            head, diff = self._get_header(raw_diff)

    return (value.tzinfo is not None

            and value.tzinfo.utcoffset(value) is not None)

def _obj_dump(obj):

    """

    Custom function for dumping objects to JSON, if obj has __json__ attribute

nullrev = -1

def _first_known_ancestors(parentrev_func, minrev, knownrevs, head):

    """

    Return the apparent parents of the head revision in a filtered DAG.

            seen.add(r)

    return ancestors

def graph_data(repo, revs):

    """Return a DAG with colored edge information for revs

    dag = _dagwalker(repo, revs)

    return list(_colored(repo, dag))

def _dagwalker(repo, revs):

    """Iterate over revs, yielding revs (highest first) and parents to show in the graph."""

    if not revs:

        parents.

    """

    branch_cache = {}

    def branch(rev):

        """Return branch for rev, using cache for efficiency.

        For Mercurial, always return the named branch name (which may be 'default').

        kargs['qualified'] = True

    return url(*args, **kargs)

def canonical_hostname():

    '''Return canonical hostname of system'''

    from kallithea import CONFIG

        parts = url('home', qualified=True).split('://', 1)

        return parts[1].split('/', 1)[0]

def html_escape(s):

    """Return string with all html escaped.

    This is also safe for javascript in html but not necessarily correct.

        .replace('>', r'\x3e')

    )

def jshtml(val):

    """HTML escapes a string value, then converts the resulting string

    to its corresponding JavaScript representation (see `js`).

    convert_boolean_attrs(attrs, ["disabled"])

    return HTML.input(**attrs)

reset = _reset

safeid = _make_safe_id_component

        return literal('/'.join(url_l))

files_breadcrumbs = _FilesBreadCrumbs()

_whitespace_re = re.compile(r'(\t)|( )(?=\n|</div>)')

def _markup_whitespace(m):

    groups = m.groups()

    if groups[0]:

    if groups[1]:

        return ' <i></i>'

def markup_whitespace(s):

    return _whitespace_re.sub(_markup_whitespace, s)

def pygmentize(filenode, **kwargs):

    """

    pygmentize function using pygments

    def __html__(self):

        return escape(safe_unicode(self.message))

class Flash(_Flash):

    def __call__(self, message, category=None, ignore_duplicate=False, logf=None):

        session.save()

        return [_Message(*m) for m in messages]

flash = Flash()

#==============================================================================

        return User.get_by_email(email, cache=True) # cache will only use sql_cache_short

    return None

def email_or_none(author):

    """Try to match email part of VCS committer string with a local user.

    Return primary email of user, email part of the specified author name, or None."""

    # No valid email, not a valid user in the system, none!

    return None

def person(author, show_attr="username"):

    """Find the user identified by 'author', return one of the users attributes,

    default to the username attribute, None if there is no user"""

                   (''.join(attributes),

                    gravatar(email_address, cls=cls, size=size)))

def gravatar(email_address, cls='', size=30):

    """return html element of the gravatar

    return literal(html)

def gravatar_url(email_address, size=30, default=''):

    # doh, we need to re-import those to mock it later

    from kallithea.config.routing import url

    re.VERBOSE | re.MULTILINE | re.IGNORECASE)

def urlify_text(s, repo_name=None, link_=None, truncate=None, stylize=False, truncatef=truncate):

    """

    Parses given text message and make literal html with markup.

            # Wrap tmp_urlify_issues_f with substitution of this pattern, while making sure all loop variables (and compiled regexpes) are bound

            issue_re = re.compile(issue_pat)

            def issues_replace(match_obj,

                               issue_server_link=issue_server_link, issue_prefix=issue_prefix):

                leadingspace = ' ' if match_obj.group().startswith(' ') else ''

        return short_id(ref_name)

    return ref_name

def link_to_ref(repo_name, ref_type, ref_name, rev=None):

    """

    Return full markup for a href to changeset_home for a changeset.

        l = literal('%s (%s)' % (l, link_to(short_id(rev), url('changeset_home', repo_name=repo_name, revision=rev))))

    return l

def changeset_status(repo, revision):

    from kallithea.model.changeset_status import ChangesetStatusModel

    return ChangesetStatusModel().get_status(repo, revision)

    return _collapse_address_list_recursive(sorted(

        addrs + nets, key=_BaseNet._get_networks_key))

# backwards compatibility

CollapseAddrList = collapse_address_list

# We need to distinguish between the string and packed-bytes representations

# of an IP address.  For example, b'0::1' is the IPv4 address 48.58.58.49,

# while '0::1' is an IPv6 address.

        # Extract pre blocks.

        extractions = {}

        def pre_extraction_callback(matchobj):

            digest = md5(matchobj.group(0)).hexdigest()

            extractions[digest] = matchobj.group(0)

from beaker.session import SessionObject

from beaker.middleware import SessionMiddleware

class SecureSessionMiddleware(SessionMiddleware):

    def __call__(self, environ, start_response):

        """

    )

    return ishg_path

class SimpleHg(BaseVCSController):

    def _handle_request(self, environ, start_response):

from webhelpers.html import literal, HTML

from webhelpers.paginate import Page as _Page

class Page(_Page):

    """

    Custom pager to match rendering style with YUI paginator emitting Bootstrap paginators

    HandleCommandLine(params)

'''

class Command(BasePasterCommand):

    '''Kallithea: Install into IIS using isapi-wsgi'''

        self.attachments.append({'filename': filename,

                                 'content_type': content_type,

                                 'data': data,

    def attach_part(self, part):

        """

            self._fqdn = socket.getfqdn()

        return self._fqdn