Compare commits
49
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
fc39293b9d
|
||
|
|
e83b8481b9 | ||
|
|
e4ecae6294
|
||
|
|
37b91db07b | ||
|
|
c30d821f7e
|
||
|
|
6ae688dcf4 | ||
|
|
78207c16be
|
||
|
|
efd50aee2f | ||
|
|
6dd473be25
|
||
|
|
1c8a7c57e5 | ||
|
|
abaebf50ff
|
||
|
|
c56e52d4cb | ||
|
|
09046d45b0
|
||
|
|
9e9e6c1fa5 | ||
|
|
45aaccd2a9 | ||
|
|
ab77962b6a | ||
|
|
d0792d60d6 | ||
|
|
72f5f4d4e7 | ||
|
|
00af9aae31 | ||
|
|
7e60372948 | ||
|
|
45bab9d960 | ||
|
|
f304afb0be | ||
|
|
f76b9f7a7c | ||
|
|
fdf62a2f5a | ||
|
|
94341ef481 | ||
|
|
2debeada5d | ||
|
|
6febeff590 | ||
|
|
8b58a45f35 | ||
|
|
fbe36d683d | ||
|
|
bd5ee3bec5 | ||
|
|
d4d6e97df0 | ||
|
|
c288a8864f | ||
|
|
9906c8f120 | ||
|
|
4dcf2c1891 | ||
|
|
cc30f599e6 | ||
|
|
05a2a5217a | ||
|
|
7d73ac90b6 | ||
|
|
edc1365ac9 | ||
|
|
0f33ddadf8 | ||
|
|
5e9bbb54ec | ||
|
|
5bcec90e33 | ||
|
|
a50b07d927 | ||
|
|
6318d90e96 | ||
|
|
a6fea661ff | ||
|
|
2894bae29a | ||
|
|
a14e8f9b24 | ||
|
|
83611872a3 | ||
|
|
30c4e0e85c | ||
|
|
f429d9f3c4 |
No files matched your search
+1
-34
@@ -4,9 +4,6 @@ parameters:
|
||||
run_rc_finalize_sweep:
|
||||
type: boolean
|
||||
default: false
|
||||
run_enrollment_reconcile:
|
||||
type: boolean
|
||||
default: false
|
||||
orbs:
|
||||
orb-tools: circleci/orb-tools@12.3
|
||||
shellcheck: circleci/shellcheck@3.2
|
||||
@@ -16,23 +13,6 @@ filters: &filters
|
||||
only: /.*/
|
||||
|
||||
jobs:
|
||||
enrollment-reconcile:
|
||||
docker:
|
||||
- image: cimg/python:3.12
|
||||
resource_class: small
|
||||
steps:
|
||||
- checkout
|
||||
- run:
|
||||
name: Install reconciliation tools
|
||||
command: |
|
||||
bash tools/install_reconcile_gh.sh
|
||||
python3 -m pip install --disable-pip-version-check PyYAML==6.0.3
|
||||
- run:
|
||||
name: Reconcile current QQQ branches
|
||||
no_output_timeout: 21m
|
||||
command: python3 tools/run_enrollment.py
|
||||
- store_artifacts:
|
||||
path: artifacts/enrollment
|
||||
rc-finalize-sweep:
|
||||
docker:
|
||||
- image: cimg/python:3.12
|
||||
@@ -48,10 +28,7 @@ jobs:
|
||||
workflows:
|
||||
lint-pack:
|
||||
when:
|
||||
not:
|
||||
or:
|
||||
- << pipeline.parameters.run_rc_finalize_sweep >>
|
||||
- << pipeline.parameters.run_enrollment_reconcile >>
|
||||
not: << pipeline.parameters.run_rc_finalize_sweep >>
|
||||
jobs:
|
||||
- orb-tools/lint:
|
||||
filters: *filters
|
||||
@@ -79,13 +56,3 @@ workflows:
|
||||
only: main
|
||||
tags:
|
||||
ignore: /.*/
|
||||
reconcile-enrollment:
|
||||
when: << pipeline.parameters.run_enrollment_reconcile >>
|
||||
jobs:
|
||||
- enrollment-reconcile:
|
||||
context: qqq-maven-registry-credentials
|
||||
filters:
|
||||
branches:
|
||||
only: main
|
||||
tags:
|
||||
ignore: /.*/
|
||||
@@ -61,7 +61,6 @@ jobs:
|
||||
python3 tests/test_reconcile_enrollment.py
|
||||
python3 tests/test_discover_enrollment.py
|
||||
python3 tests/test_finish_enrollment.py
|
||||
python3 tests/test_run_enrollment.py
|
||||
python3 tests/test_static_analysis_exit.py
|
||||
python3 tests/test_validate_standard.py
|
||||
python3 tests/test_voyage_profile.py
|
||||
|
||||
@@ -63,4 +63,6 @@ unnecessary rebuilds. Reports identify protection_mode=rulesets and the observed
|
||||
strict value. Unsupported organization-level rulesets, bypass actors and missing
|
||||
gates remain unresolved rather than being rewritten or ignored.
|
||||
|
||||
For classic protection with an empty push allowlist and admin enforcement disabled, the tool leaves the entire classic policy unchanged. After current-head gates pass, it creates a narrowly scoped active repository ruleset requiring app-bound setup and verify with no bypass actors. This enforces CI even for administrators without changing their existing branch access or locking all actors out. The ruleset retains the fleet freshness policy (strict=false); it does not weaken any existing classic policy. A same-named ruleset causes rejection rather than overwrite or duplication. Readback verifies the effective gates and unchanged classic protection; subsequent runs recognize the existing ruleset without writes.
|
||||
For classic protection, an empty push allowlist with admin enforcement disabled
|
||||
requires an explicit access-policy resolution before enabling admin enforcement.
|
||||
The tool rejects that case before any writes to avoid locking every actor out.
|
||||
@@ -50,31 +50,22 @@ python tools/reconcile_enrollment.py --targets remote-targets.json --orb-version
|
||||
python tools/reconcile_enrollment.py --targets remote-targets.json --orb-version 0.8 --output result.json --apply
|
||||
```
|
||||
|
||||
Use existing `gh` authentication with repository write access. The coordinator
|
||||
never installs credentials or changes authentication. Every target is inspected
|
||||
at an immutable head and validated before any remote mutation. No repository
|
||||
clone, SSH key or local signing key is required. A moved target stops submission;
|
||||
refresh the plan instead of overwriting it.
|
||||
Use existing `gh` authentication, GitHub SSH access, Git author identity and a
|
||||
working Git signing configuration. The coordinator never installs credentials
|
||||
or changes authentication. Every target is inspected at an immutable head and
|
||||
validated before any remote mutation. Only changed targets are cloned. A moved
|
||||
target stops submission; refresh the plan instead of overwriting it.
|
||||
|
||||
An automation branch derives from the source commit and proposed declarations.
|
||||
The coordinator creates the branch at the observed base and uses GitHub's
|
||||
`createCommitOnBranch` API with `expectedHeadOid` for an atomic append. GitHub
|
||||
signs the commit when supported by the authenticated identity; the coordinator
|
||||
requires remote signature verification, exact parent, changed paths and
|
||||
declaration bytes before opening a PR. It never force-updates a branch.
|
||||
An interrupted branch creation, commit or PR creation can be resumed:
|
||||
an existing branch still at the planned base receives the missing commit;
|
||||
The coordinator signs its commit, pushes without force, verifies the remote
|
||||
signature, parent, exact changed paths and declaration bytes, then opens a PR.
|
||||
An interrupted push or PR creation can be resumed with the same invocation:
|
||||
matching signed branches and PRs are reused. A mismatched branch is rejected.
|
||||
Closed existing PRs are reported as existing; they are not silently reopened.
|
||||
Reports include repository, branch, immutable head and submission URL, without
|
||||
embedding declaration contents or credentials. Keep the report if a later target
|
||||
fails; earlier valid submissions remain intact.
|
||||
|
||||
API permission, signature or commit-conflict failures stop the run. A timeout
|
||||
can occur after GitHub accepted a mutation, so inspect remote state or repeat
|
||||
the same invocation; do not create a different automation branch to retry.
|
||||
See [GitHub commit API documentation](https://docs.github.com/en/graphql/reference/commits#createcommitonbranch).
|
||||
|
||||
This handles remote target lists and signed submissions. Organization discovery is described below. Qualification-aware merging and classic branch enforcement are described below; scheduling and ruleset reconciliation remain separate work. A submitted PR is not a completed migration. Unknown profiles and
|
||||
native workflows require their own central conversion, not deletion by this tool.
|
||||
|
||||
@@ -126,27 +117,3 @@ Existing active repository rulesets with app-bound gates and no bypass actors ar
|
||||
A merged source update and an enforced branch are separate reported outcomes.
|
||||
Neither proves artifact publication or deployment. Scheduling and ruleset
|
||||
reconciliation remain outstanding.
|
||||
|
||||
## Central hosted pass
|
||||
|
||||
The orb owner's CircleCI config accepts `run_enrollment_reconcile: true` on
|
||||
`main`. This selects one small Python container instead of the normal orb
|
||||
build/publication workflow. It uses the existing
|
||||
`qqq-maven-registry-credentials` context's GitHub token through `gh`.
|
||||
No consumer-specific runner configuration or local signing key is needed.
|
||||
|
||||
`tools/run_enrollment.py` verifies the owner repository and main branch, runs
|
||||
organization discovery, signed enrollment, qualified merging and enforcement,
|
||||
then exits. The pass has a 20-minute execution limit. Pending checks are reported
|
||||
for the next pass rather than polled while a paid executor waits. Incremental
|
||||
results and execution status are retained under `artifacts/enrollment`, including
|
||||
when execution fails or times out. A completed pass does not mean every repository
|
||||
conforms: unresolved and waiting entries remain explicit follow-up work.
|
||||
|
||||
Create a single daily CircleCI schedule for the owner project only after a manual
|
||||
main-branch pass verifies its hosted credentials and results. Set `branch: main`
|
||||
and `run_enrollment_reconcile: true` in the schedule parameters. Scheduling is
|
||||
an external project setting; merging this config does not itself enable a schedule.
|
||||
Keep the existing RC-finalization parameter false for these runs. A timed-out
|
||||
GitHub request may already have succeeded remotely; the next pass resumes from
|
||||
the deterministic branch and verified source rather than forcing updates.
|
||||
@@ -18,13 +18,6 @@ def runs():
|
||||
|
||||
|
||||
class EnforcementTests(unittest.TestCase):
|
||||
def test_check_comparison_ignores_only_order(self):
|
||||
checks = [*enforcement.DESIRED, {'context': 'scanner', 'app_id': 15368}]
|
||||
self.assertTrue(enforcement.same_checks(checks, list(reversed(checks))))
|
||||
self.assertFalse(enforcement.same_checks(checks, checks[:-1]))
|
||||
self.assertFalse(enforcement.same_checks(checks, checks + checks[:1]))
|
||||
self.assertFalse(enforcement.same_checks(checks, [*enforcement.DESIRED, {'context': 'scanner', 'app_id': 999}]))
|
||||
|
||||
def test_preserves_security_gate_and_binds_orb_checks(self):
|
||||
before = {'required_status_checks': {'strict': False, 'contexts': ['security', 'setup'],
|
||||
'checks': [{'context': 'security', 'app_id': 15368}, {'context': 'setup', 'app_id': -1}]}}
|
||||
@@ -89,22 +82,6 @@ class EnforcementTests(unittest.TestCase):
|
||||
enforcement.enforce(plan, request)
|
||||
self.assertEqual([], state['writes'])
|
||||
|
||||
def test_github_may_reorder_required_checks_on_readback(self):
|
||||
before = {'required_status_checks': {'strict': True, 'checks': [
|
||||
*enforcement.DESIRED, {'context': 'scanner', 'app_id': 15368}]},
|
||||
'enforce_admins': {'enabled': False}, 'required_signatures': {'enabled': True}}
|
||||
plan, request, state = self.fixture(before)
|
||||
|
||||
def reordered(path, method='GET', payload=None):
|
||||
value = request(path, method, payload)
|
||||
if method == 'PATCH':
|
||||
state['before']['required_status_checks']['checks'].reverse()
|
||||
return value
|
||||
|
||||
enforcement.enforce(plan, reordered)
|
||||
self.assertTrue(state['before']['enforce_admins']['enabled'])
|
||||
self.assertEqual(before['required_signatures'], state['before']['required_signatures'])
|
||||
|
||||
def test_head_or_protection_drift_never_mutates(self):
|
||||
for field, value in [('head', 'b' * 40), ('before', {'unexpected': True})]:
|
||||
plan, request, state = self.fixture(None)
|
||||
@@ -173,31 +150,13 @@ class EnforcementTests(unittest.TestCase):
|
||||
with self.assertRaises(ValueError):
|
||||
enforcement.verified_rulesets('QRun-IO/example', effective, lambda path: record)
|
||||
|
||||
def test_empty_push_allowlist_gains_ruleset_without_changing_access(self):
|
||||
classic = {'restrictions': {'users': [], 'teams': [], 'apps': []},
|
||||
'enforce_admins': {'enabled': False}, 'required_signatures': {'enabled': True}}
|
||||
state = {'ruleset': None, 'writes': []}
|
||||
|
||||
def test_empty_push_allowlist_does_not_gain_admin_enforcement(self):
|
||||
def request(path, method='GET', payload=None):
|
||||
if method != 'GET':
|
||||
self.assertEqual(('POST', 'repos/QRun-IO/example/rulesets'), (method, path))
|
||||
state['writes'].append(copy.deepcopy(payload))
|
||||
state['ruleset'] = {**copy.deepcopy(payload), 'id': 123,
|
||||
'source_type': 'Repository', 'source': 'QRun-IO/example'}
|
||||
return state['ruleset']
|
||||
if '/rulesets?' in path:
|
||||
return []
|
||||
if path.endswith('/rulesets/123'):
|
||||
return copy.deepcopy(state['ruleset'])
|
||||
self.assertEqual('GET', method)
|
||||
if '/rules/branches/' in path:
|
||||
if state['ruleset'] is None:
|
||||
return []
|
||||
return [{**state['ruleset']['rules'][0], 'ruleset_source_type': 'Repository',
|
||||
'ruleset_source': 'QRun-IO/example', 'ruleset_id': 123}]
|
||||
return []
|
||||
if path.endswith('/protection'):
|
||||
return copy.deepcopy(classic)
|
||||
if '/check-runs?' in path:
|
||||
return {'check_runs': runs()}
|
||||
return {'restrictions': {'users': [], 'teams': [], 'apps': []}, 'enforce_admins': {'enabled': False}}
|
||||
if '/contents/' in path:
|
||||
data = ({'profile': 'core', 'orb_version': '0.8', 'default_branch': 'develop'}
|
||||
if '/.qqq-ci.yml?' in path else enforcement.standard.canonical_caller('core', '0.8'))
|
||||
@@ -206,32 +165,8 @@ class EnforcementTests(unittest.TestCase):
|
||||
return {'commit': {'sha': 'a' * 40}}
|
||||
return {'archived': False}
|
||||
|
||||
plan = enforcement.inspect('QRun-IO/example', 'main', '0.8', request)
|
||||
self.assertEqual('create-ruleset', plan['protection_mode'])
|
||||
enforcement.enforce(plan, request)
|
||||
self.assertEqual(1, len(state['writes']))
|
||||
self.assertEqual([], state['writes'][0]['bypass_actors'])
|
||||
self.assertEqual({'include': ['refs/heads/main'], 'exclude': []}, state['writes'][0]['conditions']['ref_name'])
|
||||
self.assertFalse(plan['before']['enforce_admins']['enabled'])
|
||||
self.assertEqual(classic, plan['before'])
|
||||
repeat = enforcement.inspect('QRun-IO/example', 'main', '0.8', request)
|
||||
self.assertFalse(repeat['changed'])
|
||||
enforcement.enforce(repeat, request)
|
||||
self.assertEqual(1, len(state['writes']))
|
||||
|
||||
def test_existing_named_ruleset_is_not_overwritten_or_duplicated(self):
|
||||
before = {'restrictions': {'users': [], 'teams': [], 'apps': []}, 'enforce_admins': {'enabled': False}}
|
||||
plan, base_request, state = self.fixture(before)
|
||||
plan['protection_mode'] = 'create-ruleset'
|
||||
|
||||
def request(path, method='GET', payload=None):
|
||||
if '/rulesets?' in path:
|
||||
return [{'name': 'QQQ automated verification: develop'}]
|
||||
return base_request(path, method, payload)
|
||||
|
||||
with self.assertRaisesRegex(ValueError, 'already exists'):
|
||||
enforcement.enforce(plan, request)
|
||||
self.assertEqual([], state['writes'])
|
||||
with self.assertRaisesRegex(ValueError, 'Empty push allowlist'):
|
||||
enforcement.inspect('QRun-IO/example', 'main', '0.8', request)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
@@ -118,67 +118,41 @@ class ReconcileTests(unittest.TestCase):
|
||||
self.assertEqual('submitted', result['state'])
|
||||
self.assertEqual([['gh', 'pr', 'create']], seen)
|
||||
|
||||
def test_new_api_submission_is_atomic_and_exact(self):
|
||||
def test_new_submission_requires_signed_commit_and_never_force_pushes(self):
|
||||
plan = self.plan()
|
||||
mutations = []
|
||||
committed = False
|
||||
seen = []
|
||||
|
||||
def request(path, missing=False):
|
||||
if '/git/ref/' in path:
|
||||
return None
|
||||
if '/pulls?' in path:
|
||||
return []
|
||||
return self.submission_api(plan, path, missing)
|
||||
|
||||
def mutate(path, payload):
|
||||
mutations.append((path, payload))
|
||||
return {'data': {'createCommitOnBranch': {'commit': {'oid': self.new}}}}
|
||||
def command(args, cwd=None):
|
||||
nonlocal committed
|
||||
seen.append(args)
|
||||
if args[:2] == ['git', 'clone']:
|
||||
root = Path(args[-1])
|
||||
(root / '.circleci').mkdir(parents=True)
|
||||
for name, data in self.sources.items():
|
||||
(root / name).write_bytes(data)
|
||||
elif args[:2] == ['git', 'rev-parse']:
|
||||
return self.new if committed else self.head
|
||||
elif args[:2] == ['git', 'commit']:
|
||||
self.assertIn('-S', args)
|
||||
for name in remote.PATHS:
|
||||
self.assertEqual(plan['replacements'][name], (cwd / name).read_bytes())
|
||||
committed = True
|
||||
elif args[:3] == ['gh', 'pr', 'create']:
|
||||
return 'https://github.com/QRun-IO/example/pull/3'
|
||||
return ''
|
||||
|
||||
with mock.patch.object(remote, 'api', side_effect=request), mock.patch.object(remote, 'mutation', side_effect=mutate), mock.patch.object(remote, 'command') as command:
|
||||
self.assertEqual('existing-pr', remote.apply(plan)['state'])
|
||||
command.assert_not_called()
|
||||
self.assertEqual(('repos/' + self.repo + '/git/refs', {'ref': 'refs/heads/' + plan['automation_branch'], 'sha': self.head}), mutations[0])
|
||||
commit = mutations[1][1]['variables']['input']
|
||||
self.assertEqual(self.head, commit['expectedHeadOid'])
|
||||
self.assertEqual({'repositoryNameWithOwner': self.repo, 'branchName': plan['automation_branch']}, commit['branch'])
|
||||
self.assertEqual(plan['replacements'], {item['path']: base64.b64decode(item['contents']) for item in commit['fileChanges']['additions']})
|
||||
|
||||
def test_base_only_branch_resumes_without_creating_another_ref(self):
|
||||
plan = self.plan()
|
||||
result = {'data': {'createCommitOnBranch': {'commit': {'oid': self.new}}}}
|
||||
with mock.patch.object(remote, 'api', return_value={'commit': {'sha': self.head}}), mock.patch.object(remote, 'mutation', return_value=result) as mutation:
|
||||
self.assertEqual(self.new, remote.signed_api_commit(plan, {'object': {'sha': self.head}}))
|
||||
self.assertEqual(1, mutation.call_count)
|
||||
self.assertEqual('graphql', mutation.call_args.args[0])
|
||||
|
||||
def test_existing_completed_branch_is_not_mutated(self):
|
||||
with mock.patch.object(remote, 'mutation') as mutation:
|
||||
self.assertEqual(self.new, remote.signed_api_commit(self.plan(), {'object': {'sha': self.new}}))
|
||||
mutation.assert_not_called()
|
||||
|
||||
def test_target_drift_prevents_commit_on_base_only_branch(self):
|
||||
plan = self.plan()
|
||||
with mock.patch.object(remote, 'api', return_value={'commit': {'sha': 'c' * 40}}), mock.patch.object(remote, 'mutation') as mutation:
|
||||
with self.assertRaises(ValueError):
|
||||
remote.signed_api_commit(plan, {'object': {'sha': self.head}})
|
||||
mutation.assert_not_called()
|
||||
|
||||
def test_graphql_errors_fail_closed(self):
|
||||
response = mock.Mock(returncode=0, stdout='{"errors": [{"message": "conflict"}]}')
|
||||
with mock.patch.object(remote.subprocess, 'run', return_value=response):
|
||||
with self.assertRaises(ValueError):
|
||||
remote.mutation('graphql', {})
|
||||
|
||||
def test_unsigned_api_commit_cannot_create_pr(self):
|
||||
plan = self.plan()
|
||||
def request(path, missing=False):
|
||||
if '/git/ref/' in path:
|
||||
return {'object': {'sha': self.head}}
|
||||
value = self.submission_api(plan, path, missing)
|
||||
if '/commits/' in path:
|
||||
value['commit']['verification']['verified'] = False
|
||||
return value
|
||||
with mock.patch.object(remote, 'api', side_effect=request), mock.patch.object(remote, 'mutation', return_value={'data': {'createCommitOnBranch': {'commit': {'oid': self.new}}}}), mock.patch.object(remote, 'command') as command:
|
||||
with self.assertRaises(ValueError):
|
||||
remote.apply(plan)
|
||||
command.assert_not_called()
|
||||
with mock.patch.object(remote, 'api', side_effect=request), mock.patch.object(remote, 'command', side_effect=command):
|
||||
self.assertEqual('submitted', remote.apply(plan)['state'])
|
||||
pushes = [args for args in seen if args[:2] == ['git', 'push']]
|
||||
self.assertEqual([['git', 'push', 'origin', 'HEAD:refs/heads/' + plan['automation_branch']]], pushes)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
@@ -1,48 +0,0 @@
|
||||
"""Central execution rejects untrusted branches and preserves partial evidence."""
|
||||
import json
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
from unittest.mock import Mock
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tools'))
|
||||
import run_enrollment
|
||||
|
||||
|
||||
class RunnerTests(unittest.TestCase):
|
||||
def environment(self):
|
||||
return {'CIRCLE_PROJECT_USERNAME': 'QRun-IO', 'CIRCLE_PROJECT_REPONAME': 'qqq-orb',
|
||||
'CIRCLE_BRANCH': 'main', 'GITHUB_TOKEN': 'test-only-secret'}
|
||||
|
||||
def test_wrong_owner_branch_repo_tag_or_missing_auth_cannot_execute(self):
|
||||
for change in ({'CIRCLE_PROJECT_USERNAME': 'other'}, {'CIRCLE_PROJECT_REPONAME': 'other'},
|
||||
{'CIRCLE_BRANCH': 'develop'}, {'CIRCLE_TAG': 'v1.0.0'}, {'GITHUB_TOKEN': ''}):
|
||||
execute = Mock()
|
||||
with self.subTest(change=change), self.assertRaises(ValueError):
|
||||
run_enrollment.run({**self.environment(), **change}, execute)
|
||||
execute.assert_not_called()
|
||||
|
||||
def test_timeout_retains_partial_report_without_secrets(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
def execute(args, **kwargs):
|
||||
output = Path(args[args.index('--output') + 1])
|
||||
output.write_text('[{"state":"unresolved"}]')
|
||||
self.assertEqual(1200, kwargs['timeout'])
|
||||
self.assertEqual('test-only-secret', kwargs['env']['GH_TOKEN'])
|
||||
raise subprocess.TimeoutExpired(args, 1200)
|
||||
self.assertEqual(124, run_enrollment.run(self.environment(), execute, directory))
|
||||
output = Path(directory) / 'artifacts/enrollment'
|
||||
self.assertEqual([{'state': 'unresolved'}], json.loads((output / 'result.json').read_text()))
|
||||
self.assertEqual('timed-out', json.loads((output / 'run.json').read_text())['state'])
|
||||
self.assertNotIn('test-only-secret', (output / 'run.json').read_text())
|
||||
|
||||
def test_failed_pass_propagates_nonzero_exit(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
self.assertEqual(2, run_enrollment.run(self.environment(), Mock(return_value=Mock(returncode=2)), directory))
|
||||
self.assertEqual('failed', json.loads((Path(directory) / 'artifacts/enrollment/run.json').read_text())['state'])
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
unittest.main()
|
||||
@@ -17,12 +17,6 @@ DESIRED = [{'context': name, 'app_id': 18001} for name in ('setup', 'verify')]
|
||||
PROFILES = {'qbit', 'core', 'frontend-core', 'frontend-material', 'repository-policy'}
|
||||
|
||||
|
||||
def same_checks(left, right):
|
||||
"""GitHub may reorder checks; retain exact bindings and duplicate counts."""
|
||||
return sorted(json.dumps(check, sort_keys=True) for check in left) == sorted(
|
||||
json.dumps(check, sort_keys=True) for check in right)
|
||||
|
||||
|
||||
def api(path, method='GET', payload=None):
|
||||
"""Use existing gh authentication; never expose response bodies on failure."""
|
||||
args = ['gh', 'api', '--method', method, path]
|
||||
@@ -108,9 +102,10 @@ def inspect(repo, branch, version, request=api):
|
||||
rulesets, ruleset_strict = verified_rulesets(repo, rules, request) if rules else ([], False)
|
||||
before = request(prefix + '/protection')
|
||||
restrictions = (before or {}).get('restrictions')
|
||||
use_ruleset = (not rulesets and restrictions is not None
|
||||
if (not rulesets and restrictions is not None
|
||||
and not any(restrictions.get(kind) for kind in ('users', 'teams', 'apps'))
|
||||
and not (before or {}).get('enforce_admins', {}).get('enabled'))
|
||||
and not (before or {}).get('enforce_admins', {}).get('enabled')):
|
||||
raise ValueError('Empty push allowlist needs explicit access policy before enforcing admins')
|
||||
runs = []
|
||||
page = 1
|
||||
while True:
|
||||
@@ -120,17 +115,13 @@ def inspect(repo, branch, version, request=api):
|
||||
break
|
||||
page += 1
|
||||
desired = required_checks(before, runs)
|
||||
if use_ruleset:
|
||||
return {'repository': repo, 'branch': branch, 'head': head, 'before': before,
|
||||
'required_status_checks': {'strict': False, 'checks': DESIRED},
|
||||
'changed': True, 'protection_mode': 'create-ruleset'}
|
||||
if rulesets:
|
||||
desired['strict'] = ruleset_strict or bool(((before or {}).get('required_status_checks') or {}).get('strict'))
|
||||
return {'repository': repo, 'branch': branch, 'head': head, 'before': before,
|
||||
'required_status_checks': desired, 'changed': False, 'protection_mode': 'rulesets',
|
||||
'effective_rules': rules, 'rulesets': rulesets}
|
||||
current = (before or {}).get('required_status_checks') or {}
|
||||
ready = (current.get('strict') is True and same_checks(current.get('checks', []), desired['checks'])
|
||||
ready = (current.get('strict') is True and current.get('checks') == desired['checks']
|
||||
and (before or {}).get('enforce_admins', {}).get('enabled') is True)
|
||||
return {'repository': repo, 'branch': branch, 'head': head, 'before': before,
|
||||
'required_status_checks': desired, 'changed': not ready}
|
||||
@@ -149,28 +140,6 @@ def enforce(plan, request=api):
|
||||
return
|
||||
if rules:
|
||||
raise ValueError('Ruleset changed after preflight')
|
||||
if plan.get('protection_mode') == 'create-ruleset':
|
||||
name = 'QQQ automated verification: ' + plan['branch']
|
||||
page = 1
|
||||
while True:
|
||||
existing = request(root + '/rulesets?per_page=100&page=' + str(page))
|
||||
if any(record['name'] == name for record in existing):
|
||||
raise ValueError('Named ruleset already exists; reconcile its scope explicitly')
|
||||
if len(existing) < 100:
|
||||
break
|
||||
page += 1
|
||||
request(root + '/rulesets', 'POST', {
|
||||
'name': name, 'target': 'branch', 'enforcement': 'active', 'bypass_actors': [],
|
||||
'conditions': {'ref_name': {'include': ['refs/heads/' + plan['branch']], 'exclude': []}},
|
||||
'rules': [{'type': 'required_status_checks', 'parameters': {
|
||||
'strict_required_status_checks_policy': False, 'do_not_enforce_on_create': False,
|
||||
'required_status_checks': [{'context': gate['context'], 'integration_id': gate['app_id']}
|
||||
for gate in DESIRED]}}]})
|
||||
effective = request(root + '/rules/branches/' + plan['branch'])
|
||||
verified_rulesets(plan['repository'], effective, request)
|
||||
if request(prefix + '/protection') != plan['before']:
|
||||
raise ValueError('Classic access policy changed during ruleset creation')
|
||||
return
|
||||
if not plan['changed']:
|
||||
return
|
||||
before = plan['before']
|
||||
@@ -184,7 +153,7 @@ def enforce(plan, request=api):
|
||||
request(prefix + '/protection/enforce_admins', 'POST')
|
||||
after = request(prefix + '/protection')
|
||||
actual = after['required_status_checks']
|
||||
if not actual['strict'] or not same_checks(actual['checks'], plan['required_status_checks']['checks']) or not after['enforce_admins']['enabled']:
|
||||
if not actual['strict'] or actual['checks'] != plan['required_status_checks']['checks'] or not after['enforce_admins']['enabled']:
|
||||
raise ValueError('Protection readback did not match requested gates')
|
||||
if before:
|
||||
for key, value in before.items():
|
||||
|
||||
@@ -1,18 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
set -euo pipefail
|
||||
|
||||
# Ubuntu Jammy ships gh 2.4, which lacks API --slurp and modern merge guards.
|
||||
# Pin the official amd64 release and its GitHub release asset SHA-256.
|
||||
version=2.103.0
|
||||
checksum=fdd768eb70f6409f80fcfa9f3a1c0adf0fc98d827ab3ce0bed2ac22762c5d786
|
||||
archive=$(mktemp)
|
||||
binary=$(mktemp)
|
||||
trap 'rm -f "$archive" "$binary"' EXIT
|
||||
curl --fail --silent --show-error --location --retry 3 \
|
||||
"https://github.com/cli/cli/releases/download/v${version}/gh_${version}_linux_amd64.tar.gz" -o "$archive"
|
||||
printf '%s %s\n' "$checksum" "$archive" | sha256sum --check --status
|
||||
tar -xOzf "$archive" "gh_${version}_linux_amd64/bin/gh" > "$binary"
|
||||
sudo install -m 0755 "$binary" /usr/local/bin/gh
|
||||
gh --version
|
||||
gh api --help | grep -q -- --slurp
|
||||
gh pr merge --help | grep -q -- --match-head-commit
|
||||
@@ -50,50 +50,6 @@ def content(repo, path, head):
|
||||
return base64.b64decode(item['content'])
|
||||
|
||||
|
||||
def mutation(path, payload):
|
||||
"""Use the existing gh identity; never print credentials or response bodies."""
|
||||
result = subprocess.run(['gh', 'api', path, '--method', 'POST', '--input', '-'],
|
||||
input=json.dumps(payload), capture_output=True,
|
||||
text=True, encoding='utf-8', timeout=60)
|
||||
if result.returncode:
|
||||
raise ValueError('GitHub mutation failed; inspect remote state before retrying')
|
||||
try:
|
||||
data = json.loads(result.stdout)
|
||||
except ValueError:
|
||||
raise ValueError('Invalid GitHub mutation response') from None
|
||||
if not isinstance(data, dict) or data.get('errors'):
|
||||
raise ValueError('GitHub mutation did not succeed')
|
||||
return data
|
||||
|
||||
|
||||
def signed_api_commit(plan, ref):
|
||||
"""Resume a base-only branch; append atomically without local Git/SSH keys."""
|
||||
repo, branch, base = plan['repository'], plan['automation_branch'], plan['head']
|
||||
if ref is None:
|
||||
mutation(f'repos/{repo}/git/refs', {'ref': 'refs/heads/' + branch, 'sha': base})
|
||||
elif ref['object']['sha'] != base:
|
||||
return ref['object']['sha']
|
||||
if api(f'repos/{repo}/branches/{plan["branch"]}')['commit']['sha'] != base:
|
||||
raise ValueError('Target branch moved before submission')
|
||||
additions = [{'path': path, 'contents': base64.b64encode(plan['replacements'][path]).decode('ascii')}
|
||||
for path in PATHS if plan['originals'][path] != plan['replacements'][path]]
|
||||
result = mutation('graphql', {
|
||||
'query': 'mutation($input: CreateCommitOnBranchInput!) { createCommitOnBranch(input: $input) { commit { oid } } }',
|
||||
'variables': {'input': {
|
||||
'branch': {'repositoryNameWithOwner': repo, 'branchName': branch},
|
||||
'expectedHeadOid': base,
|
||||
'message': {'headline': 'ci: enroll in the shared QQQ orb',
|
||||
'body': 'Co-Authored-By: Codex <noreply@openai.com>'},
|
||||
'fileChanges': {'additions': additions}}}})
|
||||
try:
|
||||
head = result['data']['createCommitOnBranch']['commit']['oid']
|
||||
except (KeyError, TypeError):
|
||||
raise ValueError('GitHub commit response is incomplete') from None
|
||||
if not isinstance(head, str) or not re.fullmatch(r'[0-9a-f]{40}', head):
|
||||
raise ValueError('GitHub commit response has no valid SHA')
|
||||
return head
|
||||
|
||||
|
||||
def inspect(target, version):
|
||||
"""Resolve observed repository identity and reuse the shared enrollment planner."""
|
||||
if not isinstance(target, dict) or set(target) != {'repository', 'branch'}:
|
||||
@@ -147,7 +103,29 @@ def apply(plan):
|
||||
if api(f'repos/{repo}/branches/{plan["branch"]}')['commit']['sha'] != plan['head']:
|
||||
raise ValueError('Target branch changed after preflight')
|
||||
ref = api(f'repos/{repo}/git/ref/heads/{branch}', missing=True)
|
||||
head = signed_api_commit(plan, ref)
|
||||
if ref is None:
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory) / 'checkout'
|
||||
command(['git', 'clone', '-c', 'core.autocrlf=false', '--depth', '1', '--single-branch', '--branch', plan['branch'],
|
||||
f'git@github.com:{repo}.git', str(root)])
|
||||
if command(['git', 'rev-parse', 'HEAD'], root) != plan['head']:
|
||||
raise ValueError('Target branch moved before checkout')
|
||||
for path in PATHS:
|
||||
target = enroll_consumers.declaration(root, path)
|
||||
current = target.read_bytes() if target.exists() else None
|
||||
if current != plan['originals'][path]:
|
||||
raise ValueError('Checkout differs from immutable preflight')
|
||||
target.write_bytes(plan['replacements'][path])
|
||||
command(['git', 'add', '--', *PATHS], root)
|
||||
command(['git', 'diff', '--cached', '--check'], root)
|
||||
command(['git', 'commit', '-S', '-m', 'ci: enroll in the shared QQQ orb', '-m',
|
||||
'Co-Authored-By: Codex <noreply@openai.com>'], root)
|
||||
head = command(['git', 'rev-parse', 'HEAD'], root)
|
||||
if api(f'repos/{repo}/branches/{plan["branch"]}')['commit']['sha'] != plan['head']:
|
||||
raise ValueError('Target branch moved before submission')
|
||||
command(['git', 'push', 'origin', f'HEAD:refs/heads/{branch}'], root)
|
||||
else:
|
||||
head = ref['object']['sha']
|
||||
verify_submission(plan, head)
|
||||
pulls = api(f'repos/{repo}/pulls?state=all&head={repo.split("/")[0]}:{branch}&base={plan["branch"]}')
|
||||
if pulls:
|
||||
|
||||
@@ -1,39 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""One bounded central reconciliation pass; no executor polling for PR checks."""
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import sys
|
||||
|
||||
|
||||
def run(environment=None, execute=subprocess.run, root=None):
|
||||
env = dict(os.environ if environment is None else environment)
|
||||
if (env.get('CIRCLE_PROJECT_USERNAME') != 'QRun-IO'
|
||||
or env.get('CIRCLE_PROJECT_REPONAME') != 'qqq-orb'
|
||||
or env.get('CIRCLE_BRANCH') != 'main' or env.get('CIRCLE_TAG')):
|
||||
raise ValueError('Reconciliation requires the orb main branch')
|
||||
token = env.get('GH_TOKEN') or env.get('GITHUB_TOKEN')
|
||||
if not token:
|
||||
raise ValueError('Existing GitHub authentication is required')
|
||||
env['GH_TOKEN'] = token
|
||||
root = Path(root) if root else Path(__file__).resolve().parents[1]
|
||||
output = root / 'artifacts/enrollment'
|
||||
output.mkdir(parents=True, exist_ok=True)
|
||||
args = [sys.executable, str(root / 'tools/reconcile_enrollment.py'),
|
||||
'--organization', 'QRun-IO', '--orb-version', '0.8',
|
||||
'--output', str(output / 'result.json'), '--apply', '--merge-ready', '--enforce']
|
||||
try:
|
||||
result = execute(args, cwd=root, env=env, timeout=1200, check=False)
|
||||
code = result.returncode
|
||||
state = 'completed' if code == 0 else 'failed'
|
||||
except subprocess.TimeoutExpired:
|
||||
code, state = 124, 'timed-out'
|
||||
(output / 'run.json').write_text(json.dumps({'state': state, 'exit_code': code,
|
||||
'report_available': (output / 'result.json').exists(),
|
||||
'note': 'Completion of a pass does not prove all repositories conform; inspect unresolved and waiting entries.'}, indent=2), encoding='utf-8')
|
||||
return code
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(run())
|
||||
Reference in new issue
Block a user