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 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(self, repo_name, repo_type, description, owner, private=False, clone_uri=None, repos_group=None, landing_rev='tip', just_db=False, fork_of=None, copy_fork_permissions=False, enable_statistics=False, enable_locking=False, enable_downloads=False): """ Create repository """ from rhodecode.model.scm import ScmModel owner = self._get_user(owner) fork_of = self._get_repo(fork_of) repos_group = self._get_repo_group(repos_group) try: # repo name is just a name of repository # while repo_name_full is a full qualified name that is combined # with name and path of group repo_name_full = repo_name repo_name = repo_name.split(self.URL_SEPARATOR)[-1] new_repo = Repository() new_repo.enable_statistics = False new_repo.repo_name = repo_name_full new_repo.repo_type = repo_type new_repo.user = owner new_repo.group = repos_group new_repo.description = description or repo_name new_repo.private = private new_repo.clone_uri = clone_uri new_repo.landing_rev = landing_rev new_repo.enable_statistics = enable_statistics new_repo.enable_locking = enable_locking new_repo.enable_downloads = enable_downloads if repos_group: new_repo.enable_locking = repos_group.enable_locking if fork_of: parent_repo = fork_of new_repo.fork = parent_repo self.sa.add(new_repo) if fork_of: if copy_fork_permissions: repo = fork_of user_perms = UserRepoToPerm.query()\ .filter(UserRepoToPerm.repository == repo).all() group_perms = UserGroupRepoToPerm.query()\ .filter(UserGroupRepoToPerm.repository == repo).all() for perm in user_perms: UserRepoToPerm.create(perm.user, new_repo, perm.permission) for perm in group_perms: UserGroupRepoToPerm.create(perm.users_group, new_repo, perm.permission) else: perm_obj = self._create_default_perms(new_repo, private) self.sa.add(perm_obj) else: perm_obj = self._create_default_perms(new_repo, private) self.sa.add(perm_obj) if not just_db: self.__create_repo(repo_name, repo_type, repos_group, clone_uri) log_create_repository(new_repo.get_dict(), created_by=owner.username) # now automatically start following this repository as owner ScmModel(self.sa).toggle_following_repo(new_repo.repo_id, owner.user_id) return new_repo except Exception: log.error(traceback.format_exc()) raise
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(self, form_data, cur_user, just_db=False, fork=False): from rhodecode.model.scm import ScmModel try: if fork: fork_parent_id = form_data['fork_parent_id'] # repo name is just a name of repository # while repo_name_full is a full qualified name that is combined # with name and path of group repo_name = form_data['repo_name'] repo_name_full = form_data['repo_name_full'] new_repo = Repository() new_repo.enable_statistics = False for k, v in form_data.items(): if k == 'repo_name': v = repo_name_full if k == 'repo_group': k = 'group_id' if k == 'description': v = v or repo_name setattr(new_repo, k, v) if fork: parent_repo = Repository.get(fork_parent_id) new_repo.fork = parent_repo new_repo.user_id = cur_user.user_id self.sa.add(new_repo) def _create_default_perms(): # create default permission repo_to_perm = UserRepoToPerm() default = 'repository.read' for p in User.get_by_username('default').user_perms: if p.permission.permission_name.startswith('repository.'): default = p.permission.permission_name break default_perm = 'repository.none' if form_data[ 'private'] else default repo_to_perm.permission_id = self.sa.query(Permission)\ .filter(Permission.permission_name == default_perm)\ .one().permission_id repo_to_perm.repository = new_repo repo_to_perm.user_id = User.get_by_username('default').user_id self.sa.add(repo_to_perm) if fork: if form_data.get('copy_permissions'): repo = Repository.get(fork_parent_id) user_perms = UserRepoToPerm.query()\ .filter(UserRepoToPerm.repository == repo).all() group_perms = UsersGroupRepoToPerm.query()\ .filter(UsersGroupRepoToPerm.repository == repo).all() for perm in user_perms: UserRepoToPerm.create(perm.user, new_repo, perm.permission) for perm in group_perms: UsersGroupRepoToPerm.create(perm.users_group, new_repo, perm.permission) else: _create_default_perms() else: _create_default_perms() if not just_db: self.__create_repo(repo_name, form_data['repo_type'], form_data['repo_group'], form_data['clone_uri']) log_create_repository(new_repo.get_dict(), created_by=cur_user.username) # now automatically start following this repository as owner ScmModel(self.sa).toggle_following_repo(new_repo.repo_id, cur_user.user_id) return new_repo except: log.error(traceback.format_exc()) raise
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(self, form_data, cur_user, just_db=False, fork=False): from rhodecode.model.scm import ScmModel try: if fork: fork_parent_id = form_data["fork_parent_id"] # repo name is just a name of repository # while repo_name_full is a full qualified name that is combined # with name and path of group repo_name = form_data["repo_name"] repo_name_full = form_data["repo_name_full"] new_repo = Repository() new_repo.enable_statistics = False for k, v in form_data.items(): if k == "repo_name": v = repo_name_full if k == "repo_group": k = "group_id" if k == "description": v = v or repo_name setattr(new_repo, k, v) if fork: parent_repo = Repository.get(fork_parent_id) new_repo.fork = parent_repo new_repo.user_id = cur_user.user_id self.sa.add(new_repo) def _create_default_perms(): # create default permission repo_to_perm = UserRepoToPerm() default = "repository.read" for p in User.get_by_username("default").user_perms: if p.permission.permission_name.startswith("repository."): default = p.permission.permission_name break default_perm = "repository.none" if form_data["private"] else default repo_to_perm.permission_id = ( self.sa.query(Permission).filter(Permission.permission_name == default_perm).one().permission_id ) repo_to_perm.repository = new_repo repo_to_perm.user_id = User.get_by_username("default").user_id self.sa.add(repo_to_perm) if fork: if form_data.get("copy_permissions"): repo = Repository.get(fork_parent_id) user_perms = UserRepoToPerm.query().filter(UserRepoToPerm.repository == repo).all() group_perms = UsersGroupRepoToPerm.query().filter(UsersGroupRepoToPerm.repository == repo).all() for perm in user_perms: UserRepoToPerm.create(perm.user, new_repo, perm.permission) for perm in group_perms: UsersGroupRepoToPerm.create(perm.users_group, new_repo, perm.permission) else: _create_default_perms() else: _create_default_perms() if not just_db: self.__create_repo(repo_name, form_data["repo_type"], form_data["repo_group"], form_data["clone_uri"]) log_create_repository(new_repo.get_dict(), created_by=cur_user.username) # now automatically start following this repository as owner ScmModel(self.sa).toggle_following_repo(new_repo.repo_id, cur_user.user_id) return new_repo except: log.error(traceback.format_exc()) raise
def create_repo(self, repo_name, repo_type, description, owner, private=False, clone_uri=None, repos_group=None, landing_rev='tip', just_db=False, fork_of=None, copy_fork_permissions=False): """ Create repository """ from rhodecode.model.scm import ScmModel owner = self._get_user(owner) fork_of = self._get_repo(fork_of) repos_group = self._get_repos_group(repos_group) try: # repo name is just a name of repository # while repo_name_full is a full qualified name that is combined # with name and path of group repo_name_full = repo_name repo_name = repo_name.split(self.URL_SEPARATOR)[-1] new_repo = Repository() new_repo.enable_statistics = False new_repo.repo_name = repo_name_full new_repo.repo_type = repo_type new_repo.user = owner new_repo.group = repos_group new_repo.description = description or repo_name new_repo.private = private new_repo.clone_uri = clone_uri new_repo.landing_rev = landing_rev if repos_group: new_repo.enable_locking = repos_group.enable_locking if fork_of: parent_repo = fork_of new_repo.fork = parent_repo self.sa.add(new_repo) def _create_default_perms(): # create default permission repo_to_perm = UserRepoToPerm() default = 'repository.read' for p in User.get_by_username('default').user_perms: if p.permission.permission_name.startswith('repository.'): default = p.permission.permission_name break default_perm = 'repository.none' if private else default repo_to_perm.permission_id = self.sa.query(Permission)\ .filter(Permission.permission_name == default_perm)\ .one().permission_id repo_to_perm.repository = new_repo repo_to_perm.user_id = User.get_by_username('default').user_id self.sa.add(repo_to_perm) if fork_of: if copy_fork_permissions: repo = fork_of user_perms = UserRepoToPerm.query()\ .filter(UserRepoToPerm.repository == repo).all() group_perms = UsersGroupRepoToPerm.query()\ .filter(UsersGroupRepoToPerm.repository == repo).all() for perm in user_perms: UserRepoToPerm.create(perm.user, new_repo, perm.permission) for perm in group_perms: UsersGroupRepoToPerm.create(perm.users_group, new_repo, perm.permission) else: _create_default_perms() else: _create_default_perms() if not just_db: self.__create_repo(repo_name, repo_type, repos_group, clone_uri) log_create_repository(new_repo.get_dict(), created_by=owner.username) # now automatically start following this repository as owner ScmModel(self.sa).toggle_following_repo(new_repo.repo_id, owner.user_id) return new_repo except: log.error(traceback.format_exc()) raise