public inbox for git-commits@fedoraproject.org
help / color / mirror / Atom feed
From: Major Hayden <major@redhat.com>
To: git-commits@fedoraproject.org
Subject: [rpms/python-oci] rawhide: chore: add update-oci-pair agent skill
Date: Fri, 06 Nov 2026 22:13:09 GMT	[thread overview]
Message-ID: <179400318908.1.10491828433503862838.rpms-python-oci-c274f5b224f4@fedoraproject.org> (raw)

            A new commit has been pushed.

            Repo   : rpms/python-oci
            Branch : rawhide
            Commit : c274f5b224f4b12baed64af1998acfeaacba7199
            Author : Major Hayden <major@redhat.com>
            Date   : 2026-11-06T16:12:05-06:00
            Stats  : +644/-0 in 1 file(s)
            URL    : https://src.fedoraproject.org/rpms/python-oci/c/c274f5b224f4b12baed64af1998acfeaacba7199?branch=rawhide

            Log:
            chore: add update-oci-pair agent skill

- Document the paired python-oci and oci-cli Rawhide update workflow in one place: Pagure PR merging over git, paired mockbuild validation with a local SDK repository, side-tag releases, and the Bodhi grouped update.

- Record the already-fixed six and python-pkcs11 dependency failures so they are not re-diagnosed.

Signed-off-by: Major Hayden <major@redhat.com>

---
diff --git a/.agents/skills/update-oci-pair/SKILL.md b/.agents/skills/update-oci-pair/SKILL.md
new file mode 100644
index 0000000..e54da77
--- /dev/null
+++ b/.agents/skills/update-oci-pair/SKILL.md
@@ -0,0 +1,644 @@
+---
+name: update-oci-pair
+description: Execute a coordinated Fedora Rawhide update for the python-oci SDK and oci-cli packages.
+---
+
+# Update the Python OCI package pair
+
+Use this skill for a paired Fedora Rawhide update of:
+
+1. `python-oci`, the OCI Python SDK package.
+2. `oci-cli`, the CLI package that consumes that SDK.
+
+The goal is to land compatible, buildable updates in Rawhide, with the SDK
+updated first and the CLI updated second.
+
+## Scope and stop conditions
+
+Before changing anything, record:
+
+- the requested upstream SDK version;
+- the requested upstream CLI version;
+- the exact OCI SDK version required or pinned by `oci-cli`;
+- the Fedora Rawhide branch and Koji target being used; and
+- the two dist-git repository locations.
+
+Stop without making package changes when any of the following is true:
+
+- either target upstream version or the CLI's exact SDK pin cannot be
+  established from authoritative release metadata or packaging metadata;
+- the SDK target is lower than the exact SDK pin required by `oci-cli`;
+- either repository cannot be identified as the correct Fedora dist-git
+  repository, or its checkout is not clean and disposable;
+- an existing Packit update or pull request already covers the target and its
+  branch cannot safely be reused;
+- the spec, source, local build, Packit build, or Koji build fails without a
+  resolved cause; or
+- both expected package NVRs are not present in the Rawhide tag.
+
+Equal or newer SDK versions are allowed: require
+`sdk_target_version >= oci_cli_sdk_pin`.
+Do not weaken, rewrite, or silently reinterpret an exact pin to bypass this
+gate.
+
+Do not use secrets, paste credentials, or expose access tokens in commands,
+logs, reports, or pull-request comments.
+
+## Required pre-update sequence
+
+Complete these three steps before starting any new version-update work.
+This user-confirmed sequence first incorporates already-reviewed Rawhide work,
+then verifies the two checkouts, and finally tests the pair against the SDK
+artifact that the CLI will consume.
+
+### Step 1: Merge existing Pagure PRs
+
+Inspect the existing Pagure pull requests for `python-oci` and `oci-cli`.
+Merge only the PR whose base branch is `rawhide` for each package, and only
+after its checks and review requirements are satisfied.
+Do not merge a PR targeting another Fedora branch, and do not create a
+replacement PR when the existing Rawhide PR is the intended update.
+Use the authenticated Pagure web interface or the repository's configured
+Pagure tooling without putting credentials or tokens in commands or reports.
+
+For orientation, these are the two expected pull-request pages:
+
+```sh
+PAGURE_HOST='https://src.fedoraproject.org'
+printf '%s\n' \
+  "$PAGURE_HOST/rpms/python-oci/pull-requests" \
+  "$PAGURE_HOST/rpms/oci-cli/pull-requests"
+```
+
+List open PRs and their head commits with one API call per package, then
+merge through git instead of the web UI:
+
+```sh
+curl -s "https://src.fedoraproject.org/api/0/rpms/python-oci/pull-requests?status=Open" |
+  jq '[.requests[] | {id, title, commit_stop}]'
+```
+
+```sh
+cd "$SDK_DISTGIT_DIR"
+git fetch origin "refs/pull/<PR_ID>/head"
+git log -1 --format='%H %s' FETCH_HEAD     # must equal the PR commit_stop
+git log -1 --format='%H' FETCH_HEAD^       # must equal the current rawhide tip
+git merge --ff-only FETCH_HEAD
+git push origin rawhide
+```
+
+Pagure never auto-closes a PR whose commits were pushed directly, and its
+API stays stale. Do not wait for an auto-close, scrape PR HTML, or study
+Pagure internals. After pushing, tell the user to click Merge on each PR
+page once: Pagure answers "Nothing to do, changes were already merged" and
+still records the PR as Merged with the user as the merger.
+
+If no appropriate existing Rawhide PR exists for one package, record that fact
+and continue with the normal update workflow for that package.
+If an existing Rawhide PR cannot be merged because its checks, target branch,
+or ownership are unclear, stop before proposing new version changes.
+
+### Step 2: Pull the confirmed Rawhide checkouts
+
+After the applicable PRs are merged, use the user-confirmed checkout
+directories below.
+Do not substitute an unverified `oci-cli` path.
+Require clean checkouts before pulling and fast-forward only the `rawhide`
+branch:
+
+```sh
+SDK_DISTGIT_DIR="$HOME/git/fedora/python-oci"
+CLI_DISTGIT_DIR="$HOME/git/fedora/oci-cli"
+
+for repo in "$SDK_DISTGIT_DIR" "$CLI_DISTGIT_DIR"; do
+  test -d "$repo/.git" || {
+    printf 'Missing git checkout: %s\n' "$repo" >&2
+    exit 1
+  }
+  # Ignore untracked files: mockbuild.log, results directories, and the
+  # .agents/ skill checkout are permanent local fixtures in these trees.
+  test -z "$(git -C "$repo" status --porcelain -uno)" || {
+    printf 'Checkout has tracked changes: %s\n' "$repo" >&2
+    exit 1
+  }
+  git -C "$repo" switch rawhide
+  git -C "$repo" pull --ff-only origin rawhide
+done
+```
+
+Verify the remotes after pulling and stop if either checkout is not the
+expected Fedora dist-git repository.
+
+### Step 3: Build the SDK locally and use it for the CLI mockbuild
+
+Run the SDK mockbuild first and capture all output in `mockbuild.log`:
+
+```sh
+cd "$SDK_DISTGIT_DIR"
+set -o pipefail
+if ! fedpkg mockbuild 2>&1 | tee mockbuild.log; then
+  printf 'python-oci mockbuild failed; inspect %s/mockbuild.log\n' "$PWD" >&2
+  exit 1
+fi
+```
+
+Set `SDK_MOCK_RESULTS_DIR` to the result directory reported by the SDK
+mockbuild, then create a fresh local DNF repository from its produced RPMs.
+`fedpkg mockbuild` writes RPMs to `results_<name>/<version>/<release>/`
+inside the checkout, for example `results_python-oci/2.190.0/2.fc46`.
+The result directory must be explicit and bounded to this build:
+
+```sh
+SDK_MOCK_RESULTS_DIR='/absolute/path/to/python-oci/mock-results'
+test -d "$SDK_MOCK_RESULTS_DIR" || exit 1
+test -n "$(find "$SDK_MOCK_RESULTS_DIR" -maxdepth 1 -type f -name '*.rpm' -print -quit)" || {
+  printf 'No SDK RPMs found in %s\n' "$SDK_MOCK_RESULTS_DIR" >&2
+  exit 1
+}
+
+mkdir -p "$HOME/.cache/opencode-tmp/oci-pair"
+LOCAL_REPO_DIR="$(realpath -e "$(mktemp -d "$HOME/.cache/opencode-tmp/oci-pair/oci-sdk-repo.XXXXXX")")"
+find "$SDK_MOCK_RESULTS_DIR" -maxdepth 1 -type f -name '*.rpm' \
+  -exec cp -- {} "$LOCAL_REPO_DIR"/ \;
+createrepo_c "$LOCAL_REPO_DIR"
+```
+
+The local repository is required because a normal `oci-cli` build resolves
+dependencies from remote Fedora repositories, which do not yet contain the
+newly built SDK from this paired update.
+Using the local DNF repository makes the exact SDK RPM produced by the SDK
+mockbuild available to the CLI mockbuild and verifies the pair before any
+remote Rawhide build is triggered.
+
+Run the CLI mockbuild with Mock's `--addrepo` forwarded through `fedpkg`, and
+capture its complete output in its own `mockbuild.log`:
+
+```sh
+cd "$CLI_DISTGIT_DIR"
+set -o pipefail
+if ! fedpkg mockbuild -- --addrepo "$LOCAL_REPO_DIR" 2>&1 | tee mockbuild.log; then
+  printf 'oci-cli mockbuild failed; inspect %s/mockbuild.log\n' "$PWD" >&2
+  exit 1
+fi
+```
+
+The value passed to `--addrepo` must be the absolute path printed by
+`realpath`, not a relative path or a remote repository URL.
+Diagnose either log before proceeding.
+
+## 4. Discover versions and repository locations
+
+Ask the requester for both upstream target versions when they are not already
+provided.
+Then verify them against the upstream release tags and the current Fedora
+packaging metadata.
+For example, with explicit, user-confirmed paths:
+
+```sh
+SDK_UPSTREAM_URL='https://github.com/oracle/oci-python-sdk.git'
+CLI_UPSTREAM_URL='https://github.com/oracle/oci-cli.git'
+SDK_TARGET_VERSION='2.181.0'       # Set from the requested release.
+CLI_TARGET_VERSION='3.XX.XX'       # Set from the requested release.
+
+git ls-remote --tags --refs "$SDK_UPSTREAM_URL" 'refs/tags/v*' |
+  sort -V | tail -n 5
+git ls-remote --tags --refs "$CLI_UPSTREAM_URL" 'refs/tags/v*' |
+  sort -V | tail -n 5
+```
+
+The paths in Step 2 are authoritative for this workflow.
+Confirm the selected remotes, rather than relying only on directory names.
+Do not overwrite the confirmed `SDK_DISTGIT_DIR` and `CLI_DISTGIT_DIR` values
+from Step 2 with placeholder paths:
+
+```sh
+for repo in "$SDK_DISTGIT_DIR" "$CLI_DISTGIT_DIR"; do
+  git -C "$repo" rev-parse --show-toplevel
+  git -C "$repo" remote -v
+done
+```
+
+Discover the CLI's exact SDK pin from its spec and upstream packaging files,
+not from an approximate current version:
+
+```sh
+rg -n -i \
+  --glob '*.spec' --glob 'pyproject.toml' --glob 'setup.py' \
+  'oci|python3dist\(oci\)|==|exact|pin' \
+  "$CLI_DISTGIT_DIR"
+```
+
+Normalize the discovered versions for comparison and explicitly record:
+`SDK_TARGET_VERSION`, `CLI_TARGET_VERSION`, and `OCI_CLI_SDK_PIN`.
+Block if `SDK_TARGET_VERSION` is below `OCI_CLI_SDK_PIN`; allow equality or a
+newer SDK only after checking that the CLI accepts the newer version.
+
+## 5. Inspect Packit work before creating anything
+
+Inspect open Packit pull requests and jobs for both packages before creating a
+branch, pull request, or duplicate build.
+Use the project's configured Packit dashboard or its installed CLI, and inspect
+the dist-git hosting service's open pull requests for the `rawhide` branch.
+For example, where these commands are available in the local setup:
+
+```sh
+# Packit job history per package (no packit CLI needed; plain API calls):
+curl -s 'https://prod.packit.dev/api/koji-builds?project_url=https://src.fedoraproject.org/rpms/python-oci' |
+  jq -r '.[] | "\(.build_submitted_time | todate) | \(.status) | task \(.task_id)"' | head -5
+curl -s 'https://prod.packit.dev/api/koji-builds?project_url=https://src.fedoraproject.org/rpms/oci-cli' |
+  jq -r '.[] | "\(.build_submitted_time | todate) | \(.status) | task \(.task_id)"' | head -5
+```
+
+Skip the `packit` CLI: `packit status --repo` is not a valid option and the
+positional form can fail against the service API. Use the queries above and
+the Pagure API calls from Step 1 instead.
+
+If the hosting service is not GitLab, use its native read-only pull-request
+listing instead of guessing a URL or repository path.
+Compare open work by package, Rawhide target, upstream version, source commit,
+and Packit job state.
+
+If an appropriate Packit PR branch already exists, use that branch and update
+it in place after confirming its base and ownership.
+Do not create a second PR for the same target, force-push over unrelated work,
+or close an existing PR merely to start over.
+
+## 6. Update `python-oci` first
+
+Use the existing Fedora spec structure and comments as the authority for the
+SDK package.
+Change only the version, sources, patches, and other release-specific inputs
+needed for the target release.
+Preserve Fedora packaging conventions and existing downstream fixes.
+Never manually edit `%autorelease` or `%autochangelog`.
+Let the Fedora tooling generate release and changelog entries.
+
+On a new or reused Packit branch, use the normal dist-git source workflow.
+The exact source command depends on the repository's existing conventions;
+for example:
+
+```sh
+cd "$SDK_DISTGIT_DIR"
+# Edit the version/source inputs using the repository's established method.
+fedpkg new-sources '/path/to/verified/oci-python-sdk-source.tar.gz'
+git diff --check
+rpmspec -P python-oci.spec >/tmp/python-oci-expanded.spec
+```
+
+Review the diff for accidental changes to `%autorelease`, `%autochangelog`,
+generated files, unrelated patches, or source checksums.
+Commit or push only according to the existing Packit PR workflow, and retain
+the PR branch if Packit already created it.
+
+## 7. Update `oci-cli` second
+
+Do not update the CLI until the SDK target satisfies its exact pin and the SDK
+spec/source change has passed its local checks.
+Use the existing CLI spec conventions and preserve downstream patches.
+Again, do not manually edit `%autorelease` or `%autochangelog`.
+
+Apply the CLI version and source update on the existing Packit PR branch when
+one covers the target; otherwise use the repository's normal Packit branch
+workflow.
+Verify that the CLI's dependency metadata still expresses the intended exact
+SDK pin and that the selected SDK NVR satisfies it.
+
+```sh
+cd "$CLI_DISTGIT_DIR"
+# Edit only release-specific inputs according to the existing spec pattern.
+fedpkg new-sources '/path/to/verified/oci-cli-source.tar.gz'
+git diff --check
+rpmspec -P oci-cli.spec >/tmp/oci-cli-expanded.spec
+```
+
+## 8. Validate specs and build locally
+
+Run checks appropriate to the package and the repository's existing CI
+configuration.
+At minimum, expand both specs, check the diff, build source RPMs, and run the
+configured package tests in a Fedora-compatible build environment.
+Prefer `fedpkg`, `mock`, and repository-provided checks over ad hoc test
+commands:
+
+```sh
+for spec in "$SDK_DISTGIT_DIR"/*.spec "$CLI_DISTGIT_DIR"/*.spec; do
+  rpmspec -P "$spec" >/dev/null
+done
+
+cd "$SDK_DISTGIT_DIR"
+fedpkg srpm
+fedpkg local
+
+cd "$CLI_DISTGIT_DIR"
+fedpkg srpm
+fedpkg local
+```
+
+If local builds require a named mock configuration, set it explicitly and use
+the distribution-approved configuration:
+
+```sh
+MOCK_CONFIG='fedora-rawhide-x86_64'
+mock -r "$MOCK_CONFIG" --rebuild '/path/to/built/package.src.rpm'
+```
+
+Record failures with the complete, relevant command output and diagnose them
+before proceeding.
+
+## 9. Trigger and monitor Packit and Koji
+
+Trigger the repository's configured Packit job through the existing PR or the
+project's normal Packit command.
+Do not invent a second trigger if a job is already running.
+For the user-confirmed Rawhide release path, use one Koji side tag for both
+packages.
+Do not substitute the `rawhide` target for this sequence.
+
+### Rawhide side-tag release
+
+#### Side-tag collision and reuse
+
+A direct Rawhide push can cause Packit to create a different side tag and
+submit the same NVR.
+If a manual `fedpkg build --target` then fails with `Build already in
+progress`, do not retry it and do not create a duplicate build.
+Identify the successful Packit task and its actual side tag with
+`koji taskinfo -r`:
+
+```sh
+PACKIT_TASK_ID='copy-the-packit-task-id-from-the-rawhide-build'
+koji taskinfo -r "$PACKIT_TASK_ID"
+```
+
+Use that active Packit side tag, rather than the manually requested tag, for
+`koji wait-repo`, `koji list-tagged`, and the dependent `oci-cli` build.
+Record the manually requested but unused tag in the end report.
+
+Before requesting any side tag, check whether Packit already acted on the
+pushed commit; both packages configure `koji_build` jobs triggered on commit
+with `allowed_committers: mhayden` and the shared `oci-cli-releases`
+sidetag group:
+
+```sh
+koji list-builds --package=python-oci --state=BUILDING
+koji list-builds --package=python-oci | grep -F "$SDK_TARGET_VERSION"
+```
+
+A FAILED Packit build of the target version is free diagnosis, not a
+blocker: find the failed `buildArch` task with `koji taskinfo -r`, fetch its
+logs with `koji download-logs`, and read `root.log` for
+`No match for argument` lines to identify unpackaged dependencies before
+running any mockbuild.
+
+Packit usually reacts to a rawhide push within about a minute, but it may
+never react (observed on a follow-up fix push). Give it at most five
+minutes, then build manually into the existing Packit group side tag found
+in the earlier task output or `koji list-sidetags`; manual submission is
+collision-safe because Koji rejects a late duplicate from Packit.
+
+Verify Koji authentication before submitting anything:
+
+```sh
+koji moshimoshi
+```
+
+Read-only Koji commands work unauthenticated; builds need a fresh
+`mhayden@FEDORAPROJECT.ORG` Kerberos ticket. If the ticket is expired, ask
+the user to run `kinit mhayden@FEDORAPROJECT.ORG` and retry; renewal with
+`kinit -R` fails once the ticket fully expires.
+
+1. Request the side tag from the `python-oci` checkout and save the returned
+   value exactly as printed.
+   Do not normalize, abbreviate, or reconstruct the side-tag name:
+
+   ```sh
+   cd "$SDK_DISTGIT_DIR"
+   if ! SIDE_TAG="$(fedpkg request-side-tag 2>side-tag-request.log)"; then
+     printf 'Unable to request a side tag; inspect %s/side-tag-request.log\n' "$PWD" >&2
+     exit 1
+   fi
+   test -n "$SIDE_TAG" || exit 1
+   printf '%s\n' "$SIDE_TAG" | tee side-tag.txt
+   ```
+
+2. Build `python-oci` into that exact side tag and retain the complete build
+   output.
+   Copy the successful task ID, task URL, and exact SDK NVR from the output
+   without changing them:
+
+   ```sh
+   SDK_BUILD_LOG="$SDK_DISTGIT_DIR/python-oci-${SIDE_TAG}-build.log"
+   set -o pipefail
+   if ! fedpkg build --target "$SIDE_TAG" 2>&1 | tee "$SDK_BUILD_LOG"; then
+     printf 'python-oci side-tag build failed; inspect %s\n' "$SDK_BUILD_LOG" >&2
+     exit 1
+   fi
+   SDK_TASK_ID='copy-the-successful-python-oci-task-id-from-the-build-output'
+   SDK_TASK_URL='copy-the-successful-python-oci-task-url-from-the-build-output'
+   SDK_NVR='copy-the-exact-python-oci-NVR-from-the-build-output'
+   ```
+
+3. Wait for the SDK repository and verify the SDK NVR is tagged before building
+   the CLI:
+
+   ```sh
+   koji wait-repo "$SIDE_TAG" --build="$SDK_NVR" --request
+   koji list-tagged "$SIDE_TAG" python-oci
+   koji list-tagged "$SIDE_TAG" python-oci | rg -F "$SDK_NVR"
+   ```
+
+   Stop if the exact SDK NVR is not visible in the side tag.
+
+4. Build `oci-cli` into the same side tag and retain its complete build output,
+   task ID, task URL, and exact CLI NVR:
+
+   ```sh
+   cd "$CLI_DISTGIT_DIR"
+   CLI_BUILD_LOG="$CLI_DISTGIT_DIR/oci-cli-${SIDE_TAG}-build.log"
+   set -o pipefail
+   if ! fedpkg build --target "$SIDE_TAG" 2>&1 | tee "$CLI_BUILD_LOG"; then
+     printf 'oci-cli side-tag build failed; inspect %s\n' "$CLI_BUILD_LOG" >&2
+     exit 1
+   fi
+   CLI_TASK_ID='copy-the-successful-oci-cli-task-id-from-the-build-output'
+   CLI_TASK_URL='copy-the-successful-oci-cli-task-url-from-the-build-output'
+   CLI_NVR='copy-the-exact-oci-cli-NVR-from-the-build-output'
+   ```
+
+5. Verify both Koji tasks succeeded and both exact NVRs are tagged in the same
+   side tag:
+
+   ```sh
+   koji taskinfo "$SDK_TASK_ID"
+   koji taskinfo "$CLI_TASK_ID"
+   koji list-tagged "$SIDE_TAG" python-oci | rg -F "$SDK_NVR"
+   koji list-tagged "$SIDE_TAG" oci-cli | rg -F "$CLI_NVR"
+   ```
+
+   Do not create or submit a Bodhi update automatically.
+   Stop and ask the user before creating a Bodhi update, even when both side-tag
+   builds and tag checks succeed.
+
+After both builds are tagged, first check whether Packit's `bodhi_update`
+job already created the grouped update; it reacts to builds landing in the
+`sidetag_group` side tag, including manually submitted ones, usually within
+minutes:
+
+```sh
+bodhi updates query --builds "$SDK_NVR"
+```
+
+If an update exists, verify its builds, bugs, type, `from_tag`, and
+`close_bugs`, then report it and skip manual creation entirely.
+
+Otherwise create the grouped update; use `--type enhancement` to match this
+pair's established update history:
+
+```sh
+bodhi updates new --from-tag <side-tag> --type enhancement --request testing --notes <release-summary> --bugs <sdk-bug>,<cli-bug> --close-bugs
+```
+
+Use `--from-tag` alone as the positional tag argument for the grouped update.
+Do not combine it with individual NVRs or add NVRs as extra positional
+arguments.
+The `--close-bugs` option requests automatic bug closure only when the update
+becomes stable; it does not close the bugs when the update is merely submitted
+to testing.
+
+The tickets from this run are an example only: `2487019` is the `python-oci`
+ticket and `2487018` is the `oci-cli` ticket.
+For every run, substitute the actual side tag, release summary, and bug IDs.
+Before executing Bodhi, show the user the fully substituted literal command,
+including the actual side tag and quoted release summary, and ask for explicit
+confirmation.
+Do not execute the command before that confirmation.
+
+#### Recovery: Bodhi update already exists
+
+If `bodhi updates new` returns `Update already exists using this side tag`, do
+not retry the command and do not create a duplicate update.
+Query Bodhi using both build NVRs and inspect the common existing update's side
+tag, builds, Bugzilla associations, and `close_bugs` setting:
+
+```sh
+bodhi updates query --builds "$SDK_NVR"
+bodhi updates query --builds "$CLI_NVR"
+```
+
+Record the matching update ID, URL, and status, and verify that its returned
+record contains the expected side tag, both NVRs, the expected Bugzilla ticket
+associations, and the intended `close_bugs` value.
+Do not edit an existing update until the workflow shows the proposed edit to
+the user and obtains explicit confirmation.
+
+The Bodhi CLI can also fail with a transient connection error
+(`RemoteDisconnected` or `Connection aborted`). Treat any such failure as an
+unknown state: query Bodhi by both NVRs before retrying, because Packit may
+have created the update in the meantime and each build can belong to only
+one update.
+
+Report the exact side tag, SDK and CLI NVRs, SDK and CLI task IDs, and both task
+URLs.
+
+For any explicitly authorized direct Koji build outside this side-tag release,
+use the explicit target and NVR/source RPM selected for that package:
+
+```sh
+KOJI_TARGET='rawhide'
+
+cd "$SDK_DISTGIT_DIR"
+fedpkg build --nowait --target "$KOJI_TARGET"
+
+cd "$CLI_DISTGIT_DIR"
+fedpkg build --nowait --target "$KOJI_TARGET"
+```
+
+Use the Packit job page, PR checks, and Koji task identifiers to monitor both
+packages.
+For example:
+
+```sh
+KOJI_TASK_ID='replace-with-task-id-from-koji-output'
+koji taskinfo "$KOJI_TASK_ID"
+koji watch-task "$KOJI_TASK_ID"
+```
+
+When a job fails, inspect the Packit job log and the Koji task/build logs for
+the first actionable error, then check the corresponding spec, dependency,
+source, or test before retrying.
+Do not paste private job URLs containing credentials or any access token into
+the report.
+
+### Example failure: undeclared `six` dependency
+
+This one is already fixed in rawhide (commit e4186cc); the pattern below is
+for newly undeclared dependencies.
+If the `python-oci` `%pyproject_check_import` check reports
+`ModuleNotFoundError: No module named 'six'`, the observed cause is that
+upstream imports `six` without declaring it.
+Remediate that specific packaging gap in `python-oci.spec` by adding both
+dependency declarations, with an explanatory comment:
+
+```spec
+# Upstream imports six without declaring it, so keep the build and runtime
+# dependencies explicit for the Fedora package.
+BuildRequires:  python3dist(six)
+...
+Requires:       python3dist(six)
+```
+
+Place `BuildRequires: python3dist(six)` with the other build requirements and
+`Requires: python3dist(six)` in the `python3-oci` package section.
+Preserve `%autorelease` and `%autochangelog`; do not replace or hand-edit
+either generated Fedora release mechanism.
+This is an example for this observed failure, not a universal dependency rule.
+
+After any spec change, rerun the full Step 3 sequence: SDK mockbuild,
+rebuild the local DNF repository from the new SDK RPMs with `createrepo_c`,
+then the CLI mockbuild.
+Do not retry `oci-cli` against a stale local repository or the remote
+repositories until the rebuilt SDK RPMs have been indexed by `createrepo_c`.
+
+### Already fixed: `python-pkcs11` dependency in 2.190.0
+
+Upstream 2.190.0 added `python-pkcs11==0.9.4` to `pyproject.toml`, but Fedora
+has no `python-pkcs11` package, so the Koji build failed dependency
+resolution. This is already fixed in rawhide by commit `77149df`
+(`fix(spec): drop unpackaged python-pkcs11 dependency`): a `sed` in `%prep`
+deletes the line from `pyproject.toml` (upstream guards the import behind
+try/except in `oci/auth/signers/__init__.py`, so only the PKCS#11 signers
+are unavailable), and `%pyproject_check_import` excludes
+`oci.auth.signers.pkcs11_signer`. Do not re-diagnose this failure; only check
+whether a new undeclared or unpackaged dependency appeared.
+
+## 10. Confirm Rawhide tags and report completion
+
+Determine the expected NVR for each successful build from Koji's build result,
+not by manually guessing a release number.
+For the side-tag release, confirm both exact NVRs are tagged in the side tag
+before reporting the release as ready for user approval:
+
+```sh
+SDK_EXPECTED_NVR='python-oci-<version>-<release>.fc<releasever>'
+CLI_EXPECTED_NVR='oci-cli-<version>-<release>.fc<releasever>'
+
+koji list-tagged "$SIDE_TAG" python-oci | rg -F "$SDK_EXPECTED_NVR"
+koji list-tagged "$SIDE_TAG" oci-cli | rg -F "$CLI_EXPECTED_NVR"
+```
+
+Completion of the side-tag release requires both exact expected NVRs, not
+merely successful builds or a successful Packit PR.
+Do not claim that the packages are in the main `rawhide` tag until the user has
+authorized the Bodhi update and that follow-up completes.
+
+Provide a concise end report containing:
+
+- SDK and CLI upstream versions, plus the exact CLI SDK pin;
+- the two dist-git branches or reused Packit PRs;
+- local validation performed and its result;
+- Packit and Koji job/build identifiers and outcomes;
+- the exact Rawhide side tag and both Koji task URLs;
+- the exact SDK and CLI NVRs confirmed in Rawhide; and
+- if an existing Bodhi update was found, its update ID, URL, and status;
+- whether Bodhi creation is awaiting explicit user approval;
+- any unresolved follow-up or explicit stop condition.

                 reply	other threads:[~2026-11-06 22:13 UTC|newest]

Thread overview: [no followups] expand[flat|nested]  mbox.gz  Atom feed

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=179400318908.1.10491828433503862838.rpms-python-oci-c274f5b224f4@fedoraproject.org \
    --to=major@redhat.com \
    --cc=git-commits@fedoraproject.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox