def f_actions(self): # if using actions, we need to flush coprs into db, so that we can get # their ids self.f_db() self.a1 = models.Action( action_type=helpers.ActionTypeEnum("rename"), object_type="copr", object_id=self.c1.id, old_value="{0}/{1}".format(self.c1.user.name, self.c1.name), new_value="{0}/new_name".format(self.c1.user.name), created_on=int(time.time())) self.a2 = models.Action( action_type=helpers.ActionTypeEnum("rename"), object_type="copr", object_id=self.c2.id, old_value="{0}/{1}".format(self.c2.user.name, self.c2.name), new_value="{0}/new_name2".format(self.c2.user.name), created_on=int(time.time())) self.a3 = models.Action(action_type=helpers.ActionTypeEnum("delete"), object_type="copr", object_id=100, old_value="asd/qwe", new_value=None, result=helpers.BackendResultEnum("success"), created_on=int(time.time())) self.db.session.add_all([self.a1, self.a2, self.a3])
def f_actions(self, f_db): self.delete_action = models.Action(action_type=ActionTypeEnum("delete"), object_type="copr", object_id=self.c1.id, old_value="asd/qwe", new_value=None, result=BackendResultEnum("waiting"), created_on=int(time.time())) self.cancel_build_action = models.Action(action_type=ActionTypeEnum("cancel_build"), data=json.dumps({'task_id': 123}), result=BackendResultEnum("waiting"), created_on=int(time.time())) self.db.session.add_all([self.delete_action, self.cancel_build_action])
def send_build_module(cls, user, copr, modulemd): """ :type copr: models.Copr :type modulemd: str content of module yaml file """ if not user.can_build_in(copr): raise exceptions.InsufficientRightsException( "You don't have permissions to build in this copr.") modulemd_b64 = base64.b64encode(modulemd) data = { "ownername": copr.owner_name, "projectname": copr.name, "chroots": [c.name for c in copr.active_chroots], "modulemd_b64": modulemd_b64, } action = models.Action( action_type=helpers.ActionTypeEnum("build_module"), object_type="copr", old_value="", new_value="", data=json.dumps(data), created_on=int(time.time()), ) db.session.add(action)
def send_update_module_md(cls, chroot): """ Schedules update module_md.yaml action :type copr_chroot: models.CoprChroot """ if chroot.copr.is_a_group_project: url_path = url_for('coprs_ns.group_chroot_view_module_md', group_name=chroot.copr.group.name, coprname=chroot.copr.name, chrootname=chroot.name) else: url_path = url_for('coprs_ns.chroot_view_module_md', username=chroot.copr.user.username, coprname=chroot.copr.name, chrootname=chroot.name) data_dict = { "ownername": chroot.copr.owner_name, "projectname": chroot.copr.name, "chroot": chroot.name, "module_md_present": chroot.module_md_zlib is not None, "url_path": url_path, } action = models.Action( action_type=helpers.ActionTypeEnum("update_module_md"), object_type="copr_chroot", data=json.dumps(data_dict), created_on=int(time.time())) db.session.add(action)
def test_state(self, f_users, f_coprs, f_mock_chroots, f_builds, f_modules, f_db): self.b1.build_chroots[0].status = StatusEnum("pending") self.b3.build_chroots[0].status = StatusEnum("succeeded") self.b3.build_chroots[1].status = StatusEnum("succeeded") self.b3.source_status = StatusEnum("succeeded") # even though b3 is succeeded, b1 is still pending self.m1.builds = [self.b1, self.b3] assert self.m1.status == ModuleStatusEnum("pending") # now what if b1 succeeds self.b1.build_chroots[0].status = StatusEnum("succeeded") assert self.m1.status == ModuleStatusEnum("succeeded") # let's say that b3 failed self.b3.build_chroots[0].status = StatusEnum("failed") assert self.m1.status == ModuleStatusEnum("failed") # once the action exists, it dictates the status self.b3.build_chroots[0].status = StatusEnum("succeeded") action = models.Action( action_type=ActionTypeEnum("build_module"), object_type="module", object_id=self.m1.id, ) db.session.add(action) assert self.m1.status == ModuleStatusEnum("waiting") # the backend proceeds the action action.result = BackendResultEnum("success") assert self.m1.status == ModuleStatusEnum("succeeded")
def update(cls, user, copr, check_for_duplicates=True): cls.raise_if_unfinished_blocking_action( user, copr, "Can't change this project name," " another operation is in progress: {action}") users_logic.UsersLogic.raise_if_cant_update_copr( user, copr, "Only owners and admins may update their projects.") existing = cls.exists_for_user(copr.owner, copr.name).first() if existing: if check_for_duplicates and existing.id != copr.id: raise exceptions.DuplicateException( "Project: '{0}' already exists".format(copr.name)) else: # we're renaming # if we fire a models.Copr.query, it will use the modified copr in session # -> workaround this by just getting the name old_copr_name = (db.session.query(models.Copr.name) .filter(models.Copr.id == copr.id) .filter(models.Copr.deleted == False) .first()[0]) action = models.Action(action_type=helpers.ActionTypeEnum("rename"), object_type="copr", object_id=copr.id, old_value="{0}/{1}".format(copr.owner.name, old_copr_name), new_value="{0}/{1}".format(copr.owner.name, copr.name), created_on=int(time.time())) db.session.add(action) db.session.add(copr)
def send_createrepo(cls, copr, dirnames=None): possible_dirnames = [copr_dir.name for copr_dir in copr.dirs] if not dirnames: # by default we createrepo for all of them dirnames = possible_dirnames else: missing = set(dirnames) - set(possible_dirnames) if missing: raise exceptions.NotFoundException( "Can't createrepo for {} dirnames in {} project".format( missing, copr.full_name)) data_dict = { "ownername": copr.owner_name, "projectname": copr.name, "project_dirnames": dirnames, "chroots": [chroot.name for chroot in copr.active_chroots], } action = models.Action( action_type=ActionTypeEnum("createrepo"), object_type="repository", object_id=0, data=json.dumps(data_dict), created_on=int(time.time()), ) db.session.add(action)
def send_delete_build(cls, build): """ Schedules build delete action :type build: models.Build """ # don't delete skipped chroots chroots_to_delete = [ chroot.name for chroot in build.build_chroots if chroot.state not in ["skipped"] ] if len(chroots_to_delete) == 0: return data_dict = { "username": build.copr.owner.name, "projectname": build.copr.name, "chroots": chroots_to_delete } if build.is_older_results_naming_used: if build.src_pkg_name is None or build.src_pkg_name == "": return data_dict["src_pkg_name"] = build.src_pkg_name else: data_dict["result_dir_name"] = build.result_dir_name action = models.Action(action_type=helpers.ActionTypeEnum("delete"), object_type="build", object_id=build.id, old_value="{0}/{1}".format( build.copr.owner.name, build.copr.name), data=json.dumps(data_dict), created_on=int(time.time())) db.session.add(action)
def send_rawhide_to_release(cls, data): action = models.Action( action_type=helpers.ActionTypeEnum("rawhide_to_release"), object_type="None", data=json.dumps(data), created_on=int(time.time()), ) db.session.add(action)
def create_delete_action(cls, copr): action = models.Action(action_type=helpers.ActionTypeEnum("delete"), object_type="copr", object_id=copr.id, old_value=copr.full_name, new_value="", created_on=int(time.time())) db.session.add(action) return action
def send_delete_copr(cls, copr): data_dict = { "ownername": copr.owner_name, "project_dirnames": [copr_dir.name for copr_dir in copr.dirs], } action = models.Action(action_type=ActionTypeEnum("delete"), object_type="copr", object_id=copr.id, data=json.dumps(data_dict), created_on=int(time.time())) db.session.add(action)
def send_delete_build(cls, build): """ Schedules build delete action :type build: models.Build """ action = models.Action(action_type=ActionTypeEnum("delete"), object_type="build", object_id=build.id, data=json.dumps( cls.get_build_delete_data(build)), created_on=int(time.time())) db.session.add(action)
def send_createrepo(cls, username, coprname, chroots): data_dict = { "username": username, "projectname": coprname, "chroots": chroots } action = models.Action( action_type=helpers.ActionTypeEnum("createrepo"), object_type="None", object_id=0, old_value="", data=json.dumps(data_dict), created_on=int(time.time()), ) db.session.add(action)
def send_cancel_build(cls, build): """ Schedules build cancel action :type build: models.Build """ for chroot in build.build_chroots: if chroot.state != "running": continue data_dict = { "task_id": chroot.task_id, } action = models.Action(action_type=ActionTypeEnum("cancel_build"), data=json.dumps(data_dict), created_on=int(time.time())) db.session.add(action)
def send_fork_copr(cls, src, dst, builds_map): """ :type src: models.Copr :type dst: models.Copr :type builds_map: dict where keys are forked builds IDs and values are IDs from the original builds. """ action = models.Action( action_type=helpers.ActionTypeEnum("fork"), object_type="copr", old_value="{0}".format(src.full_name), new_value="{0}".format(dst.full_name), data=json.dumps({"user": dst.owner_name, "copr": dst.name, "builds_map": builds_map}), created_on=int(time.time()), ) db.session.add(action)
def send_create_gpg_key(cls, copr): """ :type copr: models.Copr """ data_dict = { "username": copr.owner.name, "projectname": copr.name, } action = models.Action( action_type=helpers.ActionTypeEnum("gen_gpg_key"), object_type="copr", data=json.dumps(data_dict), created_on=int(time.time()), ) db.session.add(action)
def send_delete_chroot(cls, copr_chroot): """ Schedules deletion of a chroot directory from project Useful to remove outdated chroots :type build: models.CoprChroot """ data_dict = { "ownername": copr_chroot.copr.owner_name, "projectname": copr_chroot.copr.name, "chrootname": copr_chroot.name, } action = models.Action(action_type=ActionTypeEnum("delete"), object_type="chroot", object_id=None, data=json.dumps(data_dict), created_on=int(time.time())) db.session.add(action)
def send_update_comps(cls, chroot): """ Schedules update comps.xml action :type copr_chroot: models.CoprChroot """ data_dict = { "username": chroot.copr.owner.name, "projectname": chroot.copr.name, "chroot": chroot.name, "comps_present": chroot.comps_zlib is not None, } action = models.Action( action_type=helpers.ActionTypeEnum("update_comps"), object_type="copr_chroot", data=json.dumps(data_dict), created_on=int(time.time())) db.session.add(action)
def send_delete_multiple_builds(cls, builds): """ Schedules builds delete action for builds belonging to the same project :type build: list of models.Build """ project_dirnames = {} data = {'project_dirnames': project_dirnames} build_ids = [] for build in builds: build_delete_data = cls.get_build_delete_data(build) build_ids.append(build.id) # inherit some params from the first build for param in ['ownername', 'projectname']: new = build_delete_data[param] if param in data and data[param] != new: # this shouldn't happen raise exceptions.BadRequest("Can not delete builds " "from more projects") data[param] = new dirname = build_delete_data['project_dirname'] if not dirname in project_dirnames: project_dirnames[dirname] = {} project_dirname = project_dirnames[dirname] for chroot, subdirs in build_delete_data['chroot_builddirs'].items( ): if chroot not in project_dirname: project_dirname[chroot] = subdirs else: project_dirname[chroot].extend(subdirs) data['build_ids'] = build_ids # not object_id here, we are working with multiple IDs action = models.Action(action_type=ActionTypeEnum("delete"), object_type="builds", data=json.dumps(data), created_on=int(time.time())) db.session.add(action)
def delete(cls, user, copr, check_for_duplicates=True): 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( user, copr, "Can't delete this project," " another operation is in progress: {action}") action = models.Action(action_type=helpers.ActionTypeEnum("delete"), object_type="copr", object_id=copr.id, old_value="{0}/{1}".format(copr.owner.name, copr.name), new_value="", created_on=int(time.time())) copr.deleted = True db.session.add(action) return copr
def delete_build(cls, user, build): if not user.can_build_in(build.copr): raise exceptions.InsufficientRightsException( "You are not allowed to delete this build.") if not build.deletable: raise exceptions.ActionInProgressException( "You can not delete build which is not finished.", "Unfinished build") # Only failed, finished, succeeded get here. if build.state not in ["cancelled" ]: # has nothing in backend to delete # don't delete skipped chroots chroots_to_delete = [ chroot.name for chroot in build.build_chroots if chroot.state not in ["skipped"] ] if chroots_to_delete: data_dict = { "pkgs": build.pkgs, "username": build.copr.owner.name, "projectname": build.copr.name, "chroots": chroots_to_delete } action = models.Action( action_type=helpers.ActionTypeEnum("delete"), object_type="build", object_id=build.id, old_value="{0}/{1}".format(build.copr.owner.name, build.copr.name), data=json.dumps(data_dict), created_on=int(time.time())) db.session.add(action) for build_chroot in build.build_chroots: db.session.delete(build_chroot) db.session.delete(build)
def send_update_comps(cls, chroot): """ Schedules update comps.xml action :type copr_chroot: models.CoprChroot """ url_path = helpers.copr_url("coprs_ns.chroot_view_comps", chroot.copr, chrootname=chroot.name) data_dict = { "ownername": chroot.copr.owner_name, "projectname": chroot.copr.name, "chroot": chroot.name, "comps_present": chroot.comps_zlib is not None, "url_path": url_path, } action = models.Action(action_type=ActionTypeEnum("update_comps"), object_type="copr_chroot", data=json.dumps(data_dict), created_on=int(time.time())) db.session.add(action)
def send_build_module(cls, copr, modulemd): """ :type copr: models.Copr :type modulemd: str content of module yaml file """ modulemd_b64 = base64.b64encode(modulemd) data = { "ownername": copr.owner_name, "projectname": copr.name, "chroots": [c.name for c in copr.active_chroots], "modulemd_b64": modulemd_b64, } action = models.Action( action_type=helpers.ActionTypeEnum("build_module"), object_type="copr", old_value="", new_value="", data=json.dumps(data), created_on=int(time.time()), ) db.session.add(action)
def send_build_module(cls, copr, module): """ :type copr: models.Copr :type modulemd: str content of module yaml file """ mock_chroots = set.intersection( *[set(b.chroots) for b in module.builds]) data = { "chroots": [ch.name for ch in mock_chroots], "builds": [b.id for b in module.builds], } action = models.Action( action_type=ActionTypeEnum("build_module"), object_type="module", object_id=module.id, old_value="", new_value="", data=json.dumps(data), created_on=int(time.time()), ) db.session.add(action)