usage/locking

.. _locking:

===================================

RhodeCode repository locking system

===================================

| Repos with **locking function=disabled** is the default, that's how repos work 

  today.

| Repos with **locking function=enabled** behaves like follows:

Repos have a state called `locked` that can be true or false.

The hg/git commands `hg/git clone`, `hg/git pull`, and `hg/git push` 

influence this state:

- The command `hg/git pull <repo>` will lock that repo (locked=true) 

  if the user has write/admin permissions on this repo

- The command `hg/git clone <repo>` will lock that repo (locked=true) if the 

  user has write/admin permissions on this repo

RhodeCode will remember the user id who locked the repo

only this specific user can unlock the repo (locked=false) by calling 

- `hg/git push <repo>` 

every other command on that repo from this user and 

every command from any other user will result in http return code 423 (locked)

additionally the http error includes the <user> that locked the repo 

(e.g. “repository <repo> locked by user <user>”)

So the scenario of use for repos with `locking function` enabled is that 

every initial clone and every pull gives users (with write permission)

the exclusive right to do a push.

Each repo can be manually unlocked by admin from the repo settings menu.

#!/usr/bin/env python

import os

import sys

try:

    import rhodecode

    RC_HOOK_VER = '_TMPL_'

    os.environ['RC_HOOK_VER'] = RC_HOOK_VER

    from rhodecode.lib.hooks import handle_git_pre_receive

except ImportError:

    rhodecode = None

def main():

    if rhodecode is None:

        # exit with success if we cannot import rhodecode !!

        # this allows simply push to this repo even without

        # rhodecode

        sys.exit(0)

    repo_path = os.path.abspath('.')

    push_data = sys.stdin.readlines()

    # os.environ is modified here by a subprocess call that

    # runs git and later git executes this hook.

    # Environ get's some additional info from rhodecode system

    # like IP or username from basic-auth

    handle_git_pre_receive(repo_path, push_data, os.environ)

    sys.exit(0)

if __name__ == '__main__':

    main()

        m.connect('repo_locking', "/repo_locking/{repo_name:.*?}",

                  action="repo_locking", conditions=dict(method=["PUT"],

                                                      function=check_repo))

            log.error(traceback.format_exc())

            log.error(traceback.format_exc())

    def repo_locking(self, repo_name):

        """

        Unlock repository when it is locked !

        :param repo_name:

        """

        try:

            repo = Repository.get_by_repo_name(repo_name)

            if request.POST.get('set_lock'):

                Repository.lock(repo, c.rhodecode_user.user_id)

            elif request.POST.get('set_unlock'):

                Repository.unlock(repo)

        except Exception, e:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during unlocking'),

                    category='error')

        return redirect(url('edit_repo', repo_name=repo_name))

    @HasPermissionAllDecorator('hg.admin')

        log.debug('checking VCS protocol '

from webob.exc import HTTPClientError

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

    safe_str

from rhodecode.model.db import Repository, RhodeCodeUi, User

from rhodecode.model.meta import Session

    def _check_locking_state(self, environ, action, repo, user_id):

        """

        Checks locking on this repository, if locking is enabled and lock is

        present returns a tuple of make_lock, locked, locked_by.

        make_lock can have 3 states None (do nothing) True, make lock

        False release lock, This value is later propagated to hooks, which

        do the locking. Think about this as signals passed to hooks what to do.

        """

        locked = False

        make_lock = None

        repo = Repository.get_by_repo_name(repo)

        user = User.get(user_id)

        # this is kind of hacky, but due to how mercurial handles client-server

        # server see all operation on changeset; bookmarks, phases and

        # obsolescence marker in different transaction, we don't want to check

        # locking on those

        obsolete_call = environ['QUERY_STRING'] in ['cmd=listkeys',]

        locked_by = repo.locked

        if repo and repo.enable_locking and not obsolete_call:

            if action == 'push':

                #check if it's already locked !, if it is compare users

                user_id, _date = repo.locked

                if user.user_id == user_id:

                    log.debug('Got push from user, now unlocking' % (user))

                    # unlock if we have push from user who locked

                    make_lock = False

                else:

                    # we're not the same user who locked, ban with 423 !

                    locked = True

            if action == 'pull':

                if repo.locked[0] and repo.locked[1]:

                    locked = True

                else:

                    log.debug('Setting lock on repo %s by %s' % (repo, user))

                    make_lock = True

        else:

            log.debug('Repository %s do not have locking enabled' % (repo))

        return make_lock, locked, locked_by

        self.sa.add(hooks1)

        self.sa.add(hooks2)

        self.sa.add(hooks3)

        hooks4.ui_key = RhodeCodeUi.HOOK_PRE_PUSH

        hooks4.ui_value = 'python:rhodecode.lib.hooks.pre_push'

        self.sa.add(hooks4)

        hooks5 = RhodeCodeUi()

        hooks5.ui_section = 'hooks'

        hooks5.ui_key = RhodeCodeUi.HOOK_PULL

        hooks5.ui_value = 'python:rhodecode.lib.hooks.log_pull_action'

        self.sa.add(hooks5)

        hooks6 = RhodeCodeUi()

        hooks6.ui_section = 'hooks'

        hooks6.ui_key = RhodeCodeUi.HOOK_PRE_PULL

        hooks6.ui_value = 'python:rhodecode.lib.hooks.pre_pull'

        self.sa.add(hooks6)

        self.sa.add(largefiles)

        self.sa.add(hgsubversion)

        phases = RhodeCodeUi()

        phases.ui_section = 'phases'

        phases.ui_key = 'publish'

        phases.ui_value = False

from webob.exc import HTTPClientError

    pass

class HTTPLockedRC(HTTPClientError):

    """

    Special Exception For locked Repos in RhodeCode

    """

    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)

    get_changeset_safe, datetime_to_time, time_to_datetime

def person_by_id(id_):

    # attr to return from fetched user

    person_getter = lambda usr: usr.username

    #maybe it's an ID ?

    if str(id_).isdigit() or isinstance(id_, int):

        id_ = int(id_)

        user = User.get(id_)

        if user is not None:

            return person_getter(user)

    return id_

from rhodecode.model.db import Repository, User

from rhodecode.lib.utils2 import safe_str

from rhodecode.lib.exceptions import HTTPLockedRC

def pre_push(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')

    usr = User.get_by_username(username)

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

        raise HTTPLockedRC(username, repository)

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

        raise HTTPLockedRC(username, repository)

        make_lock = extras['make_lock']

        make_lock = rc_extras['make_lock']

    user = User.get_by_username(username)

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

    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)

        make_lock = extras['make_lock']

        make_lock = rc_extras['make_lock']

    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)

handle_git_pre_receive = (lambda repo_path, revs, env:

    handle_git_receive(repo_path, revs, env, hook_type='pre'))

handle_git_post_receive = (lambda repo_path, revs, env:

    handle_git_receive(repo_path, revs, env, hook_type='post'))

def handle_git_receive(repo_path, revs, env, hook_type='post'):

    extras = json.loads(env['RHODECODE_EXTRAS'])

    for k, v in extras.items():

        baseui.setconfig('rhodecode_extras', k, v)

    repo = repo.scm_instance

    repo.ui = baseui

    if hook_type == 'pre':

        pre_push(baseui, repo)

    # if push hook is enabled via web interface

    elif hook_type == 'post' and _hooks.get(RhodeCodeUi.HOOK_PUSH):

    def __init__(self, repo_name, content_path, extras):

        self.extras = extras

        git_command = request.GET.get('service')

            from rhodecode.lib.compat import json

            gitenv['RHODECODE_EXTRAS'] = json.dumps(self.extras)

    def __init__(self, repo_root, repo_name, extras):

        self.extras = extras

            app = GitRepository(self.repo_name, content_path, self.extras)

def make_wsgi_app(repo_name, repo_root, extras):

    return GitDirectory(repo_root, repo_name, extras)

from rhodecode.lib.exceptions import HTTPLockedRC

from rhodecode.lib.hooks import pre_pull

        # extras are injected into UI object and later available

        # in hooks executed by rhodecode

            'make_lock': None,

            'locked_by': [None, None]

        # CHECK LOCKING only if it's not ANONYMOUS USER

        if username != User.DEFAULT_USER:

            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)

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

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

        except HTTPLockedRC, e:

            log.debug('Repositry LOCKED ret code 423!')

            return e(environ, start_response)

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

            extras=extras,

        if action == 'pull':

            # stupid git, emulate pre-pull hook !

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

from rhodecode.lib.exceptions import HTTPLockedRC

            'make_lock': None,

            'locked_by': [None, None]

        # CHECK LOCKING only if it's not ANONYMOUS USER

        if username != User.DEFAULT_USER:

            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)

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

        except HTTPLockedRC, e:

            log.debug('Repositry LOCKED ret code 423!')

            return e(environ, start_response)

import datetime

    now = datetime.datetime.now()

def time_to_datetime(tm):

    if tm:

        if isinstance(tm, basestring):

            try:

                tm = float(tm)

            except ValueError:

                return

        return datetime.datetime.fromtimestamp(tm)

import time