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