issue_prefix = #

## issue_pat, issue_server_link, issue_prefix can have suffixes to specify

## multiple patterns, to other issues server, wiki or others

## below an example how to create a wiki pattern 

#  #wiki-some-id -> https://mywiki.com/some-id

#issue_pat_wiki = (?:wiki-)(.+)

#issue_server_link_wiki = https://mywiki.com/{id}

#issue_prefix_wiki = WIKI-

## instance-id prefix

## a prefix key for this instance used for cache invalidation when running 

## multiple instances of rhodecode, make sure it's globally unique for 

## all running rhodecode instances. Leave empty if you don't use it

instance_id = 

## alternative return HTTP header for failed authentication. Default HTTP

## response is 401 HTTPUnauthorized. Currently HG clients have troubles with 

## handling that. Set this variable to 403 to return HTTPForbidden

auth_ret_code =

####################################

###        CELERY CONFIG        ####

####################################

use_celery = false

broker.host = localhost

broker.vhost = rabbitmqhost

broker.port = 5672

broker.user = rabbitmq

broker.password = qweqwe

celery.imports = rhodecode.lib.celerylib.tasks

celery.result.backend = amqp

celery.result.dburi = amqp://

celery.result.serialier = json

#celery.send.task.error.emails = true

#celery.amqp.task.result.expires = 18000

celeryd.concurrency = 2

#celeryd.log.file = celeryd.log

celeryd.log.level = debug

celeryd.max.tasks.per.child = 1

issue_prefix = #

## issue_pat, issue_server_link, issue_prefix can have suffixes to specify

## multiple patterns, to other issues server, wiki or others

## below an example how to create a wiki pattern 

#  #wiki-some-id -> https://mywiki.com/some-id

#issue_pat_wiki = (?:wiki-)(.+)

#issue_server_link_wiki = https://mywiki.com/{id}

#issue_prefix_wiki = WIKI-

## instance-id prefix

## a prefix key for this instance used for cache invalidation when running 

## multiple instances of rhodecode, make sure it's globally unique for 

## all running rhodecode instances. Leave empty if you don't use it

instance_id = 

## alternative return HTTP header for failed authentication. Default HTTP

## response is 401 HTTPUnauthorized. Currently HG clients have troubles with 

## handling that. Set this variable to 403 to return HTTPForbidden

auth_ret_code =

####################################

###        CELERY CONFIG        ####

####################################

use_celery = false

broker.host = localhost

broker.vhost = rabbitmqhost

broker.port = 5672

broker.user = rabbitmq

broker.password = qweqwe

celery.imports = rhodecode.lib.celerylib.tasks

celery.result.backend = amqp

celery.result.dburi = amqp://

celery.result.serialier = json

#celery.send.task.error.emails = true

#celery.amqp.task.result.expires = 18000

celeryd.concurrency = 2

#celeryd.log.file = celeryd.log

celeryd.log.level = debug

celeryd.max.tasks.per.child = 1

issue_prefix = #

## issue_pat, issue_server_link, issue_prefix can have suffixes to specify

## multiple patterns, to other issues server, wiki or others

## below an example how to create a wiki pattern 

#  #wiki-some-id -> https://mywiki.com/some-id

#issue_pat_wiki = (?:wiki-)(.+)

#issue_server_link_wiki = https://mywiki.com/{id}

#issue_prefix_wiki = WIKI-

## instance-id prefix

## a prefix key for this instance used for cache invalidation when running 

## multiple instances of rhodecode, make sure it's globally unique for 

## all running rhodecode instances. Leave empty if you don't use it

instance_id = 

## alternative return HTTP header for failed authentication. Default HTTP

## response is 401 HTTPUnauthorized. Currently HG clients have troubles with 

## handling that. Set this variable to 403 to return HTTPForbidden

auth_ret_code =

####################################

###        CELERY CONFIG        ####

####################################

use_celery = false

broker.host = localhost

broker.vhost = rabbitmqhost

broker.port = 5672

broker.user = rabbitmq

broker.password = qweqwe

celery.imports = rhodecode.lib.celerylib.tasks

celery.result.backend = amqp

celery.result.dburi = amqp://

celery.result.serialier = json

#celery.send.task.error.emails = true

#celery.amqp.task.result.expires = 18000

celeryd.concurrency = 2

#celeryd.log.file = celeryd.log

celeryd.log.level = debug

celeryd.max.tasks.per.child = 1

class LdapImportError(Exception):

    pass

class DefaultUserException(Exception):

    pass

class UserOwnsReposException(Exception):

    pass

class UserGroupsAssignedException(Exception):

    pass

class StatusChangeOnClosedPullRequestError(Exception):

    pass

class HTTPLockedRC(HTTPClientError):

    """

    """

    code = 423

    title = explanation = 'Repository Locked'

    def __init__(self, reponame, username, *args, **kwargs):

        self.title = self.explanation = ('Repository `%s` locked by '

                                         'user `%s`' % (reponame, username))

        super(HTTPLockedRC, self).__init__(*args, **kwargs)

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

                try:

                    size_scm += os.path.getsize(os.path.join(path, f))

                except OSError:

                    pass

        else:

            for f in files:

                try:

                    size_root += os.path.getsize(os.path.join(path, f))

                except OSError:

                    pass

    size_scm_f = h.format_byte_size(size_scm)

    # pre push function, currently used to ban pushing when

    # repository is locked

    try:

        rc_extras = json.loads(os.environ.get('RC_SCM_DATA', "{}"))

    except:

        rc_extras = {}

    extras = dict(repo.ui.configitems('rhodecode_extras'))

    if 'username' in extras:

        username = extras['username']

        repository = extras['repository']

        scm = extras['scm']

        locked_by = extras['locked_by']

    elif 'username' in rc_extras:

        username = rc_extras['username']

        repository = rc_extras['repository']

        scm = rc_extras['scm']

        locked_by = rc_extras['locked_by']

    else:

        raise Exception('Missing data in repo.ui and os.environ')

    usr = User.get_by_username(username)

    if locked_by[0] and usr.user_id != int(locked_by[0]):

        locked_by = User.get(locked_by[0]).username

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

    # pre push function, currently used to ban pushing when

    # repository is locked

    try:

        rc_extras = json.loads(os.environ.get('RC_SCM_DATA', "{}"))

    except:

        rc_extras = {}

    extras = dict(repo.ui.configitems('rhodecode_extras'))

    if 'username' in extras:

        username = extras['username']

        repository = extras['repository']

        scm = extras['scm']

        locked_by = extras['locked_by']

    elif 'username' in rc_extras:

        username = rc_extras['username']

        repository = rc_extras['repository']

        scm = rc_extras['scm']

        locked_by = rc_extras['locked_by']

    else:

        raise Exception('Missing data in repo.ui and os.environ')

    if locked_by[0]:

        locked_by = User.get(locked_by[0]).username

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

    """

    Logs user last pull action

    :param ui:

    :param repo:

    """

    try:

        rc_extras = json.loads(os.environ.get('RC_SCM_DATA', "{}"))

    except:

        rc_extras = {}

    extras = dict(repo.ui.configitems('rhodecode_extras'))

    if 'username' in extras:

        username = extras['username']

        repository = extras['repository']

        scm = extras['scm']

        make_lock = extras['make_lock']

        ip = extras['ip']

    elif 'username' in rc_extras:

        username = rc_extras['username']

        repository = rc_extras['repository']

        scm = rc_extras['scm']

        make_lock = rc_extras['make_lock']

        ip = rc_extras['ip']

    else:

        raise Exception('Missing data in repo.ui and os.environ')

    user = User.get_by_username(username)

    action = 'pull'

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

    # extension hook call

    from rhodecode import EXTENSIONS

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

    if isfunction(callback):

        kw = {}

        kw.update(extras)

        callback(**kw)

    if make_lock is True:

        Repository.lock(Repository.get_by_repo_name(repository), user.user_id)

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

        #sys.stdout.write(msg)

    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

    """

    try:

        rc_extras = json.loads(os.environ.get('RC_SCM_DATA', "{}"))

    except:

        rc_extras = {}

    extras = dict(repo.ui.configitems('rhodecode_extras'))

    if 'username' in extras:

        username = extras['username']

        repository = extras['repository']

        scm = extras['scm']

        make_lock = extras['make_lock']

        action = extras['action']

    elif 'username' in rc_extras:

        username = rc_extras['username']

        repository = rc_extras['repository']

        scm = rc_extras['scm']

        make_lock = rc_extras['make_lock']

        action = extras['action']

    else:

        raise Exception('Missing data in repo.ui and os.environ')

    action = action + ':%s'

    if scm == 'hg':

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

    elif scm == 'git':

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

        if '_git_revs' in kwargs:

            kwargs.pop('_git_revs')

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

    action_logger(username, action, repository, extras['ip'], commit=True)

    # extension hook call

    from rhodecode import EXTENSIONS

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

    if isfunction(callback):

        kw = {'pushed_revs': revs}

        kw.update(extras)

        callback(**kw)

    if make_lock is False:

        Repository.unlock(Repository.get_by_repo_name(repository))

        msg = 'Released lock on repo `%s`\n' % repository

        sys.stdout.write(msg)

    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

    :param repository: dict dump of repository object

    :param created_by: username who created repository

    available keys of repository_dict:

     'repo_type',

     'description',

     'private',

     'created_on',

     'enable_downloads',

     'repo_id',

     'user_id',

     'enable_statistics',

     'clone_uri',

     'fork_id',

            log.debug('Checking locking on repository')

            (make_lock,

             locked,

             locked_by) = self._check_locking_state(

                            environ=environ, action=action,

                            repo=repo_name, user_id=user.user_id

                       )

            # store the make_lock for later evaluation in hooks

            extras.update({'make_lock': make_lock,

                           'locked_by': locked_by})

        # set the environ variables for this request

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

        fix_PATH()

        log.debug('HOOKS extras is %s' % extras)

        baseui = make_ui('db')

        self.__inject_extras(repo_path, baseui, extras)

        try:

            self._handle_githooks(repo_name, action, baseui, environ)

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

                     (action, repo_name, username, ip_addr))

            app = self.__make_app(repo_name, repo_path, extras)

            return app(environ, start_response)

        except HTTPLockedRC, e:

            return e(environ, start_response)

        except Exception:

            log.error(traceback.format_exc())

            return HTTPInternalServerError()(environ, start_response)

        finally:

            # invalidate cache on push

            if action == 'push':

                self._invalidate_cache(repo_name)

    def __make_app(self, repo_name, repo_path, extras):

        """

        Make an wsgi application using dulserver

        :param repo_name: name of the repository

        :param repo_path: full path to the repository

        """

        from rhodecode.lib.middleware.pygrack import make_wsgi_app

        app = make_wsgi_app(

            repo_root=safe_str(self.basepath),

            repo_name=repo_name,

            extras=extras,

        )

        app = GunzipFilter(LimitedInputFilter(app))

             locked_by) = self._check_locking_state(

                            environ=environ, action=action,

                            repo=repo_name, user_id=user.user_id

                       )

            # store the make_lock for later evaluation in hooks

            extras.update({'make_lock': make_lock,

                           'locked_by': locked_by})

        # set the environ variables for this request

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

        fix_PATH()

        log.debug('HOOKS extras is %s' % extras)

        baseui = make_ui('db')

        self.__inject_extras(repo_path, baseui, extras)

        try:

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

                     (action, repo_name, username, ip_addr))

            app = self.__make_app(repo_path, baseui, extras)

            return app(environ, start_response)

        except RepoError, e:

            if str(e).find('not found') != -1:

                return HTTPNotFound()(environ, start_response)

        except HTTPLockedRC, e:

            return e(environ, start_response)

        except Exception:

            log.error(traceback.format_exc())

            return HTTPInternalServerError()(environ, start_response)

        finally:

            # invalidate cache on push

            if action == 'push':

                self._invalidate_cache(repo_name)

    def __make_app(self, repo_name, baseui, extras):

        """

        Make an wsgi application using hgweb, and inject generated baseui

        instance, additionally inject some extras into ui object

        """

        return hgweb_mod.hgweb(repo_name, name=repo_name, baseui=baseui)

    def __get_repository(self, environ):

        """

        Get's repository name out of PATH_INFO header

        :param environ: environ where PATH_INFO is stored

        """

        try:

            environ['PATH_INFO'] = self._get_by_id(environ['PATH_INFO'])