import paste.auth.basic

import paste.httpheaders

from webhelpers.pylonslib import secure_form

from tg import config, tmpl_context as c, request, response, session, render_template

from tg import TGController

from tg.i18n import ugettext as _

from kallithea import __version__, BACKENDS

from kallithea.config.routing import url

from kallithea.lib.utils2 import str2bool, safe_unicode, AttributeDict, \

from kallithea.lib import auth_modules

from kallithea.lib.auth import AuthUser, HasPermissionAnyMiddleware

from kallithea.lib.compat import json

from kallithea.lib.utils import get_repo_slug, is_valid_repo

from kallithea.lib.exceptions import UserCreationError

from kallithea.lib.vcs.exceptions import RepositoryError, EmptyRepositoryError, ChangesetDoesNotExistError

from kallithea.model import meta

from kallithea.model.db import PullRequest, Repository, User, Setting

from kallithea.model.scm import ScmModel

log = logging.getLogger(__name__)

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

            # CHECK PERMISSIONS

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

            ip_addr = self._get_ip_addr(environ)

            user, response_app = self._authorize(environ, parsed_request.action, parsed_request.repo_name, ip_addr)

            if response_app is not None:

                return response_app(environ, start_response)

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

            # REQUEST HANDLING

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

                parsed_request.repo_name, self.scm_alias, parsed_request.action)

            try:

                log.info('%s action on %s repo "%s" by "%s" from %s',

                         parsed_request.action, self.scm_alias, parsed_request.repo_name, safe_str(user.username), ip_addr)

                app = self._make_app(parsed_request)

                return app(environ, start_response)

            except Exception:

                log.error(traceback.format_exc())

                raise webob.exc.HTTPInternalServerError()

        except webob.exc.HTTPException as e:

"""

import os

import time

import binascii

from kallithea.lib.vcs.utils.hgcompat import nullrev, revrange

from kallithea.lib import helpers as h

from kallithea.lib.utils import action_logger

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea.lib.exceptions import UserCreationError

from kallithea.lib.utils import make_ui, setup_cache_regions

from kallithea.model.db import Repository, User, Ui

def _get_scm_size(alias, root_path):

    if not alias.startswith('.'):

        alias += '.'

    size_scm, size_root = 0, 0

    for path, dirs, files in os.walk(safe_str(root_path)):

        if path.find(alias) != -1:

            for f in files:

                try:

        size_hg_f, size_root_f, size_total_f, last_cs.rev(), last_cs.hex()[:12]

    )

    ui.status(msg)

def log_pull_action(ui, repo, **kwargs):

    """Logs user last pull action

    Called as Mercurial hook outgoing.pull_logger or from Kallithea before invoking Git.

    Does *not* use the action from the hook environment but is always 'pull'.

    """

    user = User.get_by_username(ex.username)

    action = 'pull'

    action_logger(user, action, ex.repository, ex.ip, commit=True)

    # extension hook call

    from kallithea import EXTENSIONS

    callback = getattr(EXTENSIONS, 'PULL_HOOK', None)

    if callable(callback):

        kw = {}

        kw.update(ex)

        callback(**kw)

    process_pushed_raw_ids(revs)

    return 0

def process_pushed_raw_ids(revs):

    """

    Register that changes have been added to the repo - log the action *and* invalidate caches.

    Called from  Mercurial changegroup.push_logger calling hook log_push_action,

    or from the Git post-receive hook calling handle_git_post_receive ...

    or from scm _handle_push.

    """

    action = '%s:%s' % (ex.action, ','.join(revs))

    action_logger(ex.username, action, ex.repository, ex.ip, commit=True)

    from kallithea.model.scm import ScmModel

    ScmModel().mark_for_invalidation(ex.repository)

    # extension hook call

    from kallithea import EXTENSIONS

    callback = getattr(EXTENSIONS, 'PUSH_HOOK', None)

    if callable(callback):

        kw = {'pushed_revs': revs}

    Create a light-weight environment for stand-alone scripts and return an UI and the

    db repository.

    Git hooks are executed as subprocess of Git while Kallithea is waiting, and

    they thus need enough info to be able to create an app environment and

    connect to the database.

    """

    from paste.deploy import appconfig

    from sqlalchemy import engine_from_config

    from kallithea.config.environment import load_environment

    from kallithea.model.base import init_model

    ini_file_path = extras['config']

    #logging.config.fileConfig(ini_file_path) # Note: we are in a different process - don't use configured logging

    app_conf = appconfig('config:%s' % ini_file_path)

    conf = load_environment(app_conf.global_conf, app_conf.local_conf)

    setup_cache_regions(conf)

    engine = engine_from_config(conf, 'sqlalchemy.')

    init_model(engine)

    repo_path = safe_unicode(repo_path)

    # fix if it's not a bare repo

def obfuscate_url_pw(engine):

    from sqlalchemy.engine import url as sa_url

    from sqlalchemy.exc import ArgumentError

    try:

        _url = sa_url.make_url(engine or '')

    except ArgumentError:

        return engine

    if _url.password:

        _url.password = 'XXXXX'

    return str(_url)

    """

    """

    try:

        extras = json.loads(os.environ['KALLITHEA_EXTRAS'])

    except KeyError:

        raise Exception("Environment variable KALLITHEA_EXTRAS not found")

    try:

        for k in ['username', 'repository', 'scm', 'action', 'ip']:

            extras[k]

    except KeyError:

        raise Exception('Missing key %s in KALLITHEA_EXTRAS %s' % (k, extras))

    return AttributeDict(extras)

    os.environ['KALLITHEA_EXTRAS'] = json.dumps(extras)

def get_current_authuser():

    """

    Gets kallithea user from threadlocal tmpl_context variable if it's

    defined, else returns None.

    """

    from tg import tmpl_context

    if hasattr(tmpl_context, 'authuser'):

        return tmpl_context.authuser

from sqlalchemy import func

from tg.i18n import ugettext as _

import kallithea

from kallithea.lib.vcs import get_backend

from kallithea.lib.vcs.exceptions import RepositoryError

from kallithea.lib.vcs.utils.lazy import LazyProperty

from kallithea.lib.vcs.nodes import FileNode

from kallithea.lib.vcs.backends.base import EmptyChangeset

from kallithea import BACKENDS

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasRepoPermissionLevel, HasRepoGroupPermissionLevel, \

    HasUserGroupPermissionLevel, HasPermissionAny, HasPermissionAny

from kallithea.lib.utils import get_filesystem_repos, make_ui, \

    action_logger

from kallithea.model.db import Repository, Session, Ui, CacheInvalidation, \

    UserFollowing, UserLog, User, RepoGroup, PullRequest

from kallithea.lib.hooks import process_pushed_raw_ids

from kallithea.lib.exceptions import NonRelativePathError, IMCCommitError

log = logging.getLogger(__name__)

    def mark_as_fork(self, repo, fork, user):

        repo = self.__get_repo(repo)

        fork = self.__get_repo(fork)

        if fork and repo.repo_id == fork.repo_id:

            raise Exception("Cannot set repository as fork of itself")

        if fork and repo.repo_type != fork.repo_type:

            raise RepositoryError("Cannot set repository as fork of repository with other type")

        repo.fork = fork

        return repo

    def _handle_push(self, repo, username, ip_addr, action, repo_name, revisions):

        """

        Handle that the repository has changed.

        Adds an action log entry with the new revisions, and the head revision

        cache and in-memory caches are invalidated/updated.

        :param username: username who pushes

        :param action: push/push_local/push_remote

        :param repo_name: name of repo

        :param revisions: list of revisions that we pushed

        """

        process_pushed_raw_ids(revisions) # also calls mark_for_invalidation

    def _get_IMC_module(self, scm_type):

        """

        Returns InMemoryCommit class based on scm_type

        :param scm_type:

        """

        if scm_type == 'hg':

            from kallithea.lib.vcs.backends.hg import MercurialInMemoryChangeset

            return MercurialInMemoryChangeset

            if repo.alias == 'git':

                repo.fetch(clone_uri)

                # git doesn't really have something like post-fetch action

                # we fake that now.

                # TODO: extract fetched revisions ... somehow ...

                self._handle_push(repo,

                                  username=username,

                                  ip_addr=ip_addr,

                                  action='push_remote',

                                  repo_name=repo_name,

                                  revisions=[])

            else:

                                           repo.alias, action='push_remote')

                repo.pull(clone_uri)

            self.mark_for_invalidation(repo_name)

        except Exception:

            log.error(traceback.format_exc())

            raise

    def commit_change(self, repo, repo_name, cs, user, ip_addr, author, message,

                      content, f_path):

        """

        Commit a change to a single file