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 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 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_rawhide_to_release(cls, data):
action = models.Action(
action_type=ActionTypeEnum("rawhide_to_release"),
object_type="None",
data=json.dumps(data),
created_on=int(time.time()),
)
db.session.add(action)
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["ownername"] == username
assert data_dict["projectname"] == coprname
def unfinished_blocking_actions_for(cls, copr):
blocking_actions = [ActionTypeEnum("delete")]
actions = (models.Action.query.filter(
models.Action.object_type ==
"copr").filter(models.Action.object_id == copr.id).filter(
models.Action.result == BackendResultEnum("waiting")).filter(
models.Action.action_type.in_(blocking_actions)))
return actions
def test_legal_flag_doesnt_block_copr_functionality(
self, f_users, f_coprs, f_db):
self.db.session.add(
self.models.Action(object_type="copr",
object_id=self.c1.id,
action_type=ActionTypeEnum("legal-flag")))
self.db.session.commit()
# test will fail if this raises exception
CoprsLogic.raise_if_unfinished_blocking_action(self.c1, "ha, failed")
def get_waiting(cls):
"""
Return actions that aren't finished
"""
query = (models.Action.query.filter(
models.Action.result == BackendResultEnum("waiting")).filter(
models.Action.action_type != ActionTypeEnum("legal-flag")).
order_by(models.Action.created_on.asc()))
return query
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 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["ownername"] == self.u1.name
assert data["projectname"] == name
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 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_create_gpg_key(cls, copr):
"""
:type copr: models.Copr
"""
data_dict = {
"ownername": copr.owner_name,
"projectname": copr.name,
}
action = models.Action(
action_type=ActionTypeEnum("gen_gpg_key"),
object_type="copr",
data=json.dumps(data_dict),
created_on=int(time.time()),
)
db.session.add(action)
def test_fork_copr_projects_with_more_builds(self, mc_flask_g, f_users, f_fork_prepare, f_db):
mc_flask_g.user.name = self.u2.name
fc2, created = ComplexLogic.fork_copr(self.c2, 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': {'00000008-whatsupthere-world': '00000012', '00000006-hello-world': '00000013',
'00000010-new-package': '00000014', '00000011-new-package': '00000015'},
'fedora-17-x86_64': {'8-whatsupthere-world': '00000012-whatsupthere-world',
'6-hello-world': '00000013-hello-world',
'10-new-package': '00000014-new-package'},
'fedora-17-i386': {'8-whatsupthere-world': '00000012-whatsupthere-world',
'6-hello-world': '00000013-hello-world',
'11-new-package': '00000015-new-package'}}
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_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 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=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_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, 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)
