def f_build_few_chroots(self):
"""
Requires fixture: f_mock_chroots_many
"""
self.b_few_chroots = models.Build(
id=2345,
copr=self.c1,
user=self.u1,
submitted_on=50,
pkgs="http://example.com/copr-keygen-1.58-1.fc20.src.rpm",
pkg_version="1.58")
self.db.session.add(self.b_few_chroots)
self.status_by_chroot = {
'epel-5-i386': 0,
'fedora-20-i386': 1,
'fedora-20-x86_64': 1,
'fedora-21-i386': 1,
'fedora-21-x86_64': 4
}
for chroot in self.b_few_chroots.copr.active_chroots:
if chroot.name in self.status_by_chroot:
buildchroot = models.BuildChroot(
build=self.b_few_chroots,
mock_chroot=chroot,
status=self.status_by_chroot[chroot.name],
git_hash="12345",
)
self.db.session.add(buildchroot)
self.db.session.add(self.b_few_chroots)
def f_builds(self):
self.b1 = models.Build(
copr=self.c1, user=self.u1, submitted_on=50, started_on=139086644000)
self.b2 = models.Build(
copr=self.c1, user=self.u2, submitted_on=10, ended_on=139086644000)
self.b3 = models.Build(
copr=self.c2, user=self.u2, submitted_on=10)
self.b4 = models.Build(
copr=self.c2, user=self.u2, submitted_on=100)
self.b1_bc = []
self.b2_bc = []
self.b3_bc = []
self.b4_bc = []
for build, build_chroots in zip(
[self.b1, self.b2, self.b3, self.b4],
[self.b1_bc, self.b2_bc, self.b3_bc, self.b4_bc]):
status = None
if build is self.b1: # this build is going to be deleted
status = 1 # succeeded
for chroot in build.copr.active_chroots:
buildchroot = models.BuildChroot(
build=build,
mock_chroot=chroot,
status=status)
build_chroots.append(buildchroot)
self.db.session.add(buildchroot)
self.db.session.add_all([self.b1, self.b2, self.b3, self.b4])
def rebuild_package(cls, package):
build = models.Build(user=None,
pkgs=None,
package_id=package.id,
copr=package.copr,
repos=package.copr.repos,
source_type=package.source_type,
source_json=package.source_json,
submitted_on=int(time.time()),
enable_net=package.enable_net,
timeout=DEFAULT_BUILD_TIMEOUT)
db.session.add(build)
chroots = package.copr.active_chroots
status = helpers.StatusEnum("importing")
for chroot in chroots:
buildchroot = models.BuildChroot(build=build,
status=status,
mock_chroot=chroot,
git_hash=None)
db.session.add(buildchroot)
return build
def f_builds(self):
self.p1 = models.Package(copr=self.c1,
name="hello-world",
source_type=0)
self.p2 = models.Package(copr=self.c2,
name="hello-world",
source_type=0)
self.b1 = models.Build(copr=self.c1,
package=self.p1,
user=self.u1,
submitted_on=50)
self.b2 = models.Build(copr=self.c1,
package=self.p1,
user=self.u2,
submitted_on=10)
self.b3 = models.Build(copr=self.c2,
package=self.p2,
user=self.u2,
submitted_on=10)
self.b4 = models.Build(copr=self.c2,
package=self.p2,
user=self.u2,
submitted_on=100)
self.basic_builds = [self.b1, self.b2, self.b3, self.b4]
self.b1_bc = []
self.b2_bc = []
self.b3_bc = []
self.b4_bc = []
for build, build_chroots in zip(
[self.b1, self.b2, self.b3, self.b4],
[self.b1_bc, self.b2_bc, self.b3_bc, self.b4_bc]):
status = None
if build is self.b1: # this build is going to be deleted
status = StatusEnum("succeeded")
for chroot in build.copr.active_chroots:
buildchroot = models.BuildChroot(
build=build,
mock_chroot=chroot,
status=status,
git_hash="12345",
)
if build is self.b1 or build is self.b2:
buildchroot.started_on = 139086644000
buildchroot.ended_on = 149086644000
build.ended_on = 149086644000
build_chroots.append(buildchroot)
self.db.session.add(buildchroot)
self.db.session.add_all([self.b1, self.b2, self.b3, self.b4])
def f_builds(self):
self.p1 = models.Package(
copr=self.c1, copr_dir=self.c1_dir, name="hello-world", source_type=0)
self.p2 = models.Package(
copr=self.c2, copr_dir=self.c2_dir, name="whatsupthere-world", source_type=0)
self.p3 = models.Package(
copr=self.c2, copr_dir=self.c3_dir, name="goodbye-world", source_type=0)
self.b1 = models.Build(
copr=self.c1, copr_dir=self.c1_dir, package=self.p1,
user=self.u1, submitted_on=50, srpm_url="http://somesrpm",
source_status=StatusEnum("succeeded"), result_dir='bar')
self.b2 = models.Build(
copr=self.c1, copr_dir=self.c1_dir, package=self.p1,
user=self.u2, submitted_on=10, srpm_url="http://somesrpm",
source_status=StatusEnum("importing"), result_dir='bar',
source_json='{}')
self.b3 = models.Build(
copr=self.c2, copr_dir=self.c2_dir, package=self.p2, user=self.u2, submitted_on=10, srpm_url="http://somesrpm", source_status=StatusEnum("importing"), result_dir='bar')
self.b4 = models.Build(
copr=self.c2, copr_dir=self.c2_dir, package=self.p2, user=self.u2, submitted_on=100, srpm_url="http://somesrpm", source_status=StatusEnum("succeeded"), result_dir='bar')
self.basic_builds = [self.b1, self.b2, self.b3, self.b4]
self.b1_bc = []
self.b2_bc = []
self.b3_bc = []
self.b4_bc = []
for build, build_chroots in zip(
[self.b1, self.b2, self.b3, self.b4],
[self.b1_bc, self.b2_bc, self.b3_bc, self.b4_bc]):
status = None
if build is self.b1: # this build is going to be deleted
status = StatusEnum("succeeded")
for chroot in build.copr.active_chroots:
buildchroot = models.BuildChroot(
build=build,
mock_chroot=chroot,
status=status,
git_hash="12345",
result_dir='bar',
)
if build is self.b1 or build is self.b2:
buildchroot.started_on = 1390866440
buildchroot.ended_on = 1490866440
build_chroots.append(buildchroot)
self.db.session.add(buildchroot)
self.db.session.add_all([self.b1, self.b2, self.b3, self.b4])
def add(cls,
user,
pkgs,
copr,
repos=None,
chroots=None,
memory_reqs=None,
timeout=None,
enable_net=True):
if chroots is None:
chroots = []
coprs_logic.CoprsLogic.raise_if_unfinished_blocking_action(
user, copr,
"Can't build while there is an operation in progress: {action}")
users_logic.UsersLogic.raise_if_cant_build_in_copr(
user, copr, "You don't have permissions to build in this copr.")
if not repos:
repos = copr.repos
if " " in pkgs or "\n" in pkgs or "\t" in pkgs or pkgs.strip() != pkgs:
raise exceptions.MalformedArgumentException(
"Trying to create a build using src_pkg "
"with bad characters. Forgot to split?")
build = models.Build(
user=user,
pkgs=pkgs,
copr=copr,
repos=repos,
submitted_on=int(time.time()),
enable_net=bool(enable_net),
)
if memory_reqs:
build.memory_reqs = memory_reqs
if timeout:
build.timeout = timeout or DEFAULT_BUILD_TIMEOUT
db.session.add(build)
# add BuildChroot object for each active (or selected) chroot
# this copr is assigned to
if not chroots:
chroots = copr.active_chroots
for chroot in chroots:
buildchroot = models.BuildChroot(build=build, mock_chroot=chroot)
db.session.add(buildchroot)
return build
def run(self, rawhide_chroot, dest_chroot):
mock_chroot = coprs_logic.MockChrootsLogic.get_from_name(
dest_chroot).first()
if not mock_chroot:
print("Given chroot does not exist. Please run:")
print(" sudo python manage.py create_chroot {}".format(
dest_chroot))
return
mock_rawhide_chroot = coprs_logic.MockChrootsLogic.get_from_name(
rawhide_chroot).first()
if not mock_rawhide_chroot:
print("Given rawhide chroot does not exist. Didnt you mistyped?:")
print(" {}".format(rawhide_chroot))
return
for copr in coprs_logic.CoprsLogic.get_all():
if not self.has_rawhide(copr):
continue
data = {
"copr": copr.name,
"user": copr.user.name,
"rawhide_chroot": rawhide_chroot,
"dest_chroot": dest_chroot,
"builds": []
}
for package in packages_logic.PackagesLogic.get_all(copr.id):
last_build = package.last_build(successful=True)
if last_build:
data["builds"].append(last_build.result_dir_name)
# rbc means rawhide_build_chroot (we needed short variable)
rbc = builds_logic.BuildChrootsLogic.get_by_build_id_and_name(
last_build.id, rawhide_chroot).first()
dbc = builds_logic.BuildChrootsLogic.get_by_build_id_and_name(
last_build.id, dest_chroot).first()
if rbc and not dbc:
dest_build_chroot = models.BuildChroot(**rbc.to_dict())
dest_build_chroot.mock_chroot_id = mock_chroot.id
dest_build_chroot.mock_chroot = mock_chroot
db.session.add(dest_build_chroot)
if len(data["builds"]):
actions_logic.ActionsLogic.send_rawhide_to_release(data)
self.turn_on_the_chroot_for_copr(copr, rawhide_chroot,
mock_chroot)
db.session.commit()
def f_pr_build(self, f_mock_chroots, f_builds, f_pr_dir):
self.b_pr = models.Build(
copr=self.c1, copr_dir=self.c4_dir, package=self.p1,
user=self.u1, submitted_on=50, srpm_url="http://somesrpm",
source_status=StatusEnum("succeeded"), result_dir='0000PR')
self.bc_pr = models.BuildChroot(
build=self.b_pr,
mock_chroot=self.mc2,
status=StatusEnum("succeeded"),
git_hash="deadbeef",
result_dir='0000PR-pr-package',
)
self.db.session.add_all([self.b_pr, self.bc_pr])
def rebuild_package(cls,
package,
source_dict_update={},
copr_dir=None,
update_callback=None,
scm_object_type=None,
scm_object_id=None,
scm_object_url=None,
submitted_by=None):
source_dict = package.source_json_dict
source_dict.update(source_dict_update)
source_json = json.dumps(source_dict)
if not copr_dir:
copr_dir = package.copr.main_dir
build = models.Build(
user=None,
pkgs=None,
package=package,
copr=package.copr,
repos=package.copr.repos,
source_status=StatusEnum("pending"),
source_type=package.source_type,
source_json=source_json,
submitted_on=int(time.time()),
enable_net=package.copr.build_enable_net,
timeout=DEFAULT_BUILD_TIMEOUT,
copr_dir=copr_dir,
update_callback=update_callback,
scm_object_type=scm_object_type,
scm_object_id=scm_object_id,
scm_object_url=scm_object_url,
submitted_by=submitted_by,
)
db.session.add(build)
status = StatusEnum("waiting")
for chroot in package.chroots:
buildchroot = models.BuildChroot(build=build,
status=status,
mock_chroot=chroot,
git_hash=None)
db.session.add(buildchroot)
cls.process_update_callback(build)
return build
def f_build_many_chroots(self):
"""
Requires: f_mock_chroots_many
"""
self.b_many_chroots = models.Build(
id=12347,
copr=self.c1,
copr_dir=self.c1_dir,
user=self.u1,
submitted_on=50,
pkgs="http://example.com/copr-keygen-1.58-1.fc20.src.rpm",
pkg_version="1.58"
)
self.db.session.add(self.b_many_chroots)
self.status_by_chroot = {
'epel-5-i386': 0,
'epel-5-x86_64': 1,
'epel-6-i386': 0,
'epel-6-x86_64': 3,
'epel-7-x86_64': 4,
'fedora-18-x86_64': 5,
'fedora-19-i386': 5,
'fedora-19-x86_64': 6,
'fedora-20-i386': 2,
'fedora-20-x86_64': 3,
'fedora-21-i386': 0,
'fedora-21-x86_64': 0,
'fedora-22-i386': 1,
'fedora-22-x86_64': 1,
'fedora-23-i386': 1,
'fedora-23-x86_64': 4,
}
for chroot in self.b_many_chroots.copr.active_chroots:
buildchroot = models.BuildChroot(
build=self.b_many_chroots,
mock_chroot=chroot,
status=self.status_by_chroot[chroot.name],
git_hash="12345",
result_dir='bar',
)
self.db.session.add(buildchroot)
self.db.session.add(self.b_many_chroots)
def test_copr_build_basic_build_repeat(
self, f_users, f_coprs, f_mock_chroots_many, f_db):
self.b_few_chroots = models.Build(
id=2345,
copr=self.c1,
copr_dir=self.c1_dir,
user=self.u1,
submitted_on=50,
pkgs="http://example.com/copr-keygen-1.58-1.fc20.src.rpm",
pkg_version="1.58"
)
self.db.session.add(self.b_few_chroots)
self.status_by_chroot = {
'epel-5-i386': 0,
'fedora-20-i386': 1,
'fedora-20-x86_64': 1,
'fedora-21-i386': 1,
'fedora-21-x86_64': 4
}
for chroot in self.b_few_chroots.copr.active_chroots:
if chroot.name in self.status_by_chroot:
buildchroot = models.BuildChroot(
build=self.b_few_chroots,
mock_chroot=chroot,
status=self.status_by_chroot[chroot.name])
self.db.session.add(buildchroot)
self.db.session.add_all([self.u1, self.c1, self.b_few_chroots])
self.db.session.commit()
r = self.test_client.post(
"/coprs/{0}/{1}/repeat_build/{2}/"
.format(self.u1.name, self.c1.name, self.b_few_chroots.id),
data={},
follow_redirects=True)
assert r.status_code == 200
# no longer using URL
#assert self.b_few_chroots.pkgs in r.data
assert "Resubmit build {}".format(self.b_few_chroots.id).encode("utf-8") in r.data
def f_build_many_chroots(self):
self.b_many_chroots = models.Build(
id=12347,
copr=self.c1, user=self.u1,
submitted_on=50, started_on=139086644000,
pkgs="http://example.com/copr-keygen-1.58-1.fc20.src.rpm",
pkg_version="1.58"
)
self.db.session.add(self.b_many_chroots)
self.status_by_chroot = {
'epel-5-i386': 0,
'epel-5-x86_64': 1,
'epel-6-i386': 0,
'epel-6-x86_64': 3,
'epel-7-x86_64': 4,
'fedora-17-i386': 5,
'fedora-17-x86_64': 6,
'fedora-18-i386': 2,
'fedora-18-x86_64': 3,
'fedora-19-i386': 0,
'fedora-19-x86_64': 0,
'fedora-20-i386': 1,
'fedora-20-x86_64': 1,
'fedora-21-i386': 1,
'fedora-21-x86_64': 4
}
for chroot in self.b_many_chroots.copr.active_chroots:
buildchroot = models.BuildChroot(
build=self.b_many_chroots,
mock_chroot=chroot,
status=self.status_by_chroot[chroot.name])
self.db.session.add(buildchroot)
self.db.session.add(self.b_many_chroots)
def rawhide_to_release_function(rawhide_chroot, dest_chroot):
mock_chroot = coprs_logic.MockChrootsLogic.get_from_name(
dest_chroot).first()
if not mock_chroot:
print("Given chroot does not exist. Please run:")
print(
" sudo python3 manage.py create-chroot {}".format(dest_chroot))
return
mock_rawhide_chroot = coprs_logic.MockChrootsLogic.get_from_name(
rawhide_chroot).first()
if not mock_rawhide_chroot:
print("Given rawhide chroot does not exist. Didnt you mistyped?:")
print(" {}".format(rawhide_chroot))
return
coprs_query = (coprs_logic.CoprsLogic.get_all().join(
models.CoprChroot).filter(
models.Copr.follow_fedora_branching == True).filter(
models.CoprChroot.mock_chroot == mock_rawhide_chroot).options(
joinedload('copr_chroots').joinedload('mock_chroot')))
for copr in coprs_query:
print("Handling builds in copr '{}', chroot '{}'".format(
copr.full_name, mock_rawhide_chroot.name))
turn_on_the_chroot_for_copr(copr, rawhide_chroot, mock_chroot)
data = {
"projectname": copr.name,
"ownername": copr.owner_name,
"rawhide_chroot": rawhide_chroot,
"dest_chroot": dest_chroot,
"builds": []
}
latest_pkg_builds_in_rawhide = (db.session.query(
func.max(models.Build.id),
).join(models.BuildChroot).join(models.Package).filter(
models.BuildChroot.mock_chroot_id == mock_rawhide_chroot.id
).filter(models.BuildChroot.status == StatusEnum("succeeded")).filter(
models.Package.copr_dir == copr.main_dir).group_by(
models.Package.name))
fork_builds = (db.session.query(models.Build).options(
joinedload('build_chroots').joinedload('mock_chroot')).filter(
models.Build.id.in_(
latest_pkg_builds_in_rawhide.subquery()))).all()
# no builds to fork in this copr
if not len(fork_builds):
continue
for build in fork_builds:
if mock_chroot in build.chroots:
# forked chroot already exists, from previous run?
continue
# rbc means rawhide_build_chroot (we needed short variable)
rbc = None
for rbc in build.build_chroots:
if rbc.mock_chroot == mock_rawhide_chroot:
break
dest_build_chroot = models.BuildChroot(**rbc.to_dict())
dest_build_chroot.mock_chroot_id = mock_chroot.id
dest_build_chroot.mock_chroot = mock_chroot
dest_build_chroot.status = StatusEnum("forked")
db.session.add(dest_build_chroot)
data['builds'].append(build.result_dir)
if len(data["builds"]):
actions_logic.ActionsLogic.send_rawhide_to_release(data)
db.session.commit()
def add(cls,
user,
pkgs,
copr,
source_type=None,
source_json=None,
repos=None,
chroots=None,
timeout=None,
enable_net=True,
git_hashes=None,
skip_import=False):
if chroots is None:
chroots = []
coprs_logic.CoprsLogic.raise_if_unfinished_blocking_action(
copr,
"Can't build while there is an operation in progress: {action}")
users_logic.UsersLogic.raise_if_cant_build_in_copr(
user, copr, "You don't have permissions to build in this copr.")
if not repos:
repos = copr.repos
# todo: eliminate pkgs and this check
if " " in pkgs or "\n" in pkgs or "\t" in pkgs or pkgs.strip() != pkgs:
raise exceptions.MalformedArgumentException(
"Trying to create a build using src_pkg "
"with bad characters. Forgot to split?")
# just temporary to keep compatibility
if not source_type or not source_json:
source_type = helpers.BuildSourceEnum("srpm_link")
source_json = json.dumps({"url": pkgs})
build = models.Build(
user=user,
pkgs=pkgs,
copr=copr,
repos=repos,
source_type=source_type,
source_json=source_json,
submitted_on=int(time.time()),
enable_net=bool(enable_net),
)
if timeout:
build.timeout = timeout or DEFAULT_BUILD_TIMEOUT
db.session.add(build)
# add BuildChroot object for each active (or selected) chroot
# this copr is assigned to
if not chroots:
chroots = copr.active_chroots
status = helpers.StatusEnum("importing")
if skip_import:
status = StatusEnum("pending")
for chroot in chroots:
git_hash = None
if git_hashes:
git_hash = git_hashes.get(chroot.name)
buildchroot = models.BuildChroot(build=build,
status=status,
mock_chroot=chroot,
git_hash=git_hash)
db.session.add(buildchroot)
return build
def update_state_from_dict(cls, build, upd_dict):
"""
:param build:
:param upd_dict:
example:
{
"builds":[
{
"id": 1,
"copr_id": 2,
"started_on": 1390866440
},
{
"id": 2,
"copr_id": 1,
"status": 0,
"chroot": "fedora-18-x86_64",
"result_dir": "baz",
"ended_on": 1390866440
}]
}
"""
log.info("Updating build {} by: {}".format(build.id, upd_dict))
# create the package if it doesn't exist
pkg_name = upd_dict.get('pkg_name', None)
if pkg_name:
if not PackagesLogic.get(build.copr_dir.id, pkg_name).first():
try:
package = PackagesLogic.add(
build.copr.user, build.copr_dir,
pkg_name, build.source_type, build.source_json)
db.session.add(package)
db.session.commit()
except (IntegrityError, DuplicateException) as e:
app.logger.exception(e)
db.session.rollback()
return
build.package = PackagesLogic.get(build.copr_dir.id, pkg_name).first()
for attr in ["built_packages", "srpm_url", "pkg_version"]:
value = upd_dict.get(attr, None)
if value:
setattr(build, attr, value)
# update source build status
if str(upd_dict.get("task_id")) == str(build.task_id):
build.result_dir = upd_dict.get("result_dir", "")
new_status = upd_dict.get("status")
if new_status == StatusEnum("succeeded"):
new_status = StatusEnum("importing")
chroot_status=StatusEnum("waiting")
if not build.build_chroots:
# create the BuildChroots from Package setting, if not
# already set explicitly for concrete build
for chroot in build.package.chroots:
buildchroot = models.BuildChroot(
build=build,
status=chroot_status,
mock_chroot=chroot,
git_hash=None,
)
db.session.add(buildchroot)
else:
for buildchroot in build.build_chroots:
buildchroot.status = chroot_status
db.session.add(buildchroot)
build.source_status = new_status
if new_status == StatusEnum("failed") or \
new_status == StatusEnum("skipped"):
for ch in build.build_chroots:
ch.status = new_status
ch.ended_on = upd_dict.get("ended_on") or time.time()
db.session.add(ch)
if new_status == StatusEnum("failed"):
build.fail_type = FailTypeEnum("srpm_build_error")
cls.process_update_callback(build)
db.session.add(build)
return
if "chroot" in upd_dict:
# update respective chroot status
for build_chroot in build.build_chroots:
if build_chroot.name == upd_dict["chroot"]:
build_chroot.result_dir = upd_dict.get("result_dir", "")
if "status" in upd_dict and build_chroot.status not in BuildsLogic.terminal_states:
build_chroot.status = upd_dict["status"]
if upd_dict.get("status") in BuildsLogic.terminal_states:
build_chroot.ended_on = upd_dict.get("ended_on") or time.time()
if upd_dict.get("status") == StatusEnum("starting"):
build_chroot.started_on = upd_dict.get("started_on") or time.time()
db.session.add(build_chroot)
# If the last package of a module was successfully built,
# then send an action to create module repodata on backend
if (build.module
and upd_dict.get("status") == StatusEnum("succeeded")
and all(b.status == StatusEnum("succeeded") for b in build.module.builds)):
ActionsLogic.send_build_module(build.copr, build.module)
cls.process_update_callback(build)
db.session.add(build)
def add(cls, user, pkgs, copr, source_type=None, source_json=None,
repos=None, chroots=None, timeout=None, enable_net=True,
git_hashes=None, skip_import=False, background=False, batch=None,
srpm_url=None, copr_dirname=None):
if chroots is None:
chroots = []
coprs_logic.CoprsLogic.raise_if_unfinished_blocking_action(
copr, "Can't build while there is an operation in progress: {action}")
users_logic.UsersLogic.raise_if_cant_build_in_copr(
user, copr,
"You don't have permissions to build in this copr.")
if not repos:
repos = copr.repos
# todo: eliminate pkgs and this check
if pkgs and (" " in pkgs or "\n" in pkgs or "\t" in pkgs or pkgs.strip() != pkgs):
raise MalformedArgumentException("Trying to create a build using src_pkg "
"with bad characters. Forgot to split?")
# just temporary to keep compatibility
if not source_type or not source_json:
source_type = helpers.BuildSourceEnum("link")
source_json = json.dumps({"url":pkgs})
if skip_import and srpm_url:
chroot_status = StatusEnum("pending")
source_status = StatusEnum("succeeded")
else:
chroot_status = StatusEnum("waiting")
source_status = StatusEnum("pending")
copr_dir = None
if copr_dirname:
if not copr_dirname.startswith(copr.name+':') and copr_dirname != copr.name:
raise MalformedArgumentException("Copr dirname not starting with copr name.")
copr_dir = coprs_logic.CoprDirsLogic.get_or_create(copr, copr_dirname)
build = models.Build(
user=user,
pkgs=pkgs,
copr=copr,
repos=repos,
source_type=source_type,
source_json=source_json,
source_status=source_status,
submitted_on=int(time.time()),
enable_net=bool(enable_net),
is_background=bool(background),
batch=batch,
srpm_url=srpm_url,
copr_dir=copr_dir,
)
if timeout:
build.timeout = timeout or DEFAULT_BUILD_TIMEOUT
db.session.add(build)
for chroot in chroots:
# Chroots were explicitly set per-build.
git_hash = None
if git_hashes:
git_hash = git_hashes.get(chroot.name)
buildchroot = models.BuildChroot(
build=build,
status=chroot_status,
mock_chroot=chroot,
git_hash=git_hash,
)
db.session.add(buildchroot)
return build
def f_fork_prepare(self, f_coprs, f_mock_chroots, f_builds):
self.p4 = models.Package(
copr=self.c2, copr_dir=self.c2_dir, name="hello-world", source_type=0)
self.b5 = models.Build(
copr=self.c2, copr_dir=self.c2_dir, package=self.p4,
user=self.u1, submitted_on=50, srpm_url="http://somesrpm",
source_status=StatusEnum("succeeded"), result_dir='00000005-hello-world')
self.b6 = models.Build(
copr=self.c2, copr_dir=self.c2_dir, package=self.p4,
user=self.u1, submitted_on=10, srpm_url="http://somesrpm",
source_status=StatusEnum("failed"), result_dir='00000006-hello-world',
source_json='{}')
self.b7 = models.Build(
copr=self.c2, copr_dir=self.c2_dir, package=self.p2,
user=self.u1, submitted_on=10, srpm_url="http://somesrpm",
source_status=StatusEnum("succeeded"), result_dir='00000007-whatsupthere-world')
self.b8 = models.Build(
copr=self.c2, copr_dir=self.c2_dir, package=self.p2,
user=self.u1, submitted_on=100, srpm_url="http://somesrpm",
source_status=StatusEnum("succeeded"), result_dir='00000008-whatsupthere-world')
self.basic_builds = [self.b5, self.b6, self.b7, self.b8]
self.b5_bc = []
self.b6_bc = []
self.b7_bc = []
self.b8_bc = []
self.db.session.flush()
for build, build_chroots in zip(
[self.b5, self.b6, self.b7, self.b8],
[self.b5_bc, self.b6_bc, self.b7_bc, self.b8_bc]):
status = StatusEnum("succeeded")
for chroot in build.copr.active_chroots:
buildchroot = models.BuildChroot(
build=build,
mock_chroot=chroot,
status=status,
git_hash="12345",
result_dir="{}-{}".format(build.id, build.package.name),
)
build_chroots.append(buildchroot)
self.db.session.add(buildchroot)
self.db.session.add_all([self.b5, self.b6, self.b7, self.b8])
self.p5 = models.Package(
copr=self.c2, copr_dir=self.c2_dir, name="new-package", source_type=0)
self.b9 = models.Build(
copr=self.c2, copr_dir=self.c2_dir, package=self.p5,
user=self.u1, submitted_on=100, srpm_url="http://somesrpm",
source_status=StatusEnum("succeeded"), result_dir='00000009-new-package')
self.b10 = models.Build(
copr=self.c2, copr_dir=self.c2_dir, package=self.p5,
user=self.u1, submitted_on=100, srpm_url="http://somesrpm",
source_status=StatusEnum("failed"), result_dir='00000010-new-package')
self.b11 = models.Build(
copr=self.c2, copr_dir=self.c2_dir, package=self.p5,
user=self.u1, submitted_on=100, srpm_url="http://somesrpm",
source_status=StatusEnum("failed"), result_dir='00000011-new-package')
self.b9_bc = []
self.b10_bc = []
self.b11_bc = []
self.db.session.flush()
bc_status = {self.b9: {self.mc2: StatusEnum("succeeded"),
self.mc3: StatusEnum("succeeded")},
self.b10: {self.mc2: StatusEnum("forked"),
self.mc3: StatusEnum("failed")},
self.b11: {self.mc2: StatusEnum("failed"),
self.mc3: StatusEnum("succeeded")}}
for build, build_chroots in zip(
[self.b9, self.b10, self.b11],
[self.b9_bc, self.b10_bc, self.b11_bc]):
for chroot in build.copr.active_chroots:
buildchroot = models.BuildChroot(
build=build,
mock_chroot=chroot,
status=bc_status[build][chroot],
git_hash="12345",
result_dir="{}-{}".format(build.id, build.package.name),
)
build_chroots.append(buildchroot)
self.db.session.add(buildchroot)
self.db.session.add_all([self.b9, self.b10, self.b11])
