def run_propose_downstream_handler(event: dict, package_config: dict, job_config: dict):
handler = ProposeDownstreamHandler(
package_config=load_package_config(package_config),
job_config=load_job_config(job_config),
data=EventData.from_event_dict(event),
)
return get_handlers_task_results(handler.run_job(), event)
def run_distgit_commit_handler(event: dict, package_config: dict, job_config: dict):
handler = NewDistGitCommitHandler(
package_config=load_package_config(package_config),
job_config=load_job_config(job_config),
data=EventData.from_event_dict(event),
)
return get_handlers_task_results(handler.run_job(), event)
def run_pr_copr_build_handler(event: dict, package_config: dict, job_config: dict):
handler = PullRequestCoprBuildHandler(
package_config=load_package_config(package_config),
job_config=load_job_config(job_config),
data=EventData.from_event_dict(event),
)
return get_handlers_task_results(handler.run_job(), event)
def test_precheck(github_pr_event):
flexmock(PullRequestModel).should_receive("get_or_create").with_args(
pr_id=342,
namespace="packit-service",
repo_name="packit",
project_url="https://github.com/packit-service/packit",
).and_return(
flexmock(id=342,
job_config_trigger_type=JobConfigTriggerType.pull_request))
copr_build_handler = CoprBuildHandler(
package_config=PackageConfig(jobs=[
JobConfig(
type=JobType.copr_build,
trigger=JobConfigTriggerType.pull_request,
),
JobConfig(
type=JobType.tests,
trigger=JobConfigTriggerType.pull_request,
),
]),
job_config=JobConfig(
type=JobType.copr_build,
trigger=JobConfigTriggerType.pull_request,
),
data=EventData.from_event_dict(github_pr_event.get_dict()),
)
assert copr_build_handler.pre_check()
def run_push_koji_build_handler(event: dict, package_config: dict, job_config: dict):
handler = PushGithubKojiBuildHandler(
package_config=load_package_config(package_config),
job_config=load_job_config(job_config),
data=EventData.from_event_dict(event),
)
return get_handlers_task_results(handler.run_job(), event)
def check_copr_build(build_id: int) -> bool:
"""
Check the copr_build with given id and refresh the status if needed.
Used in the babysit task.
:param build_id: id of the copr_build (CoprBuildModel.build.id)
:return: True if in case of successful run, False when we need to retry
"""
logger.debug(f"Getting copr build ID {build_id} from DB.")
builds = CoprBuildModel.get_all_by_build_id(build_id)
if not builds:
logger.warning(f"Copr build {build_id} not in DB.")
return True
copr_client = CoprClient.create_from_config_file()
build_copr = copr_client.build_proxy.get(build_id)
if not build_copr.ended_on:
logger.info("The copr build is still in progress.")
return False
logger.info(f"The status is {build_copr.state!r}.")
for build in builds:
if build.status != "pending":
logger.info(f"DB state says {build.status!r}, "
"things were taken care of already, skipping.")
continue
chroot_build = copr_client.build_chroot_proxy.get(
build_id, build.target)
event = CoprBuildEvent(
topic=FedmsgTopic.copr_build_finished.value,
build_id=build_id,
build=build,
chroot=build.target,
status=(COPR_API_SUCC_STATE if chroot_build.state
== COPR_SUCC_STATE else COPR_API_FAIL_STATE),
owner=build.owner,
project_name=build.project_name,
pkg=build_copr.source_package.get(
"name", ""), # this seems to be the SRPM name
timestamp=chroot_build.ended_on,
)
job_configs = get_config_for_handler_kls(
handler_kls=CoprBuildEndHandler,
event=event,
package_config=event.get_package_config(),
)
for job_config in job_configs:
CoprBuildEndHandler(
package_config=event.package_config,
job_config=job_config,
data=EventData.from_event_dict(event.get_dict()),
copr_event=event,
).run()
return True
def run_testing_farm_comment_handler(event: dict, package_config: dict,
job_config: dict):
handler = GitHubPullRequestCommentTestingFarmHandler(
package_config=load_package_config(package_config),
job_config=load_job_config(job_config),
data=EventData.from_event_dict(event),
)
return get_handlers_task_results(handler.run_job(), event)
def run_koji_build_report_handler(event: dict, package_config: dict, job_config: dict):
handler = KojiBuildReportHandler(
package_config=load_package_config(package_config),
job_config=load_job_config(job_config),
data=EventData.from_event_dict(event),
koji_event=KojiBuildEvent.from_event_dict(event),
)
return get_handlers_task_results(handler.run_job(), event)
def run_copr_build_start_handler(event: dict, package_config: dict, job_config: dict):
handler = CoprBuildStartHandler(
package_config=load_package_config(package_config),
job_config=load_job_config(job_config),
data=EventData.from_event_dict(event),
copr_event=CoprBuildEvent.from_event_dict(event),
)
return get_handlers_task_results(handler.run_job(), event)
def run_propose_update_comment_handler(event: dict, package_config: dict,
job_config: dict):
handler = GitHubIssueCommentProposeUpdateHandler(
package_config=load_package_config(package_config),
job_config=load_job_config(job_config),
data=EventData.from_event_dict(event),
)
return get_handlers_task_results(handler.run_job(), event)
def test_event_data_parse_pr(github_pr_event):
flexmock(AddPullRequestDbTrigger).should_receive("db_trigger").and_return(
None)
data = EventData.from_event_dict(github_pr_event.get_dict())
assert data.event_type == "PullRequestGithubEvent"
assert data.user_login == "lbarcziova"
assert not data.git_ref
assert data.commit_sha == "528b803be6f93e19ca4130bf4976f2800a3004c4"
assert data.identifier == "342"
assert data.pr_id == 342
def run_testing_farm_handler(event: dict, package_config: dict,
job_config: dict, chroot: str, build_id: int):
handler = GithubTestingFarmHandler(
package_config=load_package_config(package_config),
job_config=load_job_config(job_config),
data=EventData.from_event_dict(event),
chroot=chroot,
build_id=build_id,
)
return get_handlers_task_results(handler.run_job(), event)
def run_pagure_pr_label_handler(event: dict, package_config: dict, job_config: dict):
handler = PagurePullRequestLabelHandler(
package_config=load_package_config(package_config),
job_config=load_job_config(job_config),
data=EventData.from_event_dict(event),
labels=event.get("labels"),
action=PullRequestLabelAction(event.get("action")),
base_repo_owner=event.get("base_repo_owner"),
base_repo_name=event.get("base_repo_name"),
base_repo_namespace=event.get("base_repo_namespace"),
)
return get_handlers_task_results(handler.run_job(), event)
def run_testing_farm_results_handler(event: dict, package_config: dict,
job_config: dict):
handler = TestingFarmResultsHandler(
package_config=load_package_config(package_config),
job_config=load_job_config(job_config),
data=EventData.from_event_dict(event),
tests=[TestResult(**test) for test in event.get("tests", [])],
result=TestingFarmResult(event.get("result"))
if event.get("result") else None,
pipeline_id=event.get("pipeline_id"),
log_url=event.get("log_url"),
copr_chroot=event.get("copr_chroot"),
message=event.get("message"),
)
return get_handlers_task_results(handler.run_job(), event)
def _check_pr_event(
self,
event: Union[PullRequestGithubEvent, PullRequestCommentGithubEvent,
MergeRequestGitlabEvent,
MergeRequestCommentGitlabEvent, ],
project: GitProject,
service_config: ServiceConfig,
job_configs: Iterable[JobConfig],
) -> bool:
account_name = event.user_login
if not account_name:
raise KeyError(f"Failed to get account_name from {type(event)}")
namespace = event.target_repo_namespace
namespace_approved = self.is_approved(namespace)
user_approved = (project.can_merge_pr(account_name)
or project.get_pr(event.pr_id).author == account_name)
if namespace_approved and user_approved:
# TODO: clear failing check when present
return True
msg = (
f"Namespace {namespace} is not on our allowlist!"
if not namespace_approved else
f"Account {account_name} has no write access nor is author of PR!")
logger.error(msg)
if isinstance(
event,
(PullRequestCommentGithubEvent, MergeRequestCommentGitlabEvent)):
project.pr_comment(event.pr_id, msg)
else:
for job_config in job_configs:
job_helper = CoprBuildJobHelper(
service_config=service_config,
package_config=event.get_package_config(),
project=project,
metadata=EventData.from_event_dict(event.get_dict()),
db_trigger=event.db_trigger,
job_config=job_config,
)
msg = ("Namespace is not allowed!"
if not namespace_approved else "User cannot trigger!")
job_helper.report_status_to_all(description=msg,
state=CommitStatus.error,
url=FAQ_URL)
return False
def test_precheck_skip_tests_when_build_defined(github_pr_event):
copr_build_handler = AbstractCoprBuildHandler(
package_config=PackageConfig(jobs=[
JobConfig(
type=JobType.copr_build,
trigger=JobConfigTriggerType.pull_request,
),
JobConfig(
type=JobType.tests,
trigger=JobConfigTriggerType.pull_request,
),
]),
job_config=JobConfig(
type=JobType.tests,
trigger=JobConfigTriggerType.pull_request,
),
data=EventData.from_event_dict(github_pr_event.get_dict()),
)
assert not copr_build_handler.pre_check()
def test_precheck_push_to_a_different_branch(github_push_event):
flexmock(GitBranchModel).should_receive("get_or_create").and_return(
flexmock(id=1, job_config_trigger_type=JobConfigTriggerType.commit))
copr_build_handler = CoprBuildHandler(
package_config=PackageConfig(jobs=[
JobConfig(
type=JobType.copr_build,
trigger=JobConfigTriggerType.commit,
metadata=JobMetadataConfig(branch="bad-branch"),
),
]),
job_config=JobConfig(
type=JobType.copr_build,
trigger=JobConfigTriggerType.commit,
metadata=JobMetadataConfig(branch="bad-branch"),
),
data=EventData.from_event_dict(github_push_event.get_dict()),
)
assert not copr_build_handler.pre_check()
def check_and_report(
self,
event: Optional[Any],
project: GitProject,
service_config: ServiceConfig,
job_configs: Iterable[JobConfig],
) -> bool:
"""
Check if account is approved and report status back in case of PR
:param service_config: service config
:param event: PullRequest and Release TODO: handle more
:param project: GitProject
:param job_configs: iterable of jobconfigs - so we know how to update status of the PR
:return:
"""
# whitelist checks dont apply to CentOS (Pagure, Gitlab)
if isinstance(
event,
(
PushPagureEvent,
PullRequestPagureEvent,
PullRequestCommentPagureEvent,
MergeRequestCommentGitlabEvent,
IssueCommentGitlabEvent,
MergeRequestGitlabEvent,
PushGitlabEvent,
),
):
logger.info(
"Centos (Pagure, Gitlab) events don't require whitelist checks."
)
return True
# TODO: modify event hierarchy so we can use some abstract classes instead
if isinstance(event, (ReleaseEvent, PushGitHubEvent)):
account_name = event.repo_namespace
if not account_name:
raise KeyError(
f"Failed to get account_name from {type(event)!r}")
if not self.is_approved(account_name):
logger.info(
"Refusing release event on not whitelisted repo namespace."
)
return False
return True
if isinstance(
event,
(
CoprBuildEvent,
TestingFarmResultsEvent,
DistGitEvent,
InstallationEvent,
KojiBuildEvent,
),
):
return True
if isinstance(event,
(PullRequestGithubEvent, PullRequestCommentGithubEvent)):
account_name = event.user_login
if not account_name:
raise KeyError(
f"Failed to get account_name from {type(event)}")
namespace = event.target_repo_namespace
# FIXME:
# Why check account_name when we whitelist namespace only (in whitelist.add_account())?
if not (self.is_approved(account_name)
or self.is_approved(namespace)):
msg = f"Neither account {account_name} nor owner {namespace} are on our whitelist!"
logger.error(msg)
if event.trigger == TheJobTriggerType.pr_comment:
project.pr_comment(event.pr_id, msg)
else:
for job_config in job_configs:
job_helper = CoprBuildJobHelper(
service_config=service_config,
package_config=event.get_package_config(),
project=project,
metadata=EventData.from_event_dict(
event.get_dict()),
db_trigger=event.db_trigger,
job_config=job_config,
)
msg = "Account is not whitelisted!" # needs to be shorter
job_helper.report_status_to_all(
description=msg,
state=CommitStatus.error,
url=FAQ_URL)
return False
# TODO: clear failing check when present
return True
if isinstance(event, IssueCommentEvent):
account_name = event.user_login
if not account_name:
raise KeyError(
f"Failed to get account_name from {type(event)}")
namespace = event.repo_namespace
# FIXME:
# Why check account_name when we whitelist namespace only (in whitelist.add_account())?
if not (self.is_approved(account_name)
or self.is_approved(namespace)):
msg = f"Neither account {account_name} nor owner {namespace} are on our whitelist!"
logger.error(msg)
project.issue_comment(event.issue_id, msg)
return False
return True
msg = f"Failed to validate account: Unrecognized event type {type(event)!r}."
logger.error(msg)
raise PackitException(msg)
def test_testing_farm_response(tests_result, tests_message, tests_tests,
status_status, status_message):
flexmock(PackageConfigGetter).should_receive(
"get_package_config_from_repo").and_return(
flexmock(jobs=[
JobConfig(
type=JobType.copr_build,
trigger=JobConfigTriggerType.pull_request,
)
], ))
config = flexmock(command_handler_work_dir=flexmock())
flexmock(TFResultsHandler).should_receive("service_config").and_return(
config)
flexmock(TFResultsEvent).should_receive("db_trigger").and_return(None)
config.should_receive("get_project").with_args(
url="https://github.com/packit-service/ogr").and_return()
event_dict = TFResultsEvent(
pipeline_id="id",
result=tests_result,
environment=flexmock(),
message=tests_message,
log_url="some url",
copr_repo_name=flexmock(),
copr_chroot="fedora-rawhide-x86_64",
tests=tests_tests,
repo_namespace=flexmock(),
repo_name=flexmock(),
git_ref=flexmock(),
project_url="https://github.com/packit-service/ogr",
commit_sha=flexmock(),
).get_dict()
test_farm_handler = TFResultsHandler(
package_config=flexmock(),
job_config=flexmock(),
data=EventData.from_event_dict(event_dict),
tests=tests_tests,
result=tests_result,
pipeline_id="id",
log_url="some url",
copr_chroot="fedora-rawhide-x86_64",
message=tests_message,
)
flexmock(StatusReporter).should_receive("report").with_args(
state=status_status,
description=status_message,
url="some url",
check_names="packit-stg/testing-farm-fedora-rawhide-x86_64",
)
tft_test_run_model = flexmock()
tft_test_run_model.should_receive("set_status").with_args(
tests_result).and_return().once()
tft_test_run_model.should_receive("set_web_url").with_args(
"some url").and_return().once()
flexmock(TFTTestRunModel).should_receive("get_by_pipeline_id").and_return(
tft_test_run_model)
flexmock(LocalProject).should_receive("refresh_the_arguments").and_return(
None)
test_farm_handler.run()
