def pre_push(extras):
"""
Hook executed before pushing code.
It bans pushing when the repository is locked.
"""
usr = User.get_by_username(extras.username)
output = ''
if extras.locked_by[0] and usr.user_id != int(extras.locked_by[0]):
locked_by = User.get(extras.locked_by[0]).username
reason = extras.locked_by[2]
# this exception is interpreted in git/hg middlewares and based
# on that proper return code is server to client
_http_ret = HTTPLockedRC(
_locked_by_explanation(extras.repository, locked_by, reason))
if str(_http_ret.code).startswith('2'):
# 2xx Codes don't raise exceptions
output = _http_ret.title
else:
raise _http_ret
# Calling hooks after checking the lock, for consistent behavior
pre_push_extension(repo_store_path=Repository.base_path(), **extras)
return HookResponse(0, output)
def create_repo_fork(form_data, cur_user):
"""
Creates a fork of repository using interval VCS methods
:param form_data:
:param cur_user:
"""
from rhodecode.model.repo import RepoModel
log = get_logger(create_repo_fork)
DBS = get_session()
base_path = Repository.base_path()
fork_repo = RepoModel(DBS).create(form_data, cur_user,
just_db=True, fork=True)
alias = form_data['repo_type']
org_repo_name = form_data['org_path']
fork_name = form_data['repo_name_full']
update_after_clone = form_data['update_after_clone']
source_repo_path = os.path.join(base_path, org_repo_name)
destination_fork_path = os.path.join(base_path, fork_name)
log.info('creating fork of %s as %s', source_repo_path,
destination_fork_path)
backend = get_backend(alias)
backend(safe_str(destination_fork_path), create=True,
src_url=safe_str(source_repo_path),
update_after_clone=update_after_clone)
log_create_repository(fork_repo.get_dict(), created_by=cur_user.username)
action_logger(cur_user, 'user_forked_repo:%s' % fork_name,
org_repo_name, '', DBS)
action_logger(cur_user, 'user_created_fork:%s' % fork_name,
fork_name, '', DBS)
# finally commit at latest possible stage
DBS.commit()
def post_push(extras):
"""Hook executed after user pushes to the repository."""
action_tmpl = extras.action + ':%s'
commit_ids = extras.commit_ids[:29000]
action = action_tmpl % ','.join(commit_ids)
action_logger(extras.username,
action,
extras.repository,
extras.ip,
commit=True)
# extension hook call
post_push_extension(repo_store_path=Repository.base_path(),
pushed_revs=commit_ids,
**extras)
output = ''
# make lock is a tri state False, True, None. We only release lock on False
if extras.make_lock is False:
Repository.unlock(Repository.get_by_repo_name(extras.repository))
msg = 'Released lock on repo `%s`\n' % extras.repository
output += msg
if extras.locked_by[0]:
locked_by = User.get(extras.locked_by[0]).username
reason = extras.locked_by[2]
_http_ret = HTTPLockedRC(
_locked_by_explanation(extras.repository, locked_by, reason))
# TODO: johbo: if not?
if str(_http_ret.code).startswith('2'):
# 2xx Codes don't raise exceptions
output += _http_ret.title
output += 'RhodeCode: push completed\n'
return HookResponse(0, output)
def create_repo_fork(form_data, cur_user):
"""
Creates a fork of repository using interval VCS methods
:param form_data:
:param cur_user:
"""
from rhodecode.model.repo import RepoModel
from rhodecode.model.user import UserModel
log = get_logger(create_repo_fork)
DBS = get_session()
base_path = Repository.base_path()
cur_user = UserModel(DBS)._get_user(cur_user)
fork_name = form_data['repo_name_full']
repo_type = form_data['repo_type']
description = form_data['description']
owner = cur_user
private = form_data['private']
clone_uri = form_data.get('clone_uri')
repos_group = form_data['repo_group']
landing_rev = form_data['landing_rev']
copy_fork_permissions = form_data.get('copy_permissions')
fork_of = RepoModel(DBS)._get_repo(form_data.get('fork_parent_id'))
fork_repo = RepoModel(DBS).create_repo(
fork_name,
repo_type,
description,
owner,
private,
clone_uri,
repos_group,
landing_rev,
just_db=True,
fork_of=fork_of,
copy_fork_permissions=copy_fork_permissions)
update_after_clone = form_data['update_after_clone']
source_repo_path = os.path.join(base_path, fork_of.repo_name)
destination_fork_path = os.path.join(base_path, fork_name)
log.info('creating fork of %s as %s', source_repo_path,
destination_fork_path)
backend = get_backend(repo_type)
if repo_type == 'git':
r = backend(safe_str(destination_fork_path),
create=True,
src_url=safe_str(source_repo_path),
update_after_clone=update_after_clone,
bare=True)
# add rhodecode hook into this repo
ScmModel().install_git_hook(repo=r)
elif repo_type == 'hg':
r = backend(safe_str(destination_fork_path),
create=True,
src_url=safe_str(source_repo_path),
update_after_clone=update_after_clone)
else:
raise Exception('Unknown backend type %s' % repo_type)
log_create_repository(fork_repo.get_dict(), created_by=cur_user.username)
action_logger(cur_user, 'user_forked_repo:%s' % fork_name,
fork_of.repo_name, '', DBS)
action_logger(cur_user, 'user_created_fork:%s' % fork_name, fork_name, '',
DBS)
# finally commit at latest possible stage
DBS.commit()
fork_repo.update_changeset_cache()
def create_repo_fork(form_data, cur_user):
"""
Creates a fork of repository using internal VCS methods
:param form_data:
:param cur_user:
"""
from rhodecode.model.repo import RepoModel
from rhodecode.model.user import UserModel
log = get_logger(create_repo_fork)
DBS = get_session()
cur_user = UserModel(DBS)._get_user(cur_user)
owner = cur_user
repo_name = form_data['repo_name'] # fork in this case
repo_name_full = form_data['repo_name_full']
repo_type = form_data['repo_type']
description = form_data['description']
private = form_data['private']
clone_uri = form_data.get('clone_uri')
repo_group = safe_int(form_data['repo_group'])
landing_rev = form_data['landing_rev']
copy_fork_permissions = form_data.get('copy_permissions')
fork_id = safe_int(form_data.get('fork_parent_id'))
try:
fork_of = RepoModel(DBS)._get_repo(fork_id)
RepoModel(DBS)._create_repo(
repo_name=repo_name_full,
repo_type=repo_type,
description=description,
owner=owner,
private=private,
clone_uri=clone_uri,
repo_group=repo_group,
landing_rev=landing_rev,
fork_of=fork_of,
copy_fork_permissions=copy_fork_permissions)
action_logger(cur_user, 'user_forked_repo:%s' % repo_name_full,
fork_of.repo_name, '', DBS)
DBS.commit()
base_path = Repository.base_path()
source_repo_path = os.path.join(base_path, fork_of.repo_name)
# now create this repo on Filesystem
RepoModel(DBS)._create_filesystem_repo(
repo_name=repo_name,
repo_type=repo_type,
repo_group=RepoModel(DBS)._get_repo_group(repo_group),
clone_uri=source_repo_path,
)
repo = Repository.get_by_repo_name(repo_name_full)
log_create_repository(created_by=owner.username, **repo.get_dict())
# update repo commit caches initially
config = repo._config
config.set('extensions', 'largefiles', '')
repo.update_commit_cache(config=config)
# set new created state
repo.set_state(Repository.STATE_CREATED)
DBS.commit()
except Exception as e:
log.warning(
'Exception %s occurred when forking repository, '
'doing cleanup...', e)
# rollback things manually !
repo = Repository.get_by_repo_name(repo_name_full)
if repo:
Repository.delete(repo.repo_id)
DBS.commit()
RepoModel(DBS)._delete_filesystem_repo(repo)
raise
# it's an odd fix to make celery fail task when exception occurs
def on_failure(self, *args, **kwargs):
pass
return True
def create_repo_fork(form_data, cur_user):
"""
Creates a fork of repository using interval VCS methods
:param form_data:
:param cur_user:
"""
from rhodecode.model.repo import RepoModel
from rhodecode.model.user import UserModel
log = get_logger(create_repo_fork)
DBS = get_session()
base_path = Repository.base_path()
cur_user = UserModel(DBS)._get_user(cur_user)
fork_name = form_data['repo_name_full']
repo_type = form_data['repo_type']
description = form_data['description']
owner = cur_user
private = form_data['private']
clone_uri = form_data.get('clone_uri')
repos_group = form_data['repo_group']
landing_rev = form_data['landing_rev']
copy_fork_permissions = form_data.get('copy_permissions')
fork_of = RepoModel(DBS)._get_repo(form_data.get('fork_parent_id'))
fork_repo = RepoModel(DBS).create_repo(
fork_name, repo_type, description, owner, private, clone_uri,
repos_group, landing_rev, just_db=True, fork_of=fork_of,
copy_fork_permissions=copy_fork_permissions
)
update_after_clone = form_data['update_after_clone']
source_repo_path = os.path.join(base_path, fork_of.repo_name)
destination_fork_path = os.path.join(base_path, fork_name)
log.info('creating fork of %s as %s', source_repo_path,
destination_fork_path)
backend = get_backend(repo_type)
if repo_type == 'git':
backend(safe_str(destination_fork_path), create=True,
src_url=safe_str(source_repo_path),
update_after_clone=update_after_clone,
bare=True)
elif repo_type == 'hg':
backend(safe_str(destination_fork_path), create=True,
src_url=safe_str(source_repo_path),
update_after_clone=update_after_clone)
else:
raise Exception('Unknown backend type %s' % repo_type)
log_create_repository(fork_repo.get_dict(), created_by=cur_user.username)
action_logger(cur_user, 'user_forked_repo:%s' % fork_name,
fork_of.repo_name, '', DBS)
action_logger(cur_user, 'user_created_fork:%s' % fork_name,
fork_name, '', DBS)
# finally commit at latest possible stage
DBS.commit()
def create_repo_fork(form_data, cur_user):
"""
Creates a fork of repository using interval VCS methods
:param form_data:
:param cur_user:
"""
from rhodecode.model.repo import RepoModel
from rhodecode.model.user import UserModel
log = get_logger(create_repo_fork)
DBS = get_session()
base_path = Repository.base_path()
cur_user = UserModel(DBS)._get_user(cur_user)
fork_name = form_data["repo_name_full"]
repo_type = form_data["repo_type"]
description = form_data["description"]
owner = cur_user
private = form_data["private"]
clone_uri = form_data.get("clone_uri")
repos_group = form_data["repo_group"]
landing_rev = form_data["landing_rev"]
copy_fork_permissions = form_data.get("copy_permissions")
fork_of = RepoModel(DBS)._get_repo(form_data.get("fork_parent_id"))
fork_repo = RepoModel(DBS).create_repo(
fork_name,
repo_type,
description,
owner,
private,
clone_uri,
repos_group,
landing_rev,
just_db=True,
fork_of=fork_of,
copy_fork_permissions=copy_fork_permissions,
)
update_after_clone = form_data["update_after_clone"]
source_repo_path = os.path.join(base_path, fork_of.repo_name)
destination_fork_path = os.path.join(base_path, fork_name)
log.info("creating fork of %s as %s", source_repo_path, destination_fork_path)
backend = get_backend(repo_type)
if repo_type == "git":
r = backend(
safe_str(destination_fork_path),
create=True,
src_url=safe_str(source_repo_path),
update_after_clone=update_after_clone,
bare=True,
)
# add rhodecode hook into this repo
ScmModel().install_git_hook(repo=r)
elif repo_type == "hg":
r = backend(
safe_str(destination_fork_path),
create=True,
src_url=safe_str(source_repo_path),
update_after_clone=update_after_clone,
)
else:
raise Exception("Unknown backend type %s" % repo_type)
log_create_repository(fork_repo.get_dict(), created_by=cur_user.username)
action_logger(cur_user, "user_forked_repo:%s" % fork_name, fork_of.repo_name, "", DBS)
action_logger(cur_user, "user_created_fork:%s" % fork_name, fork_name, "", DBS)
# finally commit at latest possible stage
DBS.commit()
fork_repo.update_changeset_cache()
