#

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

import binascii

from inspect import isfunction

from mercurial.scmutil import revrange

from mercurial.node import nullrev

from rhodecode.lib import helpers as h

from rhodecode.lib.utils import action_logger

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

from rhodecode.lib.compat import json

from rhodecode.lib.exceptions import HTTPLockedRC

from rhodecode.model.db import Repository, User

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:

    msg = ('Repository size .hg:%s repo:%s total:%s\n'

           'Last revision is now r%s:%s\n') % (

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

    )

    sys.stdout.write(msg)

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

    # pre push function, currently used to ban pushing when

    # repository is locked

        # this exception is interpreted in git/hg middlewares and based

        # on that proper return code is server to client

        if str(_http_ret.code).startswith('2'):

            #2xx Codes don't raise exceptions

            sys.stdout.write(_http_ret.title)

        else:

            raise _http_ret

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

    # pre push function, currently used to ban pushing when

    # repository is locked

        # this exception is interpreted in git/hg middlewares and based

        # on that proper return code is server to client

        if str(_http_ret.code).startswith('2'):

            #2xx Codes don't raise exceptions

            sys.stdout.write(_http_ret.title)

        else:

            raise _http_ret

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

    """

    Logs user last pull action

    :param ui:

    :param repo:

    """

    action = 'pull'

    # extension hook call

    from rhodecode import EXTENSIONS

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

    if isfunction(callback):

        kw = {}

        callback(**kw)

        #msg = 'Made lock on repo `%s`' % repository

        #sys.stdout.write(msg)

        if str(_http_ret.code).startswith('2'):

            #2xx Codes don't raise exceptions

            sys.stdout.write(_http_ret.title)

    return 0

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

    """

    Maps user last push action to new changeset id, from mercurial

    :param ui:

    :param repo: repo object containing the `ui` object

    """

        node = kwargs['node']

        def get_revs(repo, rev_opt):

            if rev_opt:

                revs = revrange(repo, rev_opt)

                if len(revs) == 0:

                    return (nullrev, nullrev)

                return (max(revs), min(revs))

            else:

                return (len(repo) - 1, 0)

        stop, start = get_revs(repo, [node + ':'])

        h = binascii.hexlify

        revs = [h(repo[r].node()) for r in xrange(start, stop + 1)]

        revs = kwargs.get('_git_revs', [])

        if '_git_revs' in kwargs:

            kwargs.pop('_git_revs')

    action = action % ','.join(revs)

    # extension hook call

    from rhodecode import EXTENSIONS

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

    if isfunction(callback):

        kw = {'pushed_revs': revs}

        callback(**kw)

        sys.stdout.write(msg)

        if str(_http_ret.code).startswith('2'):

            #2xx Codes don't raise exceptions

            sys.stdout.write(_http_ret.title)

    return 0

def log_create_repository(repository_dict, created_by, **kwargs):

    """

    Post create repository Hook. This is a dummy function for admins to re-use

    if needed. It's taken from rhodecode-extensions module and executed

    if present

        if git_command not in self.commands:

            log.debug('command %s not allowed' % git_command)

            return exc.HTTPMethodNotAllowed()

        if 'CONTENT_LENGTH' in environ:

            inputstream = FileWrapper(environ['wsgi.input'],

                                      request.content_length)

        else:

            inputstream = environ['wsgi.input']

        try:

            gitenv = os.environ

            # forget all configs

            gitenv['GIT_CONFIG_NOGLOBAL'] = '1'

            opts = dict(

                env=gitenv,

                cwd=os.getcwd()

            )

            cmd = r'git %s --stateless-rpc "%s"' % (git_command[4:],

                                                    self.content_path),

            log.debug('handling cmd %s' % cmd)

            out = subprocessio.SubprocessIOChunker(

                cmd,

                inputstream=inputstream,

  #git-push

  'git-receive-pack': dulserver.ReceivePackHandler,

}

# not used for now until dulwich get's fixed

#from dulwich.repo import Repo

#from dulwich.web import make_wsgi_chain

from paste.httpheaders import REMOTE_USER, AUTH_TYPE

from webob.exc import HTTPNotFound, HTTPForbidden, HTTPInternalServerError, \

    HTTPBadRequest, HTTPNotAcceptable

from rhodecode.lib.base import BaseVCSController

from rhodecode.lib.auth import get_container_username

from rhodecode.lib.utils import is_valid_repo, make_ui

from rhodecode.lib.compat import json

from rhodecode.model.db import User, RhodeCodeUi

log = logging.getLogger(__name__)

GIT_PROTO_PAT = re.compile(r'^/(.+)/(info/refs|git-upload-pack|git-receive-pack)')

            pre_pull(ui=baseui, repo=_repo._repo)

        if action == 'pull' and _hooks.get(RhodeCodeUi.HOOK_PULL):

            log_pull_action(ui=baseui, repo=_repo._repo)

    def __inject_extras(self, repo_path, baseui, extras={}):

        """

        Injects some extra params into baseui instance

        :param baseui: baseui instance

        :param extras: dict with extra params to put into baseui

        """

import os

import logging

import traceback

from mercurial.error import RepoError

from mercurial.hgweb import hgweb_mod

from paste.httpheaders import REMOTE_USER, AUTH_TYPE

from webob.exc import HTTPNotFound, HTTPForbidden, HTTPInternalServerError, \

    HTTPBadRequest, HTTPNotAcceptable

from rhodecode.lib.base import BaseVCSController

from rhodecode.lib.auth import get_container_username

from rhodecode.lib.utils import make_ui, is_valid_repo, ui_sections

from rhodecode.lib.compat import json

from rhodecode.model.db import User

from rhodecode.lib.exceptions import HTTPLockedRC

log = logging.getLogger(__name__)

def is_mercurial(environ):

        also overwrites global settings with those takes from local hgrc file

        :param baseui: baseui instance

        :param extras: dict with extra params to put into baseui

        """

        hgrc = os.path.join(repo_path, '.hg', 'hgrc')

        # make our hgweb quiet so it doesn't print output

        baseui.setconfig('ui', 'quiet', 'true')

        repoui = make_ui('file', hgrc, False)

        if repoui:

            #overwrite our ui instance with the section from hgrc file

            for section in ui_sections:

                for k, v in repoui.configitems(section):

                    baseui.setconfig(section, k, v)

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

import time

import datetime

import webob

from pylons.i18n.translation import _, ungettext

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

def __get_lem():

    """

    Get language extension map based on what's inside pygments lexers

    """

    from pygments import lexers

    from string import lower

    from collections import defaultdict

    d = defaultdict(lambda: [])

class AttributeDict(dict):

    def __getattr__(self, attr):

        return self.get(attr, None)

    __setattr__ = dict.__setitem__

    __delattr__ = dict.__delitem__

def fix_PATH(os_=None):

    """

    Get current active python path, and append it to PATH variable to fix issues

    of subprocess calls and different python versions

    """

    if os_ is None:

        import os

    else:

        os = os_

    cur_path = os.path.split(sys.executable)[0]

    if not os.environ['PATH'].startswith(cur_path):

        os.environ['PATH'] = '%s:%s' % (cur_path, os.environ['PATH'])

def obfuscate_url_pw(engine):

    _url = engine or ''

    try:

        _url = sa_url.make_url(engine)

        if _url.password:

            _url.password = 'XXXXX'

    except:

        pass

    return str(_url)

def get_server_url(environ):

    req = webob.Request(environ)

    return req.host_url + req.script_name

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

    # WORKDIR API #

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

    @LazyProperty

    def workdir(self):

        """

        Returns ``Workdir`` instance for this repository.

        """

        raise NotImplementedError

class BaseChangeset(object):

    """

    Each backend should implement it's changeset representation.

    **Attributes**

        ``repository``

            repository object within which changeset exists

        ``id``

            may be ``raw_id`` or i.e. for mercurial's tip just ``tip``

        self.path = abspath(repo_path)

        repo = self._get_repo(create, src_url, update_after_clone, bare)

        self.bare = repo.bare

        self._config_files = [

            bare and abspath(self.path, 'config')

                     or abspath(self.path, '.git', 'config'),

            abspath(get_user_home(), '.gitconfig'),

        ]

    @ThreadLocalLazyProperty

    def _repo(self):

    @property

    def head(self):

        try:

            return self._repo.head()

        except KeyError:

            return None

    @LazyProperty

    def revisions(self):

        """

        Returns list of revisions' ids, in ascending order.  Being lazy

from beaker.cache import cache_region, region_invalidate

from webob.exc import HTTPNotFound

from pylons.i18n.translation import lazy_ugettext as _

from rhodecode.lib.vcs import get_backend

from rhodecode.lib.vcs.utils.helpers import get_scm

from rhodecode.lib.vcs.exceptions import VCSError

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

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

from rhodecode.lib.utils2 import str2bool, safe_str, get_changeset_safe, \

from rhodecode.lib.compat import json

from rhodecode.lib.caching_query import FromCache

from rhodecode.model.meta import Base, Session

URL_SEP = '/'

log = logging.getLogger(__name__)

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

# BASE CLASSES

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

        path_prefix = self.group.full_path_splitted if self.group else []

        return Repository.url_sep().join(path_prefix + [repo_name])

    @property

    def _ui(self):

        """

        Creates an db based ui object for this repository

        """

        from rhodecode.lib.utils import make_ui

        return make_ui('db', clear_session=False)

    @classmethod

    def is_valid(cls, repo_name):

        """

        returns True if given repo name is a valid filesystem repository

        :param cls:

        :param repo_name:

        """

        from rhodecode.lib.utils import is_valid_repo

        return is_valid_repo(repo_name, cls.base_path())

    def get_api_data(self):

from sqlalchemy import func

from pylons.i18n.translation import _

import rhodecode

from rhodecode.lib.vcs import get_backend

from rhodecode.lib.vcs.exceptions import RepositoryError

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

from rhodecode.lib.vcs.nodes import FileNode

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

from rhodecode import BACKENDS

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import HasRepoPermissionAny, HasReposGroupPermissionAny

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

    action_logger, REMOVED_REPO_PAT

from rhodecode.model import BaseModel

from rhodecode.model.db import Repository, RhodeCodeUi, CacheInvalidation, \

    UserFollowing, UserLog, User, RepoGroup, PullRequest

from rhodecode.lib.hooks import log_push_action

log = logging.getLogger(__name__)

class UserTemp(object):

        extras = {

            'ip': _get_ip_addr(environ),

            'username': username,

            'action': 'push_local',

            'repository': repo_name,

            'scm': repo.alias,

            'config': CONFIG['__file__'],

            'server_url': get_server_url(environ),

            'make_lock': None,

            'locked_by': [None, None]

        }

        _scm_repo = repo._repo

        if repo.alias == 'hg':

            log_push_action(_scm_repo.ui, _scm_repo, node=revisions[0])

        elif repo.alias == 'git':

            log_push_action(_scm_repo.ui, _scm_repo, _git_revs=revisions)

    def _get_IMC_module(self, scm_type):

        """

        Returns InMemoryCommit class based on scm_type

        :param scm_type:

        """

        if scm_type == 'hg':