def api_instance(upstream_and_remote, distgit_and_remote):
u, _ = upstream_and_remote
d, _ = distgit_and_remote
c = get_test_config()
api = get_packit_api(config=c, local_project=LocalProject(working_dir=Path.cwd()))
return u, d, api
def update(
config,
dist_git_path,
dist_git_branch,
force_new_sources,
local_content,
path_or_url,
version,
):
"""
Release current upstream release into Fedora
PATH_OR_URL argument is a local path or a URL to the upstream git repository,
it defaults to the current working directory
VERSION argument is optional, the latest upstream version
will be used by default
"""
api = get_packit_api(
config=config, dist_git_path=dist_git_path, local_project=path_or_url
)
api.sync_release(
dist_git_branch,
use_local_content=local_content,
version=version,
force_new_sources=force_new_sources,
)
def mock(
config, upstream_ref, release_suffix, default_release_suffix, root, path_or_url
):
"""
Build RPMs in mock using content of the upstream repository.
PATH_OR_URL argument is a local path or a URL to the upstream git repository,
it defaults to the current working directory.
"""
api = get_packit_api(config=config, local_project=path_or_url)
release_suffix = ChangelogHelper.resolve_release_suffix(
api.package_config, release_suffix, default_release_suffix
)
if not config.srpm_path:
config.srpm_path = api.create_srpm(
upstream_ref=upstream_ref,
srpm_dir=api.up.local_project.working_dir,
release_suffix=release_suffix,
)
rpm_paths = api.run_mock_build(root=root, srpm_path=config.srpm_path)
logger.info("RPMs:")
for path in rpm_paths:
logger.info(f" * {path}")
def create_update(
config, dist_git_branch, koji_build, update_notes, update_type, path_or_url
):
"""
Create a bodhi update for the selected upstream project
PATH_OR_URL argument is a local path or a URL to the upstream git repository,
it defaults to the current working directory
"""
api = get_packit_api(config=config, local_project=path_or_url)
default_dg_branch = api.dg.local_project.git_project.default_branch
dist_git_branch = dist_git_branch or default_dg_branch
branches_to_update = get_branches(
*dist_git_branch.split(","), default_dg_branch=default_dg_branch
)
click.echo(
f"Creating Bodhi update for the following branches: {', '.join(branches_to_update)}"
)
if branches_to_update:
click.echo("Please provide Bodhi username and password when asked for.")
for branch in branches_to_update:
api.create_update(
koji_builds=koji_build,
dist_git_branch=branch,
update_notes=update_notes,
update_type=update_type,
)
def sync_from_downstream(
config,
dist_git_branch,
upstream_branch,
no_pr,
path_or_url,
fork,
remote,
exclude,
force,
):
"""
Copy synced files from Fedora dist-git into upstream by opening a pull request.
PATH_OR_URL argument is a local path or a URL to the upstream git repository,
it defaults to the current working directory
"""
api = get_packit_api(config=config, local_project=path_or_url)
api.sync_from_downstream(
dist_git_branch,
upstream_branch,
no_pr=no_pr,
fork=fork,
remote_name=remote,
exclude_files=exclude,
force=force,
)
def sync_from_downstream(
config,
dist_git_branch,
upstream_branch,
no_pr,
path_or_url,
fork,
remote_to_push,
exclude,
force,
):
"""
Copy synced files from Fedora dist-git into upstream by opening a pull request.
PATH_OR_URL argument is a local path or a URL to the upstream git repository,
it defaults to the current working directory
"""
api = get_packit_api(config=config, local_project=path_or_url)
default_dg_branch = api.dg.local_project.git_project.default_branch
dist_git_branch = dist_git_branch or default_dg_branch
branches_to_sync = get_branches(
*dist_git_branch.split(","), default_dg_branch=default_dg_branch
)
click.echo(f"Syncing from the following branches: {', '.join(branches_to_sync)}")
for branch in branches_to_sync:
api.sync_from_downstream(
dist_git_branch=branch,
upstream_branch=upstream_branch,
no_pr=no_pr,
fork=fork,
remote_name=remote_to_push,
exclude_files=exclude,
force=force,
)
def srpm(
config,
output,
path_or_url,
upstream_ref,
bump,
release_suffix,
default_release_suffix,
):
"""
Create new SRPM (.src.rpm file) using content of the upstream repository.
PATH_OR_URL argument is a local path or a URL to the upstream git repository,
it defaults to the current working directory
"""
api = get_packit_api(config=config, local_project=path_or_url)
release_suffix = ChangelogHelper.resolve_release_suffix(
api.package_config,
release_suffix,
default_release_suffix,
)
srpm_path = api.create_srpm(
output_file=output,
upstream_ref=upstream_ref,
bump_version=bump,
release_suffix=release_suffix,
)
logger.info(f"SRPM: {srpm_path}")
def update(
config,
dist_git_path,
dist_git_branch,
force_new_sources,
no_pr,
local_content,
path_or_url,
upstream_ref,
version,
remote, # click introspects this in LocalProjectParameter
force,
):
"""
Release current upstream release into Fedora
PATH_OR_URL argument is a local path or a URL to the upstream git repository,
it defaults to the current working directory
VERSION argument is optional, the latest upstream version
will be used by default
"""
api = get_packit_api(config=config,
dist_git_path=dist_git_path,
local_project=path_or_url)
api.sync_release(
dist_git_branch,
use_local_content=local_content,
version=version,
force_new_sources=force_new_sources,
upstream_ref=upstream_ref,
create_pr=not no_pr,
force=force,
)
def copr_build(
config,
nowait,
owner,
project,
targets,
description,
instructions,
upstream_ref,
path_or_url,
):
"""
Build selected upstream project in COPR.
PATH_OR_URL argument is a local path or a URL to the upstream git repository,
it defaults to the current working directory.
"""
api = get_packit_api(config=config, local_project=path_or_url)
default_project_name = f"packit-cli-{path_or_url.repo_name}-{path_or_url.ref}"
targets_to_build = get_build_targets(
*targets.split(","), default="fedora-rawhide-x86_64"
)
build_id, repo_url = api.run_copr_build(
project=project or default_project_name,
chroots=list(targets_to_build),
owner=owner,
description=description,
instructions=instructions,
upstream_ref=upstream_ref,
)
click.echo(f"Build id: {build_id}, repo url: {repo_url}")
if not nowait:
api.watch_copr_build(build_id=build_id, timeout=60 * 60 * 2)
def init(
config,
path_or_url,
force,
upstream_url,
upstream_ref,
fedora_package,
centos_package,
dist_git_branch,
dist_git_path: Optional[str],
):
"""
Initiate a repository to start using packit.
If you specify --upstream-url, then a source-git repository is made,
otherwise only configuration file packit.yaml is created.
To learn more about source-git, please check
https://packit.dev/docs/source-git/
"""
working_dir = path_or_url.working_dir
config_path = get_existing_config(working_dir)
if config_path:
if not force:
raise PackitException(
f"Packit config {config_path} already exists."
" If you want to regenerate it use `packit init --force`")
else:
# Use default name
config_path = working_dir / ".packit.yaml"
if fedora_package or centos_package or dist_git_branch or dist_git_path:
# we're doing a source-git repo
logger.warning(
"Generating source-git repositories is experimental, "
"please give us feedback if it does things differently than you expect."
)
api = get_packit_api(config=config,
local_project=path_or_url,
load_packit_yaml=False)
dg_path = Path(dist_git_path) if dist_git_path else None
api.create_sourcegit_from_upstream(
upstream_url=upstream_url,
upstream_ref=upstream_ref,
dist_git_path=dg_path,
dist_git_branch=dist_git_branch,
fedora_package=fedora_package,
centos_package=centos_package,
)
return
template_data = {
"upstream_package_name": path_or_url.repo_name,
"downstream_package_name": path_or_url.repo_name,
}
generate_config(config_file=config_path,
write_to_file=True,
template_data=template_data)
def push_updates(update_alias, config, path_or_url):
"""
Find all Bodhi updates that have been in testing for more than 'Stable days' (7 by default)
and push them to stable.
"""
api = get_packit_api(config=config, local_project=path_or_url)
api.push_updates(update_alias)
def dump_cfg(self):
logger.info(f"Dumping new version of {self.pkg_cfg_path}")
logger.info(self.pkg_cfg)
with open(self.pkg_cfg_path, 'w') as pcf:
yaml.safe_dump(self.pkg_cfg, pcf)
# reload packit API
self.packit_api = get_packit_api(
config=self.packit_cfg, local_project=self.packit_local_project)
def test_srpm_on_example(example_repo):
c = get_test_config()
api = get_packit_api(
config=c, local_project=LocalProject(working_dir=str(example_repo)))
with cwd(example_repo):
path = api.create_srpm()
assert path.exists()
build_srpm(path)
def test_url_is_downstream():
c = get_test_config()
api = get_packit_api(
config=c,
local_project=LocalProject(git_url="https://src.fedoraproject.org/rpms/packit"),
)
assert api.downstream_local_project
assert not api.upstream_local_project
def status(config, path_or_url):
"""
Display status
"""
api = get_packit_api(config=config, local_project=path_or_url)
api.status()
def test_url_is_upstream():
c = get_test_config()
api = get_packit_api(
config=c,
local_project=LocalProject(git_url="https://github.com/packit/ogr"),
)
assert api.upstream_local_project
assert not api.downstream_local_project
def test_is_downstream(distgit_and_remote):
downstream, _ = distgit_and_remote
c = get_test_config()
api = get_packit_api(config=c,
local_project=LocalProject(working_dir=downstream))
assert api.downstream_local_project
assert not api.upstream_local_project
assert api.downstream_local_project.working_dir == downstream
def srpm(config, output, path_or_url):
"""
Create new SRPM (.src.rpm file) using content of the upstream repository.
PATH_OR_URL argument is a local path or a URL to the upstream git repository,
it defaults to the current working directory
"""
api = get_packit_api(config=config, local_project=path_or_url)
srpm_path = api.create_srpm(output_file=output)
logger.info("SRPM: %s", srpm_path)
def run_srpm(self):
try:
packit_api = get_packit_api(
config=packit_conf,
local_project=LocalProject(git.Repo(self.src_package_dir)),
)
self.srpm_path = packit_api.create_srpm(
srpm_dir=self.src_package_dir)
except Exception as e:
self.result["error"] = f"SRPMError: {e}"
def local_build(config, path_or_url, upstream_ref):
"""
Create RPMs using content of the upstream repository.
PATH_OR_URL argument is a local path or a URL to the upstream git repository,
it defaults to the current working directory
"""
api = get_packit_api(config=config, local_project=path_or_url)
rpm_paths = api.create_rpms(upstream_ref=upstream_ref)
logger.info("RPMs:")
for path in rpm_paths:
logger.info(f" * {path}")
def build(config, dist_git_path, dist_git_branch, scratch, path_or_url):
"""
Build selected upstream project in Fedora.
Packit goes to dist-git and performs `fedpkg build` for the selected branch.
PATH_OR_URL argument is a local path or a URL to the upstream git repository,
it defaults to the current working directory
"""
api = get_packit_api(config=config,
dist_git_path=dist_git_path,
local_project=path_or_url)
api.build(dist_git_branch, scratch=scratch)
def status(config, path_or_url):
"""
Display status.
\b
- latest downstream pull requests
- versions from all downstream branches
- latest upstream releases
- latest builds in Koji
- latest updates in Bodhi
"""
api = get_packit_api(config=config, local_project=path_or_url)
api.status()
def copr_build(
config,
nowait,
owner,
project,
targets,
description,
instructions,
list_on_homepage,
preserve_project,
upstream_ref,
additional_repos,
request_admin_if_needed,
path_or_url,
):
"""
Build selected upstream project in COPR.
PATH_OR_URL argument is a local path or a URL to the upstream git repository,
it defaults to the current working directory.
"""
api = get_packit_api(config=config, local_project=path_or_url)
if not project:
logger.debug("COPR project name was not passed via CLI.")
project = f"packit-cli-{path_or_url.repo_name}-{path_or_url.ref}"
if isinstance(api.package_config, PackageConfig):
project = api.package_config.get_copr_build_project_value()
logger.info(f"Using COPR project name = {project}")
targets_to_build = get_build_targets(*targets.split(","),
default="fedora-rawhide-x86_64")
additional_repos_list: Optional[List[str]] = additional_repos.split(
",") if additional_repos else None
build_id, repo_url = api.run_copr_build(
project=project,
chroots=list(targets_to_build),
owner=owner,
description=description,
instructions=instructions,
upstream_ref=upstream_ref,
list_on_homepage=list_on_homepage,
preserve_project=preserve_project,
additional_repos=additional_repos_list,
request_admin_if_needed=request_admin_if_needed,
)
click.echo(f"Build id: {build_id}, repo url: {repo_url}")
if not nowait:
api.watch_copr_build(build_id=build_id, timeout=60 * 60 * 2)
def build(
config,
dist_git_path,
dist_git_branch,
from_upstream,
scratch,
nowait,
path_or_url,
koji_target,
):
"""
Build selected upstream project in Fedora.
By default, packit checks out the respective dist-git repository and performs
`fedpkg build` for the selected branch. With `--from-upstream`, packit creates a SRPM
out of the current checkout and sends it to koji.
PATH_OR_URL argument is a local path or a URL to the upstream git repository,
it defaults to the current working directory
"""
api = get_packit_api(config=config,
dist_git_path=dist_git_path,
local_project=path_or_url)
branches_to_build = get_branches(*dist_git_branch.split(","),
default="master")
click.echo(
f"Building for the following branches: {', '.join(branches_to_build)}")
for branch in branches_to_build:
try:
out = api.build(
dist_git_branch=branch,
scratch=scratch,
nowait=nowait,
koji_target=koji_target,
from_upstream=from_upstream,
)
except PackitCommandFailedError as ex:
logs_stdout = "\n>>> ".join(ex.stdout_output.strip().split("\n"))
logs_stderr = "\n!!! ".join(ex.stderr_output.strip().split("\n"))
click.echo(
f"Build for branch '{branch}' failed. \n"
f">>> {logs_stdout}\n"
f"!!! {logs_stderr}\n",
err=True,
)
else:
if out:
print(ensure_str(out))
def create_update(config, dist_git_branch, koji_build, update_notes,
update_type, path_or_url):
"""
Create a bodhi update for the selected upstream project
PATH_OR_URL argument is a local path or a URL to the upstream git repository,
it defaults to the current working directory
"""
api = get_packit_api(config=config, local_project=path_or_url)
api.create_update(
koji_builds=koji_build,
dist_git_branch=dist_git_branch,
update_notes=update_notes,
update_type=update_type,
)
def copr_build(config, nowait, owner, project, targets, path_or_url):
"""
Build selected upstream project in COPR.
PATH_OR_URL argument is a local path or a URL to the upstream git repository,
it defaults to the current working directory.
"""
api = get_packit_api(config=config, local_project=path_or_url)
default_project_name = f"packit-cli-{path_or_url.repo_name}-{path_or_url.ref}"
build_id, repo_url = api.run_copr_build(project=project
or default_project_name,
chroots=targets.split(","),
owner=owner)
click.echo(f"Build id: {build_id}, repo url: {repo_url}")
if not nowait:
api.watch_copr_build(build_id=build_id, timeout=60 * 60 * 2)
def srpm(
config,
output,
path_or_url,
upstream_ref,
remote, # click introspects this in LocalProjectParameter
):
"""
Create new SRPM (.src.rpm file) using content of the upstream repository.
PATH_OR_URL argument is a local path or a URL to the upstream git repository,
it defaults to the current working directory
"""
api = get_packit_api(config=config, local_project=path_or_url)
srpm_path = api.create_srpm(output_file=output, upstream_ref=upstream_ref)
logger.info(f"SRPM: {srpm_path}")
def test_get_api(tmp_path, remotes, package_config, is_upstream):
repo = tmp_path / "project_repo"
repo.mkdir(parents=True, exist_ok=True)
initiate_git_repo(repo, remotes=remotes)
flexmock(utils).should_receive("get_local_package_config").and_return(
package_config)
c = get_test_config()
api = get_packit_api(config=c,
local_project=LocalProject(working_dir=str(repo)))
if is_upstream:
assert api.upstream_local_project
else:
flexmock(PackitAPI).should_receive("_run_kinit").once()
assert api.downstream_local_project
assert api.dg
def propose_downstream(
config,
dist_git_path,
dist_git_branch,
force_new_sources,
pr,
local_content,
path_or_url,
upstream_ref,
version,
force,
):
"""
Land a new upstream release in Fedora.
PATH_OR_URL argument is a local path or a URL to the upstream git repository,
it defaults to the current working directory
VERSION argument is optional, the latest upstream version
will be used by default
"""
api = get_packit_api(config=config,
dist_git_path=dist_git_path,
local_project=path_or_url)
if pr is None:
pr = api.package_config.create_pr
branches_to_update = get_dg_branches(api, dist_git_branch)
click.echo(
f"Proposing update of the following branches: {', '.join(branches_to_update)}"
)
for branch in branches_to_update:
api.sync_release(
dist_git_branch=branch,
use_local_content=local_content,
version=version,
force_new_sources=force_new_sources,
upstream_ref=upstream_ref,
create_pr=pr,
force=force,
)
def _run(self):
self.clone_repo()
self.load_packit_config()
# try running status
self.packit_api = get_packit_api(
config=self.packit_cfg, local_project=self.packit_local_project
)
if self.is_onboared():
self.result["skipped"] = True
logger.info(
f"Project already has a branch {ONBOARD_BRANCH_NAME} "
f"in {WHOAMI} namespace. Skipping."
)
return
self.announce_operation("Getting status")
self.packit_api.status()
self.packit_local_project.git_repo.create_head(ONBOARD_BRANCH_NAME).checkout()
up_spec = self.get_upstream_spec()
if up_spec and os.path.exists(up_spec):
self.announce_operation("Building srpm with upstream spec")
self.result["downstream_spec_used"] = False
self.build_srpm()
else:
self.result["downstream_spec_used"] = True
down_spec = self.get_spec_from_packit_config()
self.announce_operation("Building srpm with downstream spec")
self.get_downstream_spec(dest=down_spec)
self.build_srpm()
self.enable_copr_builds()
if (
self.result["already_had_packit_conf"]
and self.result["already_copr_enabled"]
):
logger.info("Repo had already copr enabled in packit")
return
self.push_and_create_pr()
