def update_from_names(cls, user, copr, names): UsersLogic.raise_if_cant_update_copr( user, copr, "Only owners and admins may update their projects.") current_chroots = copr.mock_chroots new_chroots = cls.mock_chroots_from_names(names) # add non-existing run_createrepo = False for mock_chroot in new_chroots: if mock_chroot not in current_chroots: db.session.add( models.CoprChroot(copr=copr, mock_chroot=mock_chroot)) run_createrepo = True if run_createrepo: ActionsLogic.send_createrepo(copr) # delete no more present to_remove = [] for mock_chroot in current_chroots: if mock_chroot in new_chroots: continue if not mock_chroot.is_active: continue # can't delete here, it would change current_chroots and break # iteration to_remove.append(mock_chroot) for mc in to_remove: copr.mock_chroots.remove(mc)
def test_delete_build_basic(self, f_users, f_coprs, f_mock_chroots, f_builds, f_db): self.b1.pkgs = "http://example.com/copr-keygen-1.58-1.fc20.src.rpm" expected_dir = self.b1.result_dir_name self.db.session.add(self.b1) self.db.session.commit() expected_chroots_to_delete = set() for bchroot in self.b1_bc: expected_chroots_to_delete.add(bchroot.name) assert len(ActionsLogic.get_many().all()) == 0 BuildsLogic.delete_build(self.u1, self.b1) self.db.session.commit() assert len(ActionsLogic.get_many().all()) == 1 action = ActionsLogic.get_many().one() delete_data = json.loads(action.data) assert "chroots" in delete_data assert delete_data["result_dir_name"] == expected_dir assert expected_chroots_to_delete == set(delete_data["chroots"]) with pytest.raises(NoResultFound): BuildsLogic.get(self.b1.id).one()
def test_delete_build_as_admin(self, f_users, f_coprs, f_mock_chroots, f_builds, f_db): self.b4.pkgs = "http://example.com/copr-keygen-1.58-1.fc20.src.rpm" expected_dir = self.b4.result_dir for bc in self.b4_bc: bc.status = StatusEnum("succeeded") bc.ended_on = time.time() self.u1.admin = True self.db.session.add_all(self.b4_bc) self.db.session.add(self.b4) self.db.session.add(self.u1) self.db.session.commit() expected_chroots_to_delete = set() for bchroot in self.b4_bc: expected_chroots_to_delete.add(bchroot.name) assert len(ActionsLogic.get_many().all()) == 0 BuildsLogic.delete_build(self.u1, self.b4) self.db.session.commit() assert len(ActionsLogic.get_many().all()) == 1 action = ActionsLogic.get_many().one() with pytest.raises(NoResultFound): BuildsLogic.get(self.b4.id).one()
def add(cls, user, name, selected_chroots, repos=None, description=None, instructions=None, check_for_duplicates=False, group=None, **kwargs): copr = models.Copr(name=name, repos=repos or u"", owner_id=user.id, description=description or u"", instructions=instructions or u"", created_on=int(time.time()), **kwargs) if group is not None: UsersLogic.raise_if_not_in_group(user, group) copr.group = group # form validation checks for duplicates CoprsLogic.new(user, copr, check_for_duplicates=check_for_duplicates) CoprChrootsLogic.new_from_names(copr, selected_chroots) db.session.flush() ActionsLogic.send_create_gpg_key(copr) return copr
def test_delete_build_basic(self, f_users, f_coprs, f_mock_chroots, f_builds, f_db): self.b1.pkgs = "http://example.com/copr-keygen-1.58-1.fc20.src.rpm" expected_dir = self.b1.result_dir self.db.session.add(self.b1) self.db.session.commit() expected_chroots_to_delete = set() for bchroot in self.b1_bc: expected_chroots_to_delete.add(bchroot.name) assert len(ActionsLogic.get_many().all()) == 0 BuildsLogic.delete_build(self.u1, self.b1) self.db.session.commit() assert len(ActionsLogic.get_many().all()) == 1 action = ActionsLogic.get_many().one() delete_data = json.loads(action.data) assert delete_data['chroot_builddirs'] == { 'srpm-builds': ['bar'], 'fedora-18-x86_64': ['bar'] } with pytest.raises(NoResultFound): BuildsLogic.get(self.b1.id).one()
def test_delete_build_as_admin( self, f_users, f_coprs, f_mock_chroots, f_builds, f_db): self.b4.pkgs = "http://example.com/copr-keygen-1.58-1.fc20.src.rpm" expected_dir = self.b4.result_dir_name for bc in self.b4_bc: bc.status = StatusEnum("succeeded") bc.ended_on = time.time() self.u1.admin = True self.db.session.add_all(self.b4_bc) self.db.session.add(self.b4) self.db.session.add(self.u1) self.db.session.commit() expected_chroots_to_delete = set() for bchroot in self.b4_bc: expected_chroots_to_delete.add(bchroot.name) assert len(ActionsLogic.get_many().all()) == 0 BuildsLogic.delete_build(self.u1, self.b4) self.db.session.commit() assert len(ActionsLogic.get_many().all()) == 1 action = ActionsLogic.get_many().one() delete_data = json.loads(action.data) assert "chroots" in delete_data assert delete_data["result_dir_name"] == expected_dir assert expected_chroots_to_delete == set(delete_data["chroots"]) with pytest.raises(NoResultFound): BuildsLogic.get(self.b4.id).one()
def test_delete_build_basic( self, f_users, f_coprs, f_mock_chroots, f_builds, f_db): self.b1.pkgs = "http://example.com/copr-keygen-1.58-1.fc20.src.rpm" expected_dir = self.b1.result_dir_name self.db.session.add(self.b1) self.db.session.commit() expected_chroots_to_delete = set() for bchroot in self.b1_bc: expected_chroots_to_delete.add(bchroot.name) assert len(ActionsLogic.get_many().all()) == 0 BuildsLogic.delete_build(self.u1, self.b1) self.db.session.commit() assert len(ActionsLogic.get_many().all()) == 1 action = ActionsLogic.get_many().one() delete_data = json.loads(action.data) assert "chroots" in delete_data assert delete_data["result_dir_name"] == expected_dir assert expected_chroots_to_delete == set(delete_data["chroots"]) with pytest.raises(NoResultFound): BuildsLogic.get(self.b1.id).one()
def _update_chroot(cls, buildroot_pkgs, repos, comps, comps_name, copr_chroot, with_opts, without_opts, delete_after, delete_notify): if buildroot_pkgs is not None: copr_chroot.buildroot_pkgs = buildroot_pkgs if repos is not None: copr_chroot.repos = repos.replace("\n", " ") if with_opts is not None: copr_chroot.with_opts = with_opts if without_opts is not None: copr_chroot.without_opts = without_opts if comps_name is not None: copr_chroot.update_comps(comps) copr_chroot.comps_name = comps_name ActionsLogic.send_update_comps(copr_chroot) if delete_after is not None: copr_chroot.delete_after = delete_after if delete_notify is not None: copr_chroot.delete_notify = delete_notify db.session.add(copr_chroot)
def fork_copr(cls, copr, user, dstname, dstgroup=None): forking = ProjectForking(user, dstgroup) created = (not bool(forking.get(copr, dstname))) fcopr = forking.fork_copr(copr, dstname) if fcopr.full_name == copr.full_name: raise exceptions.DuplicateException( "Source project should not be same as destination") builds_map = {} for package in copr.main_dir.packages: fpackage = forking.fork_package(package, fcopr) build = package.last_build(successful=True) if not build: continue fbuild = forking.fork_build(build, fcopr, fpackage) if build.result_dir: builds_map['srpm-builds'] = (build.result_dir, fbuild.result_dir) for chroot, fchroot in zip(build.build_chroots, fbuild.build_chroots): if chroot.result_dir: builds_map[chroot.name] = (chroot.result_dir, fchroot.result_dir) db.session.commit() ActionsLogic.send_fork_copr(copr, fcopr, builds_map) return fcopr, created
def test_project_delete_fail_unfinished_project_action( self, f_users, f_mock_chroots, f_coprs, f_users_api, f_db): ActionsLogic.send_delete_copr(self.c1) self.db.session.commit() href = "/api_2/projects/{}".format(self.c1.id) r0 = self.request_rest_api_with_auth(href, method="delete") assert r0.status_code == 400
def test_re_enable_auto_createrepo_produce_action(self, f_users, f_coprs, f_mock_chroots, f_db): self.db.session.add_all( [self.u1, self.c1, self.mc1, self.mc2, self.mc3]) username = self.u1.name coprname = self.c1.name copr_id = self.c1.id chroot = self.mc1.name # 1.ensure ACR enabled self.db.session.commit() c1_actual = CoprsLogic.get(self.u1.name, self.c1.name).one() assert c1_actual.auto_createrepo # 1. disabling ACR self.test_client.post("/coprs/{0}/{1}/update/".format( username, coprname), data={ "name": coprname, chroot: "y", "id": copr_id, "disable_createrepo": True }, follow_redirects=True) self.db.session.commit() # check current status c1_actual = CoprsLogic.get(username, coprname).one() assert not c1_actual.auto_createrepo # no actions issued before assert len(ActionsLogic.get_many().all()) == 0 # 2. enabling ACR self.test_client.post("/coprs/{0}/{1}/update/".format( username, coprname), data={ "name": coprname, chroot: "y", "id": copr_id, "disable_createrepo": "false" }, follow_redirects=True) self.db.session.commit() c1_actual = CoprsLogic.get(username, coprname).one() # ACR enabled assert c1_actual.auto_createrepo # added action assert len(ActionsLogic.get_many().all()) > 0 action = ActionsLogic.get_many( action_type=ActionTypeEnum("createrepo")).one() data_dict = json.loads(action.data) assert data_dict["username"] == username assert data_dict["projectname"] == coprname
def remove_comps(cls, user, copr_chroot): UsersLogic.raise_if_cant_update_copr( user, copr_chroot.copr, "Only owners and admins may update their projects.") copr_chroot.comps_name = None copr_chroot.comps_zlib = None ActionsLogic.send_update_comps(copr_chroot) db.session.add(copr_chroot)
def on_auto_createrepo_change(target_copr, value_acr, old_value_acr, initiator): """ Emit createrepo action when auto_createrepo re-enabled""" if old_value_acr == NEVER_SET: # created new copr, not interesting return if not old_value_acr and value_acr: # re-enabled ActionsLogic.send_createrepo(target_copr)
def test_delete_build_no_chroots_to_clean( self, f_users, f_coprs, f_mock_chroots, f_builds, f_db): for bchroot in self.b1_bc: bchroot.status = helpers.StatusEnum("skipped") self.db.session.commit() assert len(ActionsLogic.get_many().all()) == 0 BuildsLogic.delete_build(self.u1, self.b1) self.db.session.commit() assert len(ActionsLogic.get_many().all()) == 0
def delete_build(cls, user, build, send_delete_action=True): """ :type user: models.User :type build: models.Build """ cls.check_build_to_delete(user, build) if send_delete_action: ActionsLogic.send_delete_build(build) db.session.delete(build)
def test_delete_build_no_chroots_to_clean(self, f_users, f_coprs, f_mock_chroots, f_builds, f_db): for bchroot in self.b1_bc: bchroot.status = helpers.StatusEnum("skipped") self.db.session.commit() assert len(ActionsLogic.get_many().all()) == 0 BuildsLogic.delete_build(self.u1, self.b1) self.db.session.commit() assert len(ActionsLogic.get_many().all()) == 0
def fork_copr(cls, copr, user, dstname, dstgroup=None): if dstgroup and not user.can_build_in_group(dstgroup): raise exceptions.InsufficientRightsException( "Only members may create projects in the particular groups.") fcopr = CoprsLogic.get_by_group_id(dstgroup.id, dstname).first() if dstgroup \ else CoprsLogic.filter_without_group_projects(CoprsLogic.get(flask.g.user.name, dstname)).first() if fcopr: raise exceptions.DuplicateException("You already have {}/{} project".format(user.name, copr.name)) # @TODO Move outside and properly test it def create_object(clazz, from_object, exclude=list()): arguments = {} for name, column in from_object.__mapper__.columns.items(): if not name in exclude: arguments[name] = getattr(from_object, name) return clazz(**arguments) fcopr = create_object(models.Copr, copr, exclude=["id", "group_id"]) fcopr.forked_from_id = copr.id fcopr.owner = user fcopr.owner_id = user.id if dstname: fcopr.name = dstname if dstgroup: fcopr.group = dstgroup fcopr.group_id = dstgroup.id for chroot in list(copr.copr_chroots): CoprChrootsLogic.create_chroot(user, fcopr, chroot.mock_chroot, chroot.buildroot_pkgs, comps=chroot.comps, comps_name=chroot.comps_name) builds_map = {} for package in copr.packages: fpackage = create_object(models.Package, package, exclude=["id", "copr_id"]) fpackage.copr = fcopr db.session.add(fpackage) build = package.last_build() if not build: continue fbuild = create_object(models.Build, build, exclude=["id", "copr_id", "package_id"]) fbuild.copr = fcopr fbuild.package = fpackage fbuild.build_chroots = [create_object(models.BuildChroot, c, exclude=["id"]) for c in build.build_chroots] db.session.add(fbuild) builds_map[fbuild.id] = build.id ActionsLogic.send_fork_copr(copr, fcopr, builds_map) db.session.add(fcopr) return fcopr
def on_auto_createrepo_change(target_copr, value_acr, old_value_acr, initiator): """ Emit createrepo action when auto_createrepo re-enabled""" if old_value_acr == NEVER_SET: # created new copr, not interesting return if not old_value_acr and value_acr: # re-enabled ActionsLogic.send_createrepo( target_copr.user.name, target_copr.name, chroots=[chroot.name for chroot in target_copr.active_chroots] )
def test_re_enable_auto_createrepo_produce_action( self, f_users, f_coprs, f_mock_chroots, f_db): self.db.session.add_all( [self.u1, self.c1, self.mc1, self.mc2, self.mc3]) username = self.u1.name coprname = self.c1.name copr_id = self.c1.id chroot = self.mc1.name # 1.ensure ACR enabled self.db.session.commit() c1_actual = CoprsLogic.get(self.u1.name, self.c1.name).one() assert c1_actual.auto_createrepo # 1. disabling ACR self.test_client.post( "/coprs/{0}/{1}/update/".format(username, coprname), data={"name": coprname, chroot: "y", "id": copr_id, "disable_createrepo": True}, follow_redirects=True ) self.db.session.commit() # check current status c1_actual = CoprsLogic.get(username, coprname).one() assert not c1_actual.auto_createrepo # no actions issued before assert len(ActionsLogic.get_many().all()) == 0 # 2. enabling ACR self.test_client.post( "/coprs/{0}/{1}/update/".format(username, coprname), data={"name": coprname, chroot: "y", "id": copr_id, "disable_createrepo": "false"}, follow_redirects=True ) self.db.session.commit() c1_actual = CoprsLogic.get(username, coprname).one() # ACR enabled assert c1_actual.auto_createrepo # added action assert len(ActionsLogic.get_many().all()) > 0 action = ActionsLogic.get_many(action_type=ActionTypeEnum("createrepo")).one() data_dict = json.loads(action.data) assert data_dict["username"] == username assert data_dict["projectname"] == coprname
def _update_chroot(cls, buildroot_pkgs, comps, comps_name, module_md, module_md_name, copr_chroot): copr_chroot.buildroot_pkgs = buildroot_pkgs if comps_name is not None: copr_chroot.update_comps(comps) copr_chroot.comps_name = comps_name ActionsLogic.send_update_comps(copr_chroot) if module_md_name is not None: copr_chroot.update_module_md(module_md) copr_chroot.module_md_name = module_md_name ActionsLogic.send_update_module_md(copr_chroot)
def add(cls, user, name, selected_chroots, repos=None, description=None, instructions=None, check_for_duplicates=False, group=None, persistent=False, auto_prune=True, use_bootstrap_container=False, follow_fedora_branching=False, **kwargs): if not user.admin and persistent: raise exceptions.NonAdminCannotCreatePersistentProject() if not user.admin and not auto_prune: raise exceptions.NonAdminCannotDisableAutoPrunning() # form validation checks for duplicates cls.new(user, name, group, check_for_duplicates=check_for_duplicates) copr = models.Copr(name=name, repos=repos or u"", user=user, description=description or u"", instructions=instructions or u"", created_on=int(time.time()), persistent=persistent, auto_prune=auto_prune, use_bootstrap_container=use_bootstrap_container, follow_fedora_branching=follow_fedora_branching, **kwargs) if group is not None: UsersLogic.raise_if_not_in_group(user, group) copr.group = group copr_dir = models.CoprDir(main=True, name=name, copr=copr) db.session.add(copr_dir) db.session.add(copr) CoprChrootsLogic.new_from_names(copr, selected_chroots) db.session.flush() ActionsLogic.send_create_gpg_key(copr) return copr
def copr_build_module(copr): form = forms.ModuleFormUploadFactory(csrf_enabled=False) if not form.validate_on_submit(): # @TODO Prettier error raise LegacyApiError(form.errors) modulemd = form.modulemd.data.read() ActionsLogic.send_build_module(copr, modulemd) db.session.commit() return flask.jsonify({ "output": "ok", "message": "Module build was submitted", "modulemd": modulemd, })
def delete_unsafe(cls, user, copr): """ Deletes copr without termination of ongoing builds. """ cls.raise_if_cant_delete(user, copr) # TODO: do we want to dump the information somewhere, so that we can # search it in future? cls.raise_if_unfinished_blocking_action( copr, "Can't delete this project," " another operation is in progress: {action}") ActionsLogic.send_delete_copr(copr) CoprDirsLogic.delete_all_by_copr(copr) copr.deleted = True return copr
def delete_multiple_builds(cls, user, builds): """ :type user: models.User :type builds: list of models.Build """ to_delete = [] for build in builds: cls.check_build_to_delete(user, build) to_delete.append(build) if to_delete: ActionsLogic.send_delete_multiple_builds(to_delete) for build in to_delete: for build_chroot in build.build_chroots: db.session.delete(build_chroot) db.session.delete(build)
def test_fork_copr_sends_actions(self, mc_flask_g, f_users, f_coprs, f_mock_chroots, f_builds, f_db): mc_flask_g.user.name = self.u2.name fc1, created = ComplexLogic.fork_copr(self.c1, self.u2, u"dstname") self.db.session.commit() actions = ActionsLogic.get_many(ActionTypeEnum("gen_gpg_key")).all() assert len(actions) == 1 data = json.loads(actions[0].data) assert data["username"] == self.u2.name assert data["projectname"] == "dstname" actions = ActionsLogic.get_many(ActionTypeEnum("fork")).all() assert len(actions) == 1 data = json.loads(actions[0].data) assert data["user"] == self.u2.name assert data["copr"] == "dstname" last_build, forked_build = self.c1.packages[0].builds[1], fc1.builds[0] assert data["builds_map"] == {str(forked_build.id): str(last_build.result_dir_name)}
def fork_copr(cls, copr, user, dstname, dstgroup=None): forking = ProjectForking(user, dstgroup) fcopr = forking.fork_copr(copr, dstname) created = fcopr in db.session.new if fcopr.full_name == copr.full_name: raise exceptions.DuplicateException("Source project should not be same as destination") builds_map = {} for package in copr.packages: fpackage = forking.fork_package(package, fcopr) build = package.last_build() if not build: continue fbuild = forking.fork_build(build, fcopr, fpackage) builds_map[fbuild.id] = build.result_dir_name ActionsLogic.send_fork_copr(copr, fcopr, builds_map) return fcopr, created
def fork_copr(cls, copr, user, dstname, dstgroup=None): forking = ProjectForking(user, dstgroup) created = (not bool(forking.get(copr, dstname))) fcopr = forking.fork_copr(copr, dstname) if fcopr.full_name == copr.full_name: raise exceptions.DuplicateException("Source project should not be same as destination") builds_map = {} for package in copr.packages: fpackage = forking.fork_package(package, fcopr) build = package.last_build() if not build: continue fbuild = forking.fork_build(build, fcopr, fpackage) builds_map[fbuild.id] = build.result_dir_name ActionsLogic.send_fork_copr(copr, fcopr, builds_map) return fcopr, created
def test_build_post_json_on_project_during_action(self, f_users, f_coprs, f_db, f_mock_chroots, f_mock_chroots_many, f_build_many_chroots, f_users_api): ActionsLogic.send_delete_copr(self.c1) chroot_name_list = [c.name for c in self.c1.active_chroots] metadata = { "project_id": 1, "srpm_url": "http://example.com/mypkg.src.rpm", "chroots": chroot_name_list } self.db.session.commit() r0 = self.request_rest_api_with_auth( "/api_2/builds", method="post", content=metadata, ) assert r0.status_code == 400
def test_delete_build_basic( self, f_users, f_coprs, f_mock_chroots, f_builds, f_db): self.db.session.commit() expected_chroots_to_delete = set() for bchroot in self.b1_bc: expected_chroots_to_delete.add(bchroot.name) assert len(ActionsLogic.get_many().all()) == 0 BuildsLogic.delete_build(self.u1, self.b1) self.db.session.commit() assert len(ActionsLogic.get_many().all()) == 1 action = ActionsLogic.get_many().one() delete_data = json.loads(action.data) assert "chroots" in delete_data assert expected_chroots_to_delete == set(delete_data["chroots"]) with pytest.raises(NoResultFound): BuildsLogic.get(self.b1.id).one()
def test_delete_build_basic(self, f_users, f_coprs, f_mock_chroots, f_builds, f_db): self.db.session.commit() expected_chroots_to_delete = set() for bchroot in self.b1_bc: expected_chroots_to_delete.add(bchroot.name) assert len(ActionsLogic.get_many().all()) == 0 BuildsLogic.delete_build(self.u1, self.b1) self.db.session.commit() assert len(ActionsLogic.get_many().all()) == 1 action = ActionsLogic.get_many().one() delete_data = json.loads(action.data) assert "chroots" in delete_data assert expected_chroots_to_delete == set(delete_data["chroots"]) with pytest.raises(NoResultFound): BuildsLogic.get(self.b1.id).one()
def delete_build(cls, user, build, send_delete_action=True): """ :type user: models.User :type build: models.Build """ if not user.can_edit(build.copr) or build.persistent: raise InsufficientRightsException( "You are not allowed to delete build `{}`.".format(build.id)) if not build.finished: raise ActionInProgressException( "You can not delete build `{}` which is not finished.".format(build.id), "Unfinished build") if send_delete_action: ActionsLogic.send_delete_build(build) for build_chroot in build.build_chroots: db.session.delete(build_chroot) db.session.delete(build)
def test_copr_logic_add_sends_create_gpg_key_action(self, f_users, f_mock_chroots, f_db): name = u"project_1" selected_chroots = [self.mc1.name] CoprsLogic.add(self.u1, name, selected_chroots) self.db.session.commit() actions = ActionsLogic.get_many(ActionTypeEnum("gen_gpg_key")).all() assert len(actions) == 1 data = json.loads(actions[0].data) assert data["username"] == self.u1.name assert data["projectname"] == name
def delete_build(cls, user, build, send_delete_action=True): """ :type user: models.User :type build: models.Build """ if not user.can_edit(build.copr): raise exceptions.InsufficientRightsException( "You are not allowed to delete build `{}`.".format(build.id)) if not build.deletable: # from celery.contrib import rdb; rdb.set_trace() raise exceptions.ActionInProgressException( "You can not delete build `{}` which is not finished.".format(build.id), "Unfinished build") if send_delete_action and build.state not in ["canceled"]: # cancelled builds should have nothing in backend to delete ActionsLogic.send_delete_build(build) for build_chroot in build.build_chroots: db.session.delete(build_chroot) db.session.delete(build)
def delete_build(cls, user, build, send_delete_action=True): """ :type user: models.User :type build: models.Build """ if not user.can_edit(build.copr) or build.persistent: raise exceptions.InsufficientRightsException( "You are not allowed to delete build `{}`.".format(build.id)) if not build.finished: # from celery.contrib import rdb; rdb.set_trace() raise exceptions.ActionInProgressException( "You can not delete build `{}` which is not finished.".format(build.id), "Unfinished build") if send_delete_action and build.state not in ["canceled"]: # cancelled builds should have nothing in backend to delete ActionsLogic.send_delete_build(build) for build_chroot in build.build_chroots: db.session.delete(build_chroot) db.session.delete(build)
def test_fork_copr_sends_actions(self, f_users, f_coprs, f_mock_chroots, f_builds, f_db): with app.app_context(): with mock.patch('flask.g') as mc_flask_g: mc_flask_g.user.name = self.u2.name fc1, created = ComplexLogic.fork_copr(self.c1, self.u2, u"dstname") self.db.session.commit() actions = ActionsLogic.get_many(ActionTypeEnum("fork")).all() assert len(actions) == 1 data = json.loads(actions[0].data) assert data["user"] == self.u2.name assert data["copr"] == "dstname" assert data["builds_map"] == {'srpm-builds': {'bar': '00000005'},'fedora-18-x86_64': {'bar': '00000005-hello-world'}}
def test_delete_build_bad_src_pkg(self, f_users, f_coprs, f_mock_chroots, f_builds, f_db): # has meaning only for the builds with old result dir naming schema self.b1.pkgs = "http://example.com/" self.db.session.add(self.b1) self.db.session.commit() expected_chroots_to_delete = set() for bchroot in self.b1_bc: bchroot.git_hash = None expected_chroots_to_delete.add(bchroot.name) assert len(ActionsLogic.get_many().all()) == 0 BuildsLogic.delete_build(self.u1, self.b1) self.db.session.commit() assert len(ActionsLogic.get_many().all()) == 0 with pytest.raises(NoResultFound): BuildsLogic.get(self.b1.id).one()
def cancel_build(cls, user, build): if not user.can_build_in(build.copr): raise InsufficientRightsException( "You are not allowed to cancel this build.") if not build.cancelable: if build.status == StatusEnum("starting"): # this is not intuitive, that's why we provide more specific message err_msg = "Cannot cancel build {} in state 'starting'".format(build.id) else: err_msg = "Cannot cancel build {}".format(build.id) raise RequestCannotBeExecuted(err_msg) if build.status == StatusEnum("running"): # otherwise the build is just in frontend ActionsLogic.send_cancel_build(build) build.canceled = True cls.process_update_callback(build) for chroot in build.build_chroots: chroot.status = 2 # canceled if chroot.ended_on is not None: chroot.ended_on = time.time()
def add(cls, user, name, selected_chroots, repos=None, description=None, instructions=None, check_for_duplicates=False, group=None, **kwargs): copr = models.Copr(name=name, repos=repos or u"", user_id=user.id, description=description or u"", instructions=instructions or u"", created_on=int(time.time()), **kwargs) if group is not None: UsersLogic.raise_if_not_in_group(user, group) copr.group = group # form validation checks for duplicates cls.new(user, copr, check_for_duplicates=check_for_duplicates) CoprChrootsLogic.new_from_names(copr, selected_chroots) db.session.flush() ActionsLogic.send_create_gpg_key(copr) return copr
def test_delete_build_some_chroots( self, f_users, f_coprs, f_mock_chroots, f_builds, f_db): expected_chroots_to_delete = set([self.b1_bc[0].name, self.b1_bc[-1].name]) for bchroot in self.b1_bc[1:-1]: bchroot.status = helpers.StatusEnum("skipped") self.db.session.commit() assert len(ActionsLogic.get_many().all()) == 0 BuildsLogic.delete_build(self.u1, self.b1) self.db.session.commit() assert len(ActionsLogic.get_many().all()) == 1 action = ActionsLogic.get_many().one() delete_data = json.loads(action.data) assert "chroots" in delete_data assert expected_chroots_to_delete == set(delete_data["chroots"]) with pytest.raises(NoResultFound): BuildsLogic.get(self.b1.id).one()
def test_delete_build_bad_src_pkg( self, f_users, f_coprs, f_mock_chroots, f_builds, f_db): # has meaning only for the builds with old result dir naming schema self.b1.pkgs = "http://example.com/" self.db.session.add(self.b1) self.db.session.commit() expected_chroots_to_delete = set() for bchroot in self.b1_bc: bchroot.git_hash = None expected_chroots_to_delete.add(bchroot.name) assert len(ActionsLogic.get_many().all()) == 0 BuildsLogic.delete_build(self.u1, self.b1) self.db.session.commit() assert len(ActionsLogic.get_many().all()) == 0 with pytest.raises(NoResultFound): BuildsLogic.get(self.b1.id).one()
def test_build_post_multipart_on_project_during_action( self, f_users, f_coprs, f_builds, f_db, f_mock_chroots, f_mock_chroots_many, f_build_many_chroots, f_users_api): ActionsLogic.send_delete_copr(self.c1) chroot_name_list = [c.name for c in self.c1.active_chroots] metadata = { "project_id": 1, "enable_net": True, "chroots": chroot_name_list } data = { "metadata": json.dumps(metadata), "srpm": (BytesIO(b'my file contents'), 'hello world.src.rpm') } self.db.session.commit() r0 = self.request_rest_api_with_auth( "/api_2/builds", method="post", content_type="multipart/form-data", data=data) assert r0.status_code == 400
def test_fork_copr_sends_actions(self, mc_flask_g, f_users, f_coprs, f_mock_chroots, f_builds, f_db): mc_flask_g.user.name = self.u2.name fc1, created = ComplexLogic.fork_copr(self.c1, self.u2, u"dstname") self.db.session.commit() actions = ActionsLogic.get_many(ActionTypeEnum("gen_gpg_key")).all() assert len(actions) == 1 data = json.loads(actions[0].data) assert data["username"] == self.u2.name assert data["projectname"] == "dstname" actions = ActionsLogic.get_many(ActionTypeEnum("fork")).all() assert len(actions) == 1 data = json.loads(actions[0].data) assert data["user"] == self.u2.name assert data["copr"] == "dstname" last_build, forked_build = self.c1.packages[0].builds[1], fc1.builds[0] assert data["builds_map"] == { str(forked_build.id): str(last_build.result_dir_name) }
def test_delete_build_some_chroots(self, f_users, f_coprs, f_mock_chroots, f_builds, f_db): expected_chroots_to_delete = set( [self.b1_bc[0].name, self.b1_bc[-1].name]) for bchroot in self.b1_bc[1:-1]: bchroot.status = helpers.StatusEnum("skipped") self.db.session.commit() assert len(ActionsLogic.get_many().all()) == 0 BuildsLogic.delete_build(self.u1, self.b1) self.db.session.commit() assert len(ActionsLogic.get_many().all()) == 1 action = ActionsLogic.get_many().one() delete_data = json.loads(action.data) assert "chroots" in delete_data assert expected_chroots_to_delete == set(delete_data["chroots"]) with pytest.raises(NoResultFound): BuildsLogic.get(self.b1.id).one()
def _update_chroot(cls, buildroot_pkgs, comps, comps_name, copr_chroot): copr_chroot.buildroot_pkgs = buildroot_pkgs if comps_name is not None: copr_chroot.update_comps(comps) copr_chroot.comps_name = comps_name ActionsLogic.send_update_comps(copr_chroot)