def set_local_project(self): """ update self.local_project """ # TODO: ogr should have a method, something like this: # get_github_service(token, app_id, inst_id, cert_path) -> GithubService # the logic below should be the function # I want to leave this code here up the end of this sprint # TODO: in order to support any git forge here, ogr should also have a method like this: # get_github_service_from_url(url, **kwargs): # ogr should guess the forge based on the url; kwargs should be passed to the # constructor in order to support the above if (self.config.github_app_id and self.config.github_app_cert_path and self.config.github_app_installation_id): logger.info("Authenticating with Github using a Githab app.") private_key = Path(self.config.github_app_cert_path).read_text() integration = github.GithubIntegration(self.config.github_app_id, private_key) token = integration.get_access_token( self.config.github_app_installation_id) gh_service = GithubService(token=token) else: logger.debug("Authenticating with Github using a token.") gh_service = GithubService(token=self.config.github_token) self.local_project.git_service = gh_service if not self.local_project.repo_name: # will this ever happen? self.local_project.repo_name = self.package_name
def setUp(self): self.token = os.environ.get("GITHUB_TOKEN") self.user = os.environ.get("GITHUB_USER") test_name = self.id() or "all" persistent_data_file = os.path.join( PERSISTENT_DATA_PREFIX, f"test_github_data_{test_name}.yaml") persistent_object_storage = PersistentObjectStorage( persistent_data_file) if persistent_object_storage.is_write_mode and (not self.user or not self.token): raise EnvironmentError( "please set GITHUB_TOKEN GITHUB_USER env variables") self.service = GithubService( token=self.token, persistent_storage=persistent_object_storage) self.colin_project = self.service.get_project(namespace="user-cont", repo="colin") self.colin_fork = self.service.get_project(namespace="user-cont", repo="colin", is_fork=True) self.not_forked_project = self.service.get_project( namespace="fedora-modularity", repo="fed-to-brew")
def main(): """Create issues warning users of data purge and how to continue injesting knowledge from Thoth.""" # this takes care of accidentally passing a filter on empty strings to the database which will usually result in no # entries being found os_name = os.getenv("PURGE_OS_NAME") if os.getenv( "PURGE_OS_NAME") else None os_version = os.getenv("PURGE_OS_VERSION") if os.getenv( "PURGE_OS_VERSION") else None python_version = os.getenv("PURGE_PYTHON_VERSION") if os.getenv( "PURGE_PYTHON_VERSION") else None all_installations = GRAPH.get_kebechet_github_installation_info_with_software_environment_all( os_name=os_name, os_version=os_version, python_version=python_version, ) available_software_runtimes = GRAPH.get_solved_python_package_versions_software_environment_all( ) gh = GithubService( token=os.getenv("GITHUB_KEBECHET_TOKEN"), github_app_id=os.getenv("GITHUB_APP_ID"), github_private_key_path=os.getenv("GITHUB_PRIVATE_KEY_PATH"), ) number_issues_total = len(all_installations) number_issues_created = 0 for i in all_installations: try: p = gh.get_project(namespace=i["slug"].split("/")[0], repo=i["repo_name"]) # We shouldn't have to check if the issue exists because the purge job is run for each env only once p.create_issue( title= f"{os_name}:{os_version}py{python_version} being purged from Thoth DB", body=_ISSUE_BODY.format( os_name=os_name, os_version=os_version, python_version=python_version, available_runtimes=json.dumps(available_software_runtimes, indent=4), ), private=i["private"], labels=["bot"], ) number_issues_created += 1 except Exception as e: _LOGGER.error( f"Could not create issue for {i['slug']} because: {e!r}") set_schema_metrics() number_purge_issues_created.labels( component="workflow-helpers", env=Configuration.THOTH_DEPLOYMENT_NAME).set(number_issues_created) number_purge_issues_total.labels( component="workflow-helpers", env=Configuration.THOTH_DEPLOYMENT_NAME).set(number_issues_total) send_metrics()
def create_ogr_service( service_type: str, service_url: Optional[str] = None, token: Optional[str] = None, github_app_id: Optional[str] = None, github_private_key_path: Optional[str] = None, ): """Create a new OGR service for interacting with remote GitForges.""" service_type = service_type.upper() if service_type == "GITHUB": ogr_service = GithubService( token=token, github_app_id=os.getenv("GITHUB_APP_ID"), github_private_key_path=os.getenv("GITHUB_PRIVATE_KEY_PATH"), ) elif service_type == "GITLAB": ogr_service = GitlabService(token=token, instance_url=service_url) elif service_type == "PAGURE": ogr_service = PagureService( token=token, instance_url=service_url, ) else: raise NotImplementedError(f"Kebechet cannot act on {service_type}") return ogr_service
def mock_remote_functionality(distgit: Path, upstream: Path): def mocked_create_pr(*args, **kwargs): return PullRequestReadOnly( title="", id=42, status=PRStatus.open, url="", description="", author="", source_branch="", target_branch="", created=datetime.datetime(1969, 11, 11, 11, 11, 11, 11), ) flexmock(GithubService) github_service = GithubService() flexmock( GithubService, get_project=lambda repo, namespace: GithubProject( "also-not", github_service, "set", github_repo=flexmock() ), ) flexmock( PagureProject, get_git_urls=lambda: {"git": DOWNSTREAM_PROJECT_URL}, fork_create=lambda: None, get_fork=lambda: PagureProject("", "", PagureService()), create_pr=mocked_create_pr, ) flexmock( GithubProject, get_git_urls=lambda: {"git": UPSTREAM_PROJECT_URL}, fork_create=lambda: None, ) flexmock(PagureUser, get_username=lambda: "packito") dglp = LocalProject( working_dir=distgit, git_url="https://packit.dev/rpms/beer", git_service=PagureService(), ) flexmock( DistGit, push_to_fork=lambda *args, **kwargs: None, # let's not hammer the production lookaside cache webserver is_archive_in_lookaside_cache=lambda archive_path: False, local_project=dglp, ) flexmock(DistGit).should_receive("existing_pr").and_return(None) def mocked_new_sources(sources=None): if not Path(sources).is_file(): raise RuntimeError("archive does not exist") flexmock(PkgTool, new_sources=mocked_new_sources) flexmock(PackitAPI, init_kerberos_ticket=lambda: None) pc = get_local_package_config(str(upstream)) pc.dist_git_clone_path = str(distgit) pc.upstream_project_url = str(upstream) return upstream, distgit
def run(project_url: str, fork_namespace: str): """Run single repo thoth-advise demo.""" namespace, repo, service_url = _parse_url_4_args(project_url) service = GithubService(token=_TOKEN) original_project = service.get_project(namespace=namespace, repo=repo) if original_project.is_fork: original_project.create_issue( title="Thoth Demo failed due to forked repository", body=templates.run_on_fork_issue, ) raise NotImplementedError( "This workflow does not work on projects which are already forks of other projects." ) original_project.github_repo.create_fork(organization=fork_namespace) fork_project = service.get_project(namespace=fork_namespace, repo=repo) base_thoth_config = pkg_resources.read_text(resources, "example.thoth.yaml") with cloned_repo(fork_project) as repo: _write_to_file(".thoth.yaml", base_thoth_config) result, error = thamos.lib.advise_here() # type: ignore if error: _LOGGER.warning( "Thoth adviser failed to resolve a stack... Quitting") original_project.create_issue( title="Thoth cannot issue advice at this time.", body=templates.failed_issue_body) exit(1) _write_result2files(result) repo.git.checkout("-b", "thoth-demo") repo.index.add([".thoth.yaml", "Pipfile", "Pipfile.lock"]) repo.index.commit( "Lock down dependencies using Thoth resolution and add basic thoth configuration." ) repo.remotes.origin.push("thoth-demo") original_project.create_pr( title="Demonstration of Thoth dependency management", body=templates.thoth_demo_body, target_branch=original_project.default_branch, source_branch="thoth-demo", fork_username=fork_namespace, )
def mock_config(self): service_config = ServiceConfig() service_config.services = { GithubService(token="token"), GitlabService(token="token"), } service_config.dry_run = False service_config.github_requests_log_path = "/path" ServiceConfig.service_config = service_config
def setUp(self): self.token = os.environ.get("GITHUB_TOKEN") self.user = os.environ.get("GITHUB_USER") test_name = self.id() or "all" self.is_write_mode = bool(os.environ.get("FORCE_WRITE")) if self.is_write_mode and (not self.user or not self.token): raise EnvironmentError( "please set GITHUB_TOKEN GITHUB_USER env variables") persistent_data_file = os.path.join( PERSISTENT_DATA_PREFIX, f"test_github_data_{test_name}.yaml") self.service = GithubService( token=self.token, persistent_storage=PersistentObjectStorage(persistent_data_file, self.is_write_mode), read_only=True, ) self.colin_project = self.service.get_project(namespace="user-cont", repo="colin")
def setup_class(cls): service_config = ServiceConfig() service_config.services = { GithubService(token="12345"), PagureService(instance_url="https://git.stg.centos.org", token="6789"), } service_config.dry_run = False service_config.github_requests_log_path = "/path" ServiceConfig.service_config = service_config
def _init_helper(self): """Handle the initialization or reinitialization of OGR object.""" if self.service_type == ServiceType.GITHUB: if self.service_url: self.service = GithubService(self.token, instance_url=self.service_url) else: self.service = GithubService(self.token) self.repository = self.service.get_project( repo=self.repo, namespace=self.namespace) elif self.service_type == ServiceType.GITLAB: if self.service_url: self.service = GitlabService(self.token, instance_url=self.service_url) else: self.service = GitlabService(self.token) self.repository = self.service.get_project( repo=self.repo, namespace=self.namespace) else: raise NotImplementedError
def test_check_and_report(whitelist: Whitelist, events: List[Tuple[AbstractGithubEvent, bool]]): """ :param whitelist: fixture :param events: fixture: [(Event, should-be-approved)] """ flexmock( GithubProject, pr_comment=lambda *args, **kwargs: None, set_commit_status=lambda *args, **kwargs: None, issue_comment=lambda *args, **kwargs: None, ) flexmock(PullRequestEvent).should_receive("get_package_config").and_return( flexmock(jobs=[ JobConfig( job=JobType.tests, trigger=JobTriggerType.pull_request, metadata={"targets": ["fedora-rawhide"]}, ) ], )) git_project = GithubProject("", GithubService(), "") for event, is_valid in events: if isinstance(event, PullRequestEvent) and not is_valid: # Report the status flexmock(CoprHelper).should_receive("get_copr_client").and_return( Client( config={ "copr_url": "https://copr.fedorainfracloud.org", "username": "******", })) flexmock(LocalProject).should_receive( "refresh_the_arguments").and_return(None) flexmock(LocalProject).should_receive("checkout_pr").and_return( None) flexmock(Model).should_receive("save").and_return(None) flexmock(StatusReporter).should_receive("report").with_args( description="Account is not whitelisted!", state="error", url=FAQ_URL, check_names=[EXPECTED_TESTING_FARM_CHECK_NAME], ).once() assert (whitelist.check_and_report( event, git_project, config=flexmock(deployment=Deployment.stg, command_handler_work_dir=""), ) is is_valid)
def ogr_service(cls) -> BaseGitService: if cls.SERVICE_NAME == "GITHUB": return GithubService( token=cls.AUTH_TOKEN, github_app_id=cls.GITHUB_APP_ID, github_app_private_key_path=cls.GITHUB_APP_PRIVATE_KEY_PATH, ) elif cls.SERVICE_NAME == "GITLAB": return GitlabService(token=cls.AUTH_TOKEN, instance_url=cls.SERVICE_URL) elif cls.SERVICE_NAME == "PAGURE": return PagureService(token=cls.AUTH_TOKEN, instance_url=cls.SERVICE_URL) else: raise NotImplementedError( f"Varangian cannot run on {cls.SERVICE_NAME} git services.")
def _ogr_service_from_dict(service_dict: Dict[str, str]) -> BaseGitService: if service_dict["service_name"] == "GITHUB": return GithubService( token=service_dict.get("auth_token"), github_app_id=service_dict.get("github_app_id"), github_app_private_key_path=service_dict.get( "github_app_private_key_path"), ) elif service_dict["service_name"] == "GITLAB": return GitlabService(token=service_dict.get("auth_token"), instance_url=service_dict.get("service_url")) elif service_dict["service_name"] == "PAGURE": return PagureService(token=service_dict.get("auth_token"), instance_url=service_dict.get("service_url")) else: raise NotImplementedError( f"Varangian cannot run on {service_dict['service_name']} git services." )
class ReadOnly(unittest.TestCase): def setUp(self): self.token = os.environ.get("GITHUB_TOKEN") self.user = os.environ.get("GITHUB_USER") test_name = self.id() or "all" self.is_write_mode = bool(os.environ.get("FORCE_WRITE")) if self.is_write_mode and (not self.user or not self.token): raise EnvironmentError( "please set GITHUB_TOKEN GITHUB_USER env variables") persistent_data_file = os.path.join( PERSISTENT_DATA_PREFIX, f"test_github_data_{test_name}.yaml") self.service = GithubService( token=self.token, persistent_storage=PersistentObjectStorage(persistent_data_file, self.is_write_mode), read_only=True, ) self.colin_project = self.service.get_project(namespace="user-cont", repo="colin") def tearDown(self): self.service.persistent_storage.dump() def test_pr_comments(self): pr_comments = self.colin_project.get_pr_comments(7) assert pr_comments assert len(pr_comments) == 2 assert pr_comments[0].comment.endswith( "I've just integrated your thoughts.") assert pr_comments[1].comment.startswith("Thank you!") def test_create_pr(self): pr = self.colin_project.pr_create("title", "text", "master", "souce_branch") assert pr.title == "title" def test_create_fork(self): fork = self.colin_project.fork_create() assert not fork.is_fork
def test_check_and_report(event, should_pass): w = Whitelist() w.db = { "anakin": { "status": "approved_manually" }, "yoda": { "status": "approved_manually" }, "naboo": { "status": "approved_manually" }, } flexmock( GithubProject, pr_comment=lambda *args, **kwargs: None, set_commit_status=lambda *args, **kwargs: None, issue_comment=lambda *args, **kwargs: None, ) git_project = GithubProject("", GithubService(), "") assert w.check_and_report(event, git_project) == should_pass
def test_check_and_report(whitelist: Whitelist, events: List[Tuple[AbstractGithubEvent, bool]]): """ :param whitelist: fixture :param events: fixture: [(Event, should-be-approved)] """ flexmock( GithubProject, pr_comment=lambda *args, **kwargs: None, set_commit_status=lambda *args, **kwargs: None, issue_comment=lambda *args, **kwargs: None, ) flexmock(PullRequestEvent).should_receive("get_package_config").and_return( flexmock(jobs=[ JobConfig(job=JobType.tests, trigger=JobTriggerType.pull_request, metadata={}) ])) git_project = GithubProject("", GithubService(), "") for event in events: assert (whitelist.check_and_report( event[0], git_project, config=flexmock(deployment=Deployment.stg)) is event[1])
def mock_remote_functionality(distgit, upstream): def mocked_pr_create(*args, **kwargs): return PullRequest( title="", id=42, status=PRStatus.open, url="", description="", author="", source_branch="", target_branch="", created=datetime.datetime(1969, 11, 11, 11, 11, 11, 11), ) flexmock(GithubService) github_service = GithubService() flexmock( GithubService, get_project=lambda repo, namespace: GithubProject( "also-not", github_service, "set", github_repo=flexmock()), ) flexmock( PagureProject, get_git_urls=lambda: {"git": DOWNSTREAM_PROJECT_URL}, fork_create=lambda: None, get_fork=lambda: PagureProject("", "", PagureService()), pr_create=mocked_pr_create, ) flexmock( OurPagure, get_git_urls=lambda: {"git": DOWNSTREAM_PROJECT_URL}, get_fork=lambda: PagureProject("", "", flexmock()), ) flexmock( GithubProject, get_git_urls=lambda: {"git": UPSTREAM_PROJECT_URL}, fork_create=lambda: None, ) def mock_download_remote_sources(): """ mock download of the remote archive and place it into dist-git repo """ tarball_path = distgit / TARBALL_NAME hops_filename = "hops" hops_path = distgit / hops_filename hops_path.write_text("Cascade\n") subprocess.check_call( ["tar", "-cf", str(tarball_path), hops_filename], cwd=distgit) flexmock(SpecFile, download_remote_sources=mock_download_remote_sources) flexmock( DistGit, push_to_fork=lambda *args, **kwargs: None, # let's not hammer the production lookaside cache webserver is_archive_in_lookaside_cache=lambda archive_path: False, build=lambda scratch: None, ) def mocked_new_sources(sources=None): if not Path(sources).is_file(): raise RuntimeError("archive does not exist") flexmock(FedPKG, init_ticket=lambda x=None: None, new_sources=mocked_new_sources) pc = get_local_package_config(str(upstream)) pc.downstream_project_url = str(distgit) pc.upstream_project_url = str(upstream) # https://stackoverflow.com/questions/45580215/using-flexmock-on-python-modules flexmock(sys.modules["packit.bot_api"]).should_receive( "get_packit_config_from_repo").and_return(pc) return upstream, distgit
def github_service(github_token): return GithubService(token=github_token, read_only=True)
def _github_service(self): return GithubService(token=self.config.github_token)
def test_check_and_report(whitelist: Whitelist, events: List[Tuple[AbstractGithubEvent, bool]]): """ :param whitelist: fixture :param events: fixture: [(Event, should-be-approved)] """ flexmock( GithubProject, pr_comment=lambda *args, **kwargs: None, set_commit_status=lambda *args, **kwargs: None, issue_comment=lambda *args, **kwargs: None, ) flexmock(PullRequestGithubEvent).should_receive( "get_package_config").and_return( flexmock(jobs=[ JobConfig( type=JobType.tests, trigger=JobConfigTriggerType.pull_request, metadata=JobMetadataConfig(targets=["fedora-rawhide"]), ) ], )) git_project = GithubProject("", GithubService(), "") for event, is_valid in events: if isinstance(event, PullRequestGithubEvent) and not is_valid: # Report the status flexmock(CoprHelper).should_receive("get_copr_client").and_return( Client( config={ "copr_url": "https://copr.fedorainfracloud.org", "username": "******", })) flexmock(LocalProject).should_receive( "refresh_the_arguments").and_return(None) flexmock(LocalProject).should_receive("checkout_pr").and_return( None) flexmock(StatusReporter).should_receive("report").with_args( description="Account is not whitelisted!", state=CommitStatus.error, url=FAQ_URL, check_names=[EXPECTED_TESTING_FARM_CHECK_NAME], ).once() # get_account returns the whitelist object if it exists # returns nothing if it isn't whitelisted # then inside the whitelist.py file, a function checks if the status is # one of the approved statuses # this exact code is used twice above but mypy has an issue with this one only whitelist_mock = flexmock(DBWhitelist).should_receive("get_account") if not TYPE_CHECKING: if is_valid: whitelist_mock.and_return( DBWhitelist(status="approved_manually")) else: whitelist_mock.and_return(None) assert (whitelist.check_and_report( event, git_project, config=flexmock(deployment=Deployment.stg, command_handler_work_dir=""), ) is is_valid)
def test_check_and_report( allowlist: Allowlist, allowlist_entries, events: Iterable[Tuple[AbstractGithubEvent, bool, Iterable[str]]], ): """ :param allowlist: fixture :param events: fixture: [(Event, should-be-approved)] """ flexmock( GithubProject, create_check_run=lambda *args, **kwargs: None, get_issue=lambda *args, **kwargs: flexmock(comment=lambda *args, ** kwargs: None), get_pr=lambda *args, **kwargs: flexmock(source_project=flexmock(), author=None, comment=lambda *args, **kwargs: None), ) job_configs = [ JobConfig( type=JobType.tests, trigger=JobConfigTriggerType.pull_request, metadata=JobMetadataConfig(_targets=["fedora-rawhide"]), ) ] flexmock(PullRequestGithubEvent).should_receive( "get_package_config").and_return(flexmock(jobs=job_configs, )) flexmock(PullRequestModel).should_receive("get_or_create").and_return( flexmock( job_config_trigger_type=JobConfigTriggerType.pull_request, id=123, job_trigger_model_type=JobTriggerModelType.pull_request, )) flexmock(JobTriggerModel).should_receive("get_or_create").with_args( type=JobTriggerModelType.pull_request, trigger_id=123).and_return( flexmock(id=2, type=JobTriggerModelType.pull_request)) git_project = GithubProject("", GithubService(), "") for event, is_valid, resolved_through in events: flexmock(GithubProject, can_merge_pr=lambda username: is_valid) flexmock( event, project=git_project).should_receive("get_dict").and_return(None) # needs to be included when running only `test_allowlist` # flexmock(event).should_receive("db_trigger").and_return( # flexmock(job_config_trigger_type=job_configs[0].trigger).mock() # ) flexmock(EventData).should_receive("from_event_dict").and_return( flexmock(commit_sha="0000000", pr_id="0")) if isinstance(event, PullRequestGithubEvent) and not is_valid: # Report the status flexmock(CoprHelper).should_receive("get_copr_client").and_return( Client( config={ "copr_url": "https://copr.fedorainfracloud.org", "username": "******", })) flexmock(LocalProject).should_receive( "refresh_the_arguments").and_return(None) flexmock(LocalProject).should_receive("checkout_pr").and_return( None) flexmock(StatusReporter).should_receive("report").with_args( description="Namespace is not allowed!", state=BaseCommitStatus.neutral, url=FAQ_URL, check_names=[EXPECTED_TESTING_FARM_CHECK_NAME], markdown_content=None, ).once() flexmock(packit_service.worker.build.copr_build).should_receive( "get_valid_build_targets").and_return({ "fedora-rawhide-x86_64", }) mock_model(allowlist_entries, resolved_through) assert (allowlist.check_and_report( event, git_project, service_config=flexmock( deployment=Deployment.stg, command_handler_work_dir="", admins=["admin"], ), job_configs=job_configs, ) is is_valid)
def github_service(github_token): return GithubService(token=github_token)
def service(self): if not self._service: self._service = GithubService(token=self.token, read_only=True) return self._service
def test_get_service_class_not_found(url, mapping): with pytest.raises(OgrException) as ex: _ = get_service_class(url=url, service_mapping_update=mapping) assert str(ex.value) == "No matching service was found." @pytest.mark.parametrize( "url,mapping,instances,result", [ ( "https://github.com/packit-service/ogr", None, None, GithubProject(namespace="packit-service", repo="ogr", service=GithubService()), ), ( "github.com/packit-service/ogr", None, None, GithubProject(namespace="packit-service", repo="ogr", service=GithubService()), ), ( "[email protected]:packit-service/ogr.git", None, None, GithubProject(namespace="packit-service", repo="ogr",
def test_check_and_report(allowlist: Allowlist, events: List[Tuple[AbstractGithubEvent, bool]]): """ :param allowlist: fixture :param events: fixture: [(Event, should-be-approved)] """ flexmock( GithubProject, pr_comment=lambda *args, **kwargs: None, set_commit_status=lambda *args, **kwargs: None, issue_comment=lambda *args, **kwargs: None, get_pr=lambda *args, **kwargs: flexmock(source_project=flexmock(), author=None), ) job_configs = [ JobConfig( type=JobType.tests, trigger=JobConfigTriggerType.pull_request, metadata=JobMetadataConfig(targets=["fedora-rawhide"]), ) ] flexmock(PullRequestGithubEvent).should_receive( "get_package_config").and_return(flexmock(jobs=job_configs, )) flexmock(PullRequestModel).should_receive("get_or_create").and_return( flexmock(job_config_trigger_type=JobConfigTriggerType.pull_request)) git_project = GithubProject("", GithubService(), "") for event, is_valid in events: flexmock(GithubProject, can_merge_pr=lambda username: is_valid) flexmock( event, project=git_project).should_receive("get_dict").and_return(None) # needs to be included when running only `test_allowlist` # flexmock(event).should_receive("db_trigger").and_return( # flexmock(job_config_trigger_type=job_configs[0].trigger).mock() # ) flexmock(EventData).should_receive("from_event_dict").and_return( flexmock(commit_sha="0000000", pr_id="0")) if isinstance(event, PullRequestGithubEvent) and not is_valid: # Report the status flexmock(CoprHelper).should_receive("get_copr_client").and_return( Client( config={ "copr_url": "https://copr.fedorainfracloud.org", "username": "******", })) flexmock(LocalProject).should_receive( "refresh_the_arguments").and_return(None) flexmock(LocalProject).should_receive("checkout_pr").and_return( None) flexmock(StatusReporter).should_receive("report").with_args( description="Namespace is not allowed!", state=CommitStatus.error, url=FAQ_URL, check_names=[EXPECTED_TESTING_FARM_CHECK_NAME], ).once() flexmock(packit_service.worker.build.copr_build).should_receive( "get_valid_build_targets").and_return({ "fedora-rawhide-x86_64", }) # get_account returns the allowlist object if it exists # returns nothing if it isn't allowlisted # then inside the allowlist.py file, a function checks if the status is # one of the approved statuses # this exact code is used twice above but mypy has an issue with this one only allowlist_mock = flexmock(DBAllowlist).should_receive("get_account") if not TYPE_CHECKING: if is_valid: allowlist_mock.and_return( DBAllowlist(status="approved_manually")) else: allowlist_mock.and_return(None) assert (allowlist.check_and_report( event, git_project, service_config=flexmock( deployment=Deployment.stg, command_handler_work_dir="", admins=["admin"], ), job_configs=job_configs, ) is is_valid)
def update_keb_installation(): """Load files and pass them to storages update function.""" if _SLUG is None: _LOGGER.info("No slug present, continuing to next step in task.") return service = GithubService( github_app_id=os.getenv("GITHUB_APP_ID"), github_app_private_key_path=os.getenv("GITHUB_PRIVATE_KEY_PATH"), ) # TODO: extend to use other services project = service.get_project(namespace=_SLUG.split("/")[0], repo=_SLUG.split("/")[1]) raw_thoth_config = project.get_file_content(".thoth.yaml") with TemporaryDirectory() as repo_path, cwd(repo_path): thoth_config.load_config_from_string(raw_thoth_config) requirements_format = thoth_config.content["requirements_format"] overlays_dir = thoth_config.content.get("overlays_dir") to_update: List[RuntimeEnvironment] if overlays_dir is not None: to_update = [RuntimeEnvironment.from_dict(r) for r in thoth_config.list_runtime_environments()] else: to_update = [RuntimeEnvironment.from_dict(thoth_config.get_runtime_environment())] for runtime_environment in to_update: if overlays_dir: prefix = f"{overlays_dir}/{runtime_environment.name}/" else: prefix = "" if requirements_format == "pipenv": pipfile_r = project.get_file_content(f"{prefix}Pipfile") with open("Pipfile", "wb") as f: f.write(pipfile_r) try: piplock_r = project.get_file_content(f"{prefix}Pipfile.lock") with open("Pipfile.lock", "wb") as f: f.write(piplock_r) project = Project.from_files(pipfile_path="Pipfile", pipfile_lock_path="Pipfile.lock") except Exception: _LOGGER.debug("No Pipfile.lock found") project = Project.from_files( pipfile_path="Pipfile", without_pipfile_lock=True, runtime_environment=runtime_environment, ) elif requirements_format in ["pip", "pip-tools", "pip-compile"]: try: requirements_r = project.get_file_content(f"{prefix}requirements.txt") with open("requirements.txt", "wb") as f: f.write(requirements_r) project = Project.from_pip_compile_files( requirements_path="requirements.txt", allow_without_lock=True, runtime_environment=runtime_environment, ) except Exception: _LOGGER.debug("No requirements.txt found, trying to download requirements.in") requirements_r = project.get_file_content(f"{prefix}requirements.in") with open("requirements.in", "wb") as f: f.write(requirements_r.content) project = Project.from_pip_compile_files( requirements_path="requirements.in", allow_without_lock=True, runtime_environment=runtime_environment, ) project = Project.from_pip_compile_files(allow_without_lock=True) else: raise NotImplementedError(f"{requirements_format} requirements format not supported.") db.update_kebechet_installation_using_files( slug=_SLUG, runtime_environment_name=runtime_environment.name, installation_id=str(project.github_repo.id), requirements=project.pipfile.to_dict(), requirements_lock=project.pipfile_lock.to_dict(), thoth_config=thoth_config, ) present_installations = db.get_kebechet_github_app_installations_all(slug=_SLUG) cur_env_names = {r.name for r in to_update} all_env_names = {installation["runtime_environment_name"] for installation in present_installations} to_delete = all_env_names - cur_env_names for name in to_delete: db.delete_kebechet_github_app_installations(slug=_SLUG, runtime_environment=name)
def sourcegit_service(self) -> GitService: return GithubService(token=self.github_token)
# SPDX-License-Identifier: MIT import enum import sentry_sdk import time from copr.v3 import Client from datetime import datetime, timedelta, date from os import getenv from github import InputGitAuthor from ogr.services.github import GithubService from ogr.abstract import PullRequest copr = Client.create_from_config_file() service = GithubService(token=getenv("GITHUB_TOKEN")) project = service.get_project(repo="hello-world", namespace="packit") user = InputGitAuthor(name="Release Bot", email="*****@*****.**") class Trigger(str, enum.Enum): comment = "comment" pr_opened = "pr_opened" push = "push" class Testcase: def __init__(self, pr: PullRequest = None, trigger: Trigger = Trigger.pr_opened):
def github_service(self): if self._github_service is None: self._github_service = GithubService( token=self.config.github_token) return self._github_service