Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

Check ordinary saved-policy notifications and restart in CI

pulse-triage[bot]cbc387ab9132
diff --git a/.github/workflows/build-and-test.yml b/.github/workflows/build-and-test.yml
index 6171decf69..58ce67ae61 100644
--- a/.github/workflows/build-and-test.yml
+++ b/.github/workflows/build-and-test.yml
@@ -319,6 +319,26 @@ jobs:
if-no-files-found: warn
retention-days: 7
+ # Reuse the exact real-embed binary, rather than another build or mock
+ # lifecycle callback. This owns only disposable loopback endpoints/data:
+ # saved policy must reach ordinary alerts and survive a real restart.
+ - name: Check ordinary notification policy and restart
+ timeout-minutes: 3
+ run: >-
+ python3 scripts/check_notification_runtime.py
+ --binary "$RUNNER_TEMP/pulse-real-embed"
+ --expected-source-sha "${{ github.sha }}"
+ --receipt "$RUNNER_TEMP/pulse-notification-runtime.json"
+
+ - name: Retain bounded notification runtime receipt
+ if: always()
+ uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+ with:
+ name: notification-runtime-${{ github.run_id }}-${{ github.run_attempt }}
+ path: ${{ runner.temp }}/pulse-notification-runtime.json
+ if-no-files-found: warn
+ retention-days: 7
+
# An audit service failure or real advisory stays gating, but it must not
# suppress formatting, tests, type-checking, or production-build proof.
- name: Require frontend dependency audit
diff --git a/scripts/check_notification_runtime.py b/scripts/check_notification_runtime.py
new file mode 100644
index 0000000000..4c7fe197f3
--- /dev/null
+++ b/scripts/check_notification_runtime.py
@@ -0,0 +1,371 @@
+#!/usr/bin/env python3
+"""An owned offline source application and webhook; not installed acceptance.
+
+All data, credentials and network endpoints are generated in this guest.
+Never prints credentials, response bodies or application logs. Mutations are
+single submissions; uncertain POST/PUT outcomes stop without replay.
+"""
+import argparse
+import datetime
+import hashlib
+import http.cookiejar
+import http.server
+import json
+import os
+from pathlib import Path
+import re
+import secrets
+import signal
+import socket
+import subprocess
+import tempfile
+import threading
+import time
+import urllib.error
+import urllib.request
+
+PUBLIC_URL = 'https://notification-runtime.example.test'
+LIMIT = 2 * 1024 * 1024
+# prepareWebhookData's ordinary event; resolution is a different path.
+ORDINARY_EVENT = 'alert'
+
+
+class Failure(RuntimeError):
+ pass
+
+
+def require(condition, message):
+ if not condition:
+ raise Failure(message)
+
+
+def free_port():
+ with socket.socket() as sock:
+ sock.bind(('127.0.0.1', 0))
+ return sock.getsockname()[1]
+
+
+class Sink:
+ def __init__(self):
+ self.rows = []
+ self.lock = threading.Lock()
+ self.error = None
+ owner = self
+
+ class Handler(http.server.BaseHTTPRequestHandler):
+ def log_message(self, *_):
+ pass
+
+ def do_POST(self):
+ try:
+ size = int(self.headers.get('Content-Length', '-1'))
+ require(0 < size <= 65536, 'sink request exceeded declared bound')
+ raw = self.rfile.read(size)
+ require(len(raw) == size, 'sink short read')
+ obj = json.loads(raw)
+ require(isinstance(obj, dict), 'sink non-object')
+ with owner.lock:
+ owner.rows.append({'body': obj, 'sha256': hashlib.sha256(raw).hexdigest(),
+ 'bytes': size, 'path': self.path})
+ self.send_response(200)
+ self.send_header('Content-Length', '2')
+ self.end_headers()
+ self.wfile.write(b'OK')
+ except Exception as exc:
+ owner.error = type(exc).__name__
+ self.send_response(400)
+ self.send_header('Content-Length', '0')
+ self.end_headers()
+
+ self.server = http.server.ThreadingHTTPServer(('127.0.0.1', 0), Handler)
+ self.server.daemon_threads = False
+ self.port = self.server.server_port
+ self.thread = threading.Thread(target=self.server.serve_forever, name='owned-webhook')
+ self.thread.start()
+
+ def snapshot(self):
+ with self.lock:
+ return list(self.rows)
+
+ def close(self):
+ self.server.shutdown()
+ self.server.server_close()
+ self.thread.join(timeout=5)
+ require(not self.thread.is_alive(), 'sink thread did not join')
+ with socket.socket() as sock:
+ sock.settimeout(1)
+ require(sock.connect_ex(('127.0.0.1', self.port)) != 0, 'sink listener stayed open')
+
+
+def delivery_checks(row, expected_name):
+ """Keep each asserted closed condition, not private/untrusted payload text."""
+ body = row['body']
+ return {'owned_path': row['path'] == '/owned-alert',
+ 'resource_identity': body.get('resourceName') == expected_name,
+ 'saved_public_url': body.get('instance') == PUBLIC_URL,
+ 'ordinary_event': body.get('event') == ORDINARY_EVENT,
+ 'cpu_metric': body.get('type') == 'cpu'}
+
+
+def source_binding(binary, expected):
+ require(bool(re.fullmatch(r'[0-9a-f]{40}', expected)), 'invalid expected source identity')
+ actual = subprocess.check_output(['git', 'rev-parse', 'HEAD'], text=True).strip()
+ require(actual == expected, 'checkout differs from expected source')
+ require(subprocess.run(['git', 'diff', '--quiet', 'HEAD'], check=False).returncode == 0,
+ 'checkout has tracked source changes')
+ version = subprocess.check_output(['go', 'version', '-m', str(binary)], text=True)
+ fields = {}
+ for line in version.splitlines():
+ match = re.match(r'\s*build\s+(vcs(?:\.[a-z]+)?)=(.*)$', line)
+ if match:
+ fields[match[1]] = match[2]
+ require(fields.get('vcs') == 'git' and fields.get('vcs.revision') == expected and
+ fields.get('vcs.modified') == 'false', 'binary VCS identity is not clean exact source')
+ return {'checkout_sha': actual, 'binary_vcs_revision': fields['vcs.revision'],
+ 'binary_vcs_modified': False}
+
+
+class Journey:
+ def __init__(self, binary, data, log, sink):
+ self.binary, self.data, self.log, self.sink = binary, data, log, sink
+ self.port = free_port()
+ self.origin = f'http://127.0.0.1:{self.port}'
+ self.cookies = http.cookiejar.CookieJar()
+ self.client = urllib.request.build_opener(urllib.request.ProxyHandler({}),
+ urllib.request.HTTPCookieProcessor(self.cookies))
+ self.password = secrets.token_hex(24)
+ self.token = None
+ self.token_id = None
+ self.process = None
+ self.phases, self.exits, self.requests, self.deliveries = [], [], [], []
+ self.delivery_observations = []
+ self.active_request = None
+
+ def phase(self, name):
+ self.phases.append(name)
+ print('PHASE=' + name, flush=True)
+
+ def request(self, path, payload=None, method=None, expected=200, auth='session'):
+ headers = {'Content-Type': 'application/json', 'User-Agent': 'pulse-notification-policy-journey'}
+ client = self.client
+ if auth != 'session':
+ client = urllib.request.build_opener(urllib.request.ProxyHandler({}))
+ if auth == 'agent':
+ headers['Authorization'] = 'Bearer ' + self.token
+ if payload is not None and auth == 'session':
+ for cookie in self.cookies:
+ if cookie.name == 'pulse_csrf':
+ headers['X-CSRF-Token'] = cookie.value
+ req = urllib.request.Request(self.origin + path, headers=headers, method=method,
+ data=None if payload is None else json.dumps(payload).encode())
+ self.active_request = {'path': path, 'method': req.get_method(), 'authentication': auth}
+ print('REQUEST_BEGIN=' + json.dumps(self.active_request, sort_keys=True), flush=True)
+ start = time.monotonic()
+ try:
+ response = client.open(req, timeout=30)
+ except urllib.error.HTTPError as exc:
+ response = exc
+ with response:
+ raw = response.read(LIMIT + 1)
+ obs = dict(self.active_request, status=response.status,
+ elapsed_seconds=round(time.monotonic() - start, 3))
+ self.requests.append(obs)
+ self.active_request = None
+ print('REQUEST_END=' + json.dumps(obs, sort_keys=True), flush=True)
+ require(len(raw) <= LIMIT, 'HTTP response exceeded byte bound')
+ require(response.status == expected, f'{path} expected HTTP {expected}, observed {response.status}')
+ if expected >= 400:
+ return None
+ try:
+ return json.loads(raw) if raw else None
+ except json.JSONDecodeError:
+ raise Failure(path + ' successful response was not JSON') from None
+
+ def start(self):
+ env = {'PATH': os.environ['PATH'], 'HOME': str(self.data), 'LANG': 'C.UTF-8',
+ 'PULSE_DATA_DIR': str(self.data), 'BIND_ADDRESS': '127.0.0.1',
+ 'FRONTEND_PORT': str(self.port), 'PULSE_METRICS_PORT': str(free_port()),
+ 'PULSE_AUTH_USER': 'runtime-check', 'PULSE_AUTH_PASS': self.password,
+ 'PULSE_MOCK_MODE': 'false', 'DISCOVERY_ENABLED': 'false', 'PULSE_TELEMETRY': 'false'}
+ self.process = subprocess.Popen([str(self.binary)], cwd=self.data, env=env,
+ stdout=self.log, stderr=subprocess.STDOUT, start_new_session=True)
+ deadline = time.monotonic() + 45
+ while time.monotonic() < deadline:
+ require(self.process.poll() is None, 'owned server exited before readiness')
+ try:
+ self.request('/api/resources', expected=401, auth='none')
+ return
+ except (urllib.error.URLError, TimeoutError, ConnectionError):
+ time.sleep(.2)
+ raise Failure('owned server readiness deadline expired')
+
+ def stop(self):
+ if self.process is None:
+ return
+ child, self.process = self.process, None
+ started = time.monotonic()
+ if child.poll() is None:
+ os.killpg(child.pid, signal.SIGTERM)
+ forced = False
+ try:
+ code = child.wait(timeout=40)
+ except subprocess.TimeoutExpired:
+ forced = True
+ os.killpg(child.pid, signal.SIGKILL)
+ code = child.wait(timeout=10)
+ self.exits.append({'exit': code, 'forced': forced, 'waited': True,
+ 'wait_seconds': round(time.monotonic() - started, 3)})
+ require(code == 0 and not forced, 'owned server shutdown not clean')
+ with socket.socket() as sock:
+ sock.settimeout(1)
+ require(sock.connect_ex(('127.0.0.1', self.port)) != 0, 'owned listener stayed open')
+
+ def denied_destination(self):
+ self.request('/api/notifications/webhooks',
+ {'name': 'unlisted-loopback', 'url': f'http://127.0.0.2:{self.sink.port}/blocked',
+ 'enabled': True, 'method': 'POST', 'service': 'generic'}, expected=400)
+
+ def assert_settings(self):
+ settings = self.request('/api/system/settings')
+ require(settings.get('publicURL') == PUBLIC_URL and
+ settings.get('webhookAllowedPrivateCIDRs') == '127.0.0.1/32', 'saved system policy changed')
+ cfg = self.request('/api/alerts/config')
+ require(cfg.get('enabled') and cfg.get('activationState') == 'active' and
+ cfg.get('agentDefaults', {}).get('cpu', {}).get('trigger') == 80,
+ 'saved threshold/activation policy changed')
+
+ def report(self, identity):
+ payload = {'agent': {'id': 'agent-' + identity, 'version': '0.0.0-dev', 'type': 'unified',
+ 'commandsEnabled': False, 'intervalSeconds': 60},
+ 'host': {'id': 'machine-' + identity, 'machineId': 'machine-' + identity,
+ 'hostname': 'notification-' + identity + '.example.test',
+ 'platform': 'linux', 'cpuCount': 1},
+ 'timestamp': datetime.datetime.now(datetime.timezone.utc).isoformat(),
+ 'sequenceId': 'v1:notification-' + identity + ':1',
+ 'metrics': {'cpuUsagePercent': 95, 'memory': {'totalBytes': 1073741824,
+ 'usedBytes': 429496729, 'freeBytes': 644245095, 'usage': 40}}}
+ self.request('/api/agents/agent/report', payload, auth='agent')
+ deadline = time.monotonic() + 30
+ expected_name = payload['host']['hostname']
+ while time.monotonic() < deadline:
+ require(self.process.poll() is None, 'owned server exited during ordinary delivery')
+ rows = self.sink.snapshot()
+ matches = [row for row in rows if row['body'].get('resourceName') == expected_name]
+ if matches:
+ require(len(matches) == 1, 'same first alert delivered more than once')
+ row = matches[0]
+ checks = delivery_checks(row, expected_name)
+ self.delivery_observations.append({'resource': identity, 'checks': checks,
+ 'bytes': row['bytes'], 'sha256': row['sha256']})
+ require(all(checks.values()), 'ordinary delivery checks failed: ' +
+ ','.join(sorted(key for key, passed in checks.items() if not passed)))
+ self.deliveries.append({'resource': identity, 'event': ORDINARY_EVENT, 'metric': 'cpu',
+ 'saved_public_url': True, 'count': len(matches),
+ 'bytes': row['bytes'], 'sha256': row['sha256']})
+ self.phase('ordinary-first-alert-' + identity)
+ return
+ require(self.sink.error is None, 'owned destination rejected payload')
+ time.sleep(.2)
+ active = self.request('/api/alerts/active')
+ self.phase('ordinary-delivery-deadline-active-' + ('present' if bool(active) else 'empty'))
+ raise Failure('ordinary first-alert destination deadline expired')
+
+ def run(self):
+ try:
+ self.start()
+ self.request('/api/login', {'username': 'runtime-check', 'password': self.password})
+ require(any(c.name == 'pulse_csrf' for c in self.cookies), 'login missing CSRF cookie')
+ require(self.request('/api/resources?limit=500').get('data') == [], 'initial live estate not empty')
+ self.phase('authenticated-empty-live-startup')
+ self.request('/api/system/settings/update', {'publicURL': PUBLIC_URL,
+ 'webhookAllowedPrivateCIDRs': '127.0.0.1/32', 'telemetryEnabled': False})
+ self.denied_destination()
+ self.request('/api/notifications/webhooks', {'name': 'owned-first-alert',
+ 'url': f'http://127.0.0.1:{self.sink.port}/owned-alert', 'enabled': True,
+ 'method': 'POST', 'service': 'generic',
+ 'template': '{"instance":"{{.Instance | jsonString}}","resourceName":"{{.ResourceName | jsonString}}","event":"{{.Event | jsonString}}","type":"{{.Type | jsonString}}"}'})
+ cfg = self.request('/api/alerts/config')
+ cfg.update(enabled=True, activationState='active', flappingEnabled=False,
+ timeThresholds={'agent': 0}, metricTimeThresholds={'agent': {'cpu': 0}},
+ metricEvaluationWindows={'agent': {'cpu': 0}},
+ agentDefaults={'cpu': {'trigger': 80, 'clear': 70}},
+ disableAllAgents=False, disableAllAgentsOffline=True)
+ cfg['schedule'].update(cooldown=0, initialNotify='webhook', notifyOnResolve=False,
+ grouping={'enabled': False, 'window': 0, 'byNode': False, 'byGuest': False})
+ self.request('/api/alerts/config', cfg, method='PUT')
+ response = self.request('/api/security/tokens', {'name': 'owned-monitoring-only',
+ 'scopes': ['agent:report'], 'expiresIn': '1h'})
+ self.token, self.token_id = response['token'], response['record']['id']
+ require(response['record']['scopes'] == ['agent:report'], 'monitoring-only scope widened')
+ self.request('/api/system/settings', expected=403, auth='agent')
+ self.assert_settings()
+ require(self.sink.snapshot() == [], 'destination called before ordinary synthetic alert')
+ self.phase('saved-policy-and-unlisted-destination-refusal')
+ self.report('a')
+ self.stop()
+ self.phase('first-child-exit-and-listener-closure')
+ self.start()
+ # Original authenticated cookies and issued token: no relogin or token replacement.
+ self.assert_settings()
+ tokens = self.request('/api/security/tokens')
+ records = tokens.get('tokens', []) if isinstance(tokens, dict) else tokens
+ matches = [r for r in records if r.get('id') == self.token_id]
+ require(len(matches) == 1 and matches[0].get('scopes') == ['agent:report'],
+ 'issued monitoring-only token not retained at restart')
+ self.denied_destination()
+ self.phase('restart-session-token-and-policy-readback')
+ self.report('b')
+ self.stop()
+ self.phase('second-child-exit-and-listener-closure')
+ finally:
+ self.stop()
+
+
+def main():
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument('--binary', type=Path, required=True)
+ parser.add_argument('--expected-source-sha', required=True)
+ parser.add_argument('--receipt', type=Path)
+ args = parser.parse_args()
+ binary = args.binary.resolve(strict=True)
+ binding = source_binding(binary, args.expected_source_sha)
+ report = {'source_binding': binding, 'kind': 'offline-development-source-notification-runtime',
+ 'binary_sha256': hashlib.sha256(binary.read_bytes()).hexdigest(), 'outcome': 'failed'}
+ with tempfile.TemporaryDirectory(prefix='pulse-notification-runtime-') as temporary:
+ data = Path(temporary)
+ sink = Sink()
+ journey = None
+ try:
+ with (data / 'owned-server.log').open('wb') as log:
+ journey = Journey(binary, data, log, sink)
+ journey.run()
+ report['outcome'] = 'passed'
+ except Exception as exc:
+ report['error'] = str(exc) if isinstance(exc, Failure) else type(exc).__name__
+ finally:
+ try:
+ sink.close()
+ report['sink_thread_joined_and_listener_closed'] = True
+ except Exception as exc:
+ report['sink_thread_joined_and_listener_closed'] = False
+ report['cleanup_error'] = type(exc).__name__
+ report['outcome'] = 'failed'
+ if journey:
+ report.update(phases=journey.phases, child_exits=journey.exits,
+ requests=journey.requests, incomplete_request=journey.active_request,
+ deliveries=journey.deliveries, delivery_observations=journey.delivery_observations)
+ report['owned_temporary_data_removed'] = not data.exists()
+ report['source_clean_after'] = subprocess.run(['git', 'diff', '--quiet', 'HEAD'], check=False).returncode == 0
+ if not report['source_clean_after']:
+ report['outcome'] = 'failed'
+ if args.receipt:
+ # Never replace a previous attempt's receipt. No logs or credentials.
+ with args.receipt.open('x', encoding='utf-8') as handle:
+ json.dump(report, handle, sort_keys=True, indent=2)
+ handle.write('\n')
+ print('NOTIFICATION_RUNTIME=' + json.dumps(report, sort_keys=True), flush=True)
+ return 0 if report['outcome'] == 'passed' else 1
+
+
+if __name__ == '__main__':
+ raise SystemExit(main())
diff --git a/scripts/tests/test_notification_runtime.py b/scripts/tests/test_notification_runtime.py
new file mode 100644
index 0000000000..7d9ad138d4
--- /dev/null
+++ b/scripts/tests/test_notification_runtime.py
@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+"""Controls for the source-bound ordinary notification journey, without a server."""
+import contextlib
+import copy
+import importlib.util
+import io
+from pathlib import Path
+from types import SimpleNamespace
+import unittest
+from unittest import mock
+
+ROOT = Path(__file__).resolve().parents[2]
+SPEC = importlib.util.spec_from_file_location('notification_runtime', ROOT / 'scripts/check_notification_runtime.py')
+RUNTIME = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(RUNTIME)
+SHA = 'a' * 40
+
+
+class FakeResponse:
+ def __init__(self, raw=b'{}', status=200):
+ self.raw, self.status = raw, status
+ self.limit = None
+
+ def __enter__(self):
+ return self
+
+ def __exit__(self, *_):
+ return None
+
+ def read(self, limit):
+ self.limit = limit
+ return self.raw
+
+
+class NotificationRuntimeControls(unittest.TestCase):
+ def valid_row(self):
+ return {'path': '/owned-alert', 'body': {'resourceName': 'owned.example.test',
+ 'instance': RUNTIME.PUBLIC_URL, 'event': 'alert', 'type': 'cpu'}}
+
+ def journey(self):
+ return RUNTIME.Journey(Path('/unused-binary'), Path('/unused-data'), io.BytesIO(), None)
+
+ def test_current_ordinary_event_not_resolution_or_invented_firing(self):
+ source = (ROOT / 'internal/notifications/notifications.go').read_text()
+ prepare = source.split('func (n *NotificationManager) prepareWebhookData(', 1)[1]
+ self.assertRegex(prepare, r'Event:\s+"alert",')
+ self.assertEqual(RUNTIME.ORDINARY_EVENT, 'alert')
+ row = self.valid_row()
+ self.assertTrue(all(RUNTIME.delivery_checks(row, 'owned.example.test').values()))
+ for event in ('firing', 'resolved', None):
+ with self.subTest(event=event):
+ row['body']['event'] = event
+ self.assertFalse(RUNTIME.delivery_checks(row, 'owned.example.test')['ordinary_event'])
+
+ def test_all_five_delivery_conditions_are_independent(self):
+ cases = [('path', '/foreign', 'owned_path'),
+ ('resourceName', 'other.example.test', 'resource_identity'),
+ ('instance', 'https://other.example.test', 'saved_public_url'),
+ ('event', 'resolved', 'ordinary_event'),
+ ('type', 'memory', 'cpu_metric')]
+ for field, value, failing in cases:
+ with self.subTest(field=field):
+ row = copy.deepcopy(self.valid_row())
+ target = row if field == 'path' else row['body']
+ target[field] = value
+ checks = RUNTIME.delivery_checks(row, 'owned.example.test')
+ self.assertEqual([key for key, passed in checks.items() if not passed], [failing])
+
+ def test_uncertain_mutation_is_never_replayed_and_keeps_request_identity(self):
+ journey = self.journey()
+ client = mock.Mock()
+ client.open.side_effect = TimeoutError('private provider text must not be printed')
+ journey.client = client
+ with contextlib.redirect_stdout(io.StringIO()) as output:
+ with self.assertRaises(TimeoutError):
+ journey.request('/api/alerts/config', {'privateValue': 'do-not-log'}, method='PUT')
+ client.open.assert_called_once()
+ self.assertEqual(journey.active_request, {'path': '/api/alerts/config', 'method': 'PUT',
+ 'authentication': 'session'})
+ self.assertEqual(journey.requests, [])
+ self.assertNotIn('do-not-log', output.getvalue())
+ self.assertNotIn('private provider text', output.getvalue())
+
+ def test_expected_refusal_does_not_decode_or_print_response_body(self):
+ journey = self.journey()
+ response = FakeResponse(b'private rejection detail', 403)
+ journey.client = mock.Mock()
+ journey.client.open.return_value = response
+ with contextlib.redirect_stdout(io.StringIO()) as output:
+ self.assertIsNone(journey.request('/api/system/settings', expected=403))
+ self.assertEqual(response.limit, RUNTIME.LIMIT + 1)
+ self.assertNotIn('private rejection detail', output.getvalue())
+ self.assertEqual(journey.requests[-1]['status'], 403)
+ self.assertIsNone(journey.active_request)
+
+ def test_oversized_success_stops_after_one_read(self):
+ journey = self.journey()
+ response = FakeResponse(b'x' * (RUNTIME.LIMIT + 1))
+ journey.client = mock.Mock()
+ journey.client.open.return_value = response
+ with contextlib.redirect_stdout(io.StringIO()):
+ with self.assertRaisesRegex(RUNTIME.Failure, 'byte bound'):
+ journey.request('/api/resources')
+ journey.client.open.assert_called_once()
+
+ def test_only_clean_matching_checkout_and_binary_admitted(self):
+ valid = '\tbuild\tvcs=git\n\tbuild\tvcs.revision=' + SHA + '\n\tbuild\tvcs.modified=false\n'
+ cases = [(SHA, 0, valid, True),
+ ('b' * 40, 0, valid, False),
+ (SHA, 1, valid, False),
+ (SHA, 0, valid.replace('modified=false', 'modified=true'), False),
+ (SHA, 0, valid.replace(SHA, 'b' * 40), False),
+ (SHA, 0, valid.replace('vcs=git', 'vcs=hg'), False),
+ (SHA, 0, '', False)]
+ for actual, dirty, binary, allowed in cases:
+ with self.subTest(actual=actual, dirty=dirty, binary=binary):
+ with mock.patch.object(RUNTIME.subprocess, 'check_output', side_effect=[actual, binary]), \
+ mock.patch.object(RUNTIME.subprocess, 'run', return_value=SimpleNamespace(returncode=dirty)):
+ if allowed:
+ self.assertEqual(RUNTIME.source_binding(Path('/owned-binary'), SHA)['checkout_sha'], SHA)
+ else:
+ with self.assertRaises(RUNTIME.Failure):
+ RUNTIME.source_binding(Path('/owned-binary'), SHA)
+
+ def test_malformed_source_identity_stops_before_commands(self):
+ with mock.patch.object(RUNTIME.subprocess, 'check_output') as command:
+ with self.assertRaises(RUNTIME.Failure):
+ RUNTIME.source_binding(Path('/owned-binary'), 'main')
+ command.assert_not_called()
+
+ def test_owned_child_has_no_ambient_credentials_or_telemetry(self):
+ journey = self.journey()
+ child = mock.Mock()
+ child.poll.return_value = None
+ journey.request = mock.Mock(return_value=None)
+ with mock.patch.dict(RUNTIME.os.environ, {'PATH': '/usr/bin', 'AMBIENT_SECRET': 'not-forwarded'}, clear=True), \
+ mock.patch.object(RUNTIME, 'free_port', return_value=7655), \
+ mock.patch.object(RUNTIME.subprocess, 'Popen', return_value=child) as launch:
+ journey.start()
+ env = launch.call_args.kwargs['env']
+ self.assertNotIn('AMBIENT_SECRET', env)
+ self.assertEqual(env['PULSE_TELEMETRY'], 'false')
+ self.assertEqual(env['PULSE_MOCK_MODE'], 'false')
+ self.assertEqual(env['DISCOVERY_ENABLED'], 'false')
+ self.assertEqual(env['BIND_ADDRESS'], '127.0.0.1')
+ self.assertTrue(launch.call_args.kwargs['start_new_session'])
+
+ def test_ci_reuses_the_real_embed_with_exact_source_and_attempt_receipt(self):
+ workflow = (ROOT / '.github/workflows/build-and-test.yml').read_text()
+ section = workflow.split('- name: Check ordinary notification policy and restart', 1)[1]
+ section = section.split('# An audit service failure', 1)[0]
+ self.assertIn('timeout-minutes: 3', section)
+ self.assertIn('--binary "$RUNNER_TEMP/pulse-real-embed"', section)
+ self.assertIn('--expected-source-sha "${{ github.sha }}"', section)
+ self.assertIn('--receipt "$RUNNER_TEMP/pulse-notification-runtime.json"', section)
+ self.assertIn('if: always()', section)
+ self.assertIn('notification-runtime-${{ github.run_id }}-${{ github.run_attempt }}', section)
+ self.assertNotIn('sudo', section)
+ self.assertNotIn('go build', section)
+
+
+if __name__ == '__main__':
+ unittest.main(verbosity=2)