def test_koji_build_check_names(github_pr_event):
trigger = flexmock(
job_config_trigger_type=JobConfigTriggerType.pull_request, id=123
)
flexmock(AddPullRequestDbTrigger).should_receive("db_trigger").and_return(trigger)
helper = build_helper(
event=github_pr_event,
metadata=JobMetadataConfig(targets=["bright-future"], scratch=True),
db_trigger=trigger,
)
flexmock(koji_build).should_receive("get_all_koji_targets").and_return(
["dark-past", "bright-future"]
).once()
koji_build_url = get_koji_build_info_url_from_flask(1)
flexmock(StatusReporter).should_receive("set_status").with_args(
state=CommitStatus.pending,
description="Building SRPM ...",
check_name="packit-stg/production-build-bright-future",
url="",
).and_return()
flexmock(StatusReporter).should_receive("set_status").with_args(
state=CommitStatus.pending,
description="Building RPM ...",
check_name="packit-stg/production-build-bright-future",
url=koji_build_url,
).and_return()
flexmock(GitProject).should_receive("get_pr").and_return(
flexmock(source_project=flexmock())
)
flexmock(GitProject).should_receive("set_commit_status").and_return().never()
flexmock(SRPMBuildModel).should_receive("create").and_return(
SRPMBuildModel(id=1, success=True)
)
flexmock(KojiBuildModel).should_receive("get_or_create").and_return(
KojiBuildModel(id=1)
)
flexmock(PackitAPI).should_receive("create_srpm").and_return("my.srpm")
# koji build
flexmock(Upstream).should_receive("koji_build").and_return(
"Uploading srpm: /python-ogr-0.11.1"
".dev21+gf2dec9b-1.20200407142424746041.21.gf2dec9b.fc31.src.rpm\n"
"[====================================] 100% 00:00:11 1.67 MiB 148.10 KiB/sec\n"
"Created task: 43429338\n"
"Task info: https://koji.fedoraproject.org/koji/taskinfo?taskID=43429338\n"
)
flexmock(PackitAPI).should_receive("init_kerberos_ticket").once()
assert helper.run_koji_build()["success"]
def test_koji_build_start(koji_build_scratch_start, pc_koji_build_pr,
koji_build_pr):
koji_build_pr.target = "rawhide"
flexmock(GithubProject).should_receive("is_private").and_return(False)
flexmock(KojiBuildEvent).should_receive("get_package_config").and_return(
pc_koji_build_pr)
flexmock(KojiBuildModel).should_receive("get_by_build_id").and_return(
koji_build_pr)
url = get_koji_build_info_url_from_flask(1)
flexmock(requests).should_receive("get").and_return(requests.Response())
flexmock(
requests.Response).should_receive("raise_for_status").and_return(None)
koji_build_pr.should_receive("set_build_start_time").once()
koji_build_pr.should_receive("set_build_finished_time").with_args(
None).once()
koji_build_pr.should_receive("set_status").with_args("pending").once()
koji_build_pr.should_receive("set_build_logs_url")
koji_build_pr.should_receive("set_web_url")
# check if packit-service set correct PR status
flexmock(StatusReporter).should_receive("report").with_args(
state=CommitStatus.pending,
description="RPM build is in progress...",
url=url,
check_names="packit-stg/production-build-rawhide",
).once()
flexmock(Signature).should_receive("apply_async").once()
processing_results = SteveJobs().process_message(koji_build_scratch_start)
event_dict, package_config, job = get_parameters_from_results(
processing_results)
results = run_koji_build_report_handler(
package_config=package_config,
event=event_dict,
job_config=job,
)
assert first_dict_value(results["job"])["success"]
def run(self):
build = KojiBuildModel.get_by_build_id(
build_id=str(self.koji_event.build_id))
if not build:
msg = f"Koji build {self.koji_event.build_id} not found in the database."
logger.warning(msg)
return TaskResults(success=False, details={"msg": msg})
logger.debug(
f"Build on {build.target} in koji changed state "
f"from {self.koji_event.old_state} to {self.koji_event.state}.")
build.set_build_start_time(
datetime.utcfromtimestamp(self.koji_event.start_time) if self.
koji_event.start_time else None)
build.set_build_finished_time(
datetime.utcfromtimestamp(self.koji_event.completion_time) if self.
koji_event.completion_time else None)
url = get_koji_build_info_url_from_flask(build.id)
build_job_helper = KojiBuildJobHelper(
service_config=self.service_config,
package_config=self.package_config,
project=self.project,
metadata=self.data,
db_trigger=self.db_trigger,
job_config=self.job_config,
)
if self.koji_event.state == KojiBuildState.open:
build.set_status("pending")
build_job_helper.report_status_to_all_for_chroot(
description="RPM build is in progress...",
state=CommitStatus.pending,
url=url,
chroot=build.target,
)
elif self.koji_event.state == KojiBuildState.closed:
build.set_status("success")
build_job_helper.report_status_to_all_for_chroot(
description="RPMs were built successfully.",
state=CommitStatus.success,
url=url,
chroot=build.target,
)
elif self.koji_event.state == KojiBuildState.failed:
build.set_status("failed")
build_job_helper.report_status_to_all_for_chroot(
description="RPMs failed to be built.",
state=CommitStatus.failure,
url=url,
chroot=build.target,
)
elif self.koji_event.state == KojiBuildState.canceled:
build.set_status("error")
build_job_helper.report_status_to_all_for_chroot(
description="RPMs build was canceled.",
state=CommitStatus.error,
url=url,
chroot=build.target,
)
else:
logger.debug(
f"We don't react to this koji build state change: {self.koji_event.state}"
)
koji_build_logs = self.koji_event.get_koji_build_logs_url()
build.set_build_logs_url(koji_build_logs)
koji_rpm_task_web_url = self.koji_event.get_koji_build_logs_url()
build.set_web_url(koji_rpm_task_web_url)
msg = (f"Build on {build.target} in koji changed state "
f"from {self.koji_event.old_state} to {self.koji_event.state}.")
return TaskResults(success=True, details={"msg": msg})
def run_koji_build(self) -> TaskResults:
if not self.is_scratch:
msg = "Non-scratch builds not possible from upstream."
self.report_status_to_all(
description=msg,
state=CommitStatus.error,
url=KOJI_PRODUCTION_BUILDS_ISSUE,
)
return TaskResults(success=True, details={"msg": msg})
self.report_status_to_all(
description="Building SRPM ...", state=CommitStatus.pending
)
self.create_srpm_if_needed()
if not self.srpm_model.success:
msg = "SRPM build failed, check the logs for details."
self.report_status_to_all(
state=CommitStatus.failure,
description=msg,
url=get_srpm_log_url_from_flask(self.srpm_model.id),
)
return TaskResults(success=False, details={"msg": msg})
try:
# We need to do it manually
# because we don't use PackitAPI.build, but PackitAPI.up.koji_build
self.api.init_kerberos_ticket()
except PackitCommandFailedError as ex:
msg = f"Kerberos authentication error: {ex.stderr_output}"
logger.error(msg)
self.report_status_to_all(
state=CommitStatus.error,
description=msg,
url=get_srpm_log_url_from_flask(self.srpm_model.id),
)
return TaskResults(success=False, details={"msg": msg})
errors: Dict[str, str] = {}
for target in self.build_targets:
if target not in self.supported_koji_targets:
msg = f"Target not supported: {target}"
self.report_status_to_all_for_chroot(
state=CommitStatus.error,
description=msg,
url=get_srpm_log_url_from_flask(self.srpm_model.id),
chroot=target,
)
errors[target] = msg
continue
try:
build_id, web_url = self.run_build(target=target)
except Exception as ex:
sentry_integration.send_to_sentry(ex)
# TODO: Where can we show more info about failure?
# TODO: Retry
self.report_status_to_all_for_chroot(
state=CommitStatus.error,
description=f"Submit of the build failed: {ex}",
url=get_srpm_log_url_from_flask(self.srpm_model.id),
chroot=target,
)
errors[target] = str(ex)
continue
koji_build = KojiBuildModel.get_or_create(
build_id=str(build_id),
commit_sha=self.metadata.commit_sha,
web_url=web_url,
target=target,
status="pending",
srpm_build=self.srpm_model,
trigger_model=self.db_trigger,
)
url = get_koji_build_info_url_from_flask(id_=koji_build.id)
self.report_status_to_all_for_chroot(
state=CommitStatus.pending,
description="Building RPM ...",
url=url,
chroot=target,
)
if errors:
return TaskResults(
success=False,
details={
"msg": "Koji build submit was not successful for all chroots.",
"errors": errors,
},
)
# TODO: release the hounds!
"""
celery_app.send_task(
"task.babysit_koji_build",
args=(build_metadata.build_id,),
countdown=120, # do the first check in 120s
)
"""
return TaskResults(success=True, details={})