mirror of
https://github.com/MobileGL-Dev/MobileGL
synced 2026-11-16 06:23:23 +09:00
[MG_Remote, MG_Test, ci] (P7): one constant-time token comparison serves both server policy sites, a configured token shorter than 16 bytes refuses the listen by name, and CI builds flatc so the TCP supervisor smoke runs and must pass
This commit is contained in:
@@ -61,6 +61,34 @@ def require_tcp_proof(path, prefix, discovery, require_run_ahead=False):
|
||||
raise ValueError(f"{case.get('name')}: TCP runtime did not keep requested run-ahead armed")
|
||||
|
||||
|
||||
def require_entries_passed(path, names):
|
||||
"""P7 wave 2-F, PH-7 (1). Named entries must have RUN and passed - a SKIP is a failure here.
|
||||
|
||||
`TcpLane.SupervisorProtocolControls` is registered with SKIP_RETURN_CODE 77 because the
|
||||
script it runs needs flatc, which is deliberately not in the build graph. That is the right
|
||||
behaviour for a developer who has not built one; it is the wrong behaviour for CI, where the
|
||||
lane's whole job is to run the supervisor's protocol controls and "skipped" is
|
||||
indistinguishable from the three commits the entry did not exist. The workflow builds flatc
|
||||
and then names the entry here, so a CI run in which the tool went missing reds by name
|
||||
instead of reporting a green lane that measured less than it says.
|
||||
"""
|
||||
seen = {}
|
||||
for case in ET.parse(path).getroot().iter('testcase'):
|
||||
name = case.get('name')
|
||||
if name not in names:
|
||||
continue
|
||||
if case.find('failure') is not None or case.find('error') is not None:
|
||||
seen[name] = 'failed'
|
||||
elif case.find('skipped') is not None or case.get('status') in ('notrun', 'disabled'):
|
||||
seen[name] = 'skipped'
|
||||
else:
|
||||
seen[name] = 'passed'
|
||||
for name in names:
|
||||
state = seen.get(name, 'absent')
|
||||
if state != 'passed':
|
||||
raise ValueError(f'{name}: required to pass, was {state}')
|
||||
|
||||
|
||||
def tally(path, prefix=None):
|
||||
passed = failed = skipped = 0
|
||||
for case in ET.parse(path).getroot().iter('testcase'):
|
||||
@@ -84,6 +112,8 @@ def main():
|
||||
parser.add_argument('--discovery', help='CTest --show-only=json-v1 output (required for TCP proof)')
|
||||
parser.add_argument('--require-run-ahead', action='store_true',
|
||||
help='Additionally prove actual run-ahead, without fallback or demotion, on each TCP case')
|
||||
parser.add_argument('--require-entry-passed', action='append', default=[], metavar='NAME',
|
||||
help='This ctest entry must be present and passed; a SKIP fails (repeatable)')
|
||||
args = parser.parse_args()
|
||||
if args.prefix in ('DirectGLES.Tcp.', 'DirectGLES.TcpDevice.') and not args.discovery:
|
||||
parser.error('TCP arm proof requires --discovery to locate each private role log')
|
||||
@@ -94,6 +124,8 @@ def main():
|
||||
passed, failed, skipped = tally(args.junit, prefix=prefix)
|
||||
if prefix in ('DirectGLES.Tcp.', 'DirectGLES.TcpDevice.'):
|
||||
require_tcp_proof(args.junit, prefix, args.discovery, args.require_run_ahead)
|
||||
if args.require_entry_passed:
|
||||
require_entries_passed(args.junit, args.require_entry_passed)
|
||||
except Exception as exc: # a malformed file is not "zero of everything"
|
||||
print(f"junit_tally: cannot prove {args.junit}: {exc}", file=sys.stderr)
|
||||
return 1
|
||||
|
||||
@@ -87,6 +87,35 @@ class Accounting(unittest.TestCase):
|
||||
with self.assertRaises(ValueError):
|
||||
tally.require_tcp_proof(junit, 'DirectGLES.Tcp.', discovery)
|
||||
|
||||
def test_a_skipped_required_entry_is_not_a_pass(self):
|
||||
"""P7 wave 2-F, PH-7 (1). The four states of a NAMED entry, and only one of them passes.
|
||||
|
||||
`TcpLane.SupervisorProtocolControls` skips itself (exit 77) when flatc is absent, which
|
||||
is correct for a developer and wrong for CI - the workflow now builds flatc and names the
|
||||
entry, so `skipped` has to red here exactly as `failed` and `absent` do. Written as four
|
||||
cases rather than one because the one that matters is `skipped`, and a check that only
|
||||
looked for <failure> would have let it through, which is the whole defect.
|
||||
"""
|
||||
tally = module('junit_tally')
|
||||
name = 'TcpLane.SupervisorProtocolControls'
|
||||
bodies = {
|
||||
'passed': f'<testcase name="{name}" />',
|
||||
'skipped': f'<testcase name="{name}"><skipped /></testcase>',
|
||||
'notrun': f'<testcase name="{name}" status="notrun" />',
|
||||
'failed': f'<testcase name="{name}"><failure /></testcase>',
|
||||
'absent': '<testcase name="TcpLane.AccountingControls" />',
|
||||
}
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
junit = Path(directory) / 'junit.xml'
|
||||
for state, body in bodies.items():
|
||||
junit.write_text(f'<testsuite>{body}</testsuite>')
|
||||
if state == 'passed':
|
||||
tally.require_entries_passed(junit, [name])
|
||||
continue
|
||||
with self.assertRaises(ValueError, msg=state) as raised:
|
||||
tally.require_entries_passed(junit, [name])
|
||||
self.assertIn(name, str(raised.exception))
|
||||
|
||||
def test_equal_counts_do_not_hide_a_missing_case(self):
|
||||
parity = module('spawn_lane_parity')
|
||||
a, b = 'TriangleScenario.Draw', 'TriangleScenario.Read'
|
||||
|
||||
@@ -1,11 +1,18 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Exercise a real TCP supervisor's Busy, token, version, build-policy and REAP controls.
|
||||
"""Exercise a real TCP supervisor's LISTEN, Busy, token, version, build-policy and REAP controls.
|
||||
|
||||
P7 wave 0 registered this script as `TcpLane.SupervisorProtocolControls` in
|
||||
MG_IntegrationTest/CMakeLists.txt. Until then it was referenced by NOTHING in the tree - no
|
||||
ctest entry, no workflow step - so the four controls it asserts had been green or red for an
|
||||
unknown number of commits and nobody would have known which.
|
||||
|
||||
P7 wave 2-F, PH-7 (1)(2)(3) (ID-P7-3), added the two LISTEN controls at the top of main(). They
|
||||
are the negative controls for the policy AuthToken.h now owns, and both are end-to-end against a
|
||||
real supervisor process because that is the only place the policy is reachable: an in-process
|
||||
unit test of `SocketTransport::Listen` can assert the return code but not that an operator who
|
||||
misconfigured a token gets a dead server with a named reason rather than a live one that silently
|
||||
serves loopback only.
|
||||
|
||||
It needs flatc, which is deliberately absent from the default build graph (gen_protocol.py's
|
||||
header block says why). Resolution order is gen_protocol.py's, minus the build-it-for-you arm:
|
||||
--flatc, then $MOBILEGL_FLATC_EXECUTABLE, then <repo>/../flatc-build/flatc. With none of them
|
||||
@@ -34,6 +41,18 @@ ROOT = Path(__file__).resolve().parents[2]
|
||||
# uses and ctest has no opinion of its own.
|
||||
kSkipExit = 77
|
||||
|
||||
# PH-7 (3): >= AuthToken.h's kMinimumAuthTokenBytes (16). The old value, `p65-smoke-token`, was
|
||||
# fifteen bytes - one short - which is a pleasing accident and exactly the kind of token the
|
||||
# minimum exists to refuse. The value is arbitrary; its LENGTH is the fixture.
|
||||
kToken = 'p7-ph-f-supervisor-token'
|
||||
assert len(kToken) >= 16, kToken
|
||||
# A token that is a credential in every respect except length.
|
||||
kShortToken = 'p7-ph-f-short'
|
||||
assert len(kShortToken) < 16, kShortToken
|
||||
|
||||
# ServerMain's `SocketTransport::Listen(...) != MOBILEGL_OK` arm.
|
||||
kListenRefusedExit = 72
|
||||
|
||||
|
||||
def resolve_flatc(explicit):
|
||||
"""gen_protocol.py's order, without its build-it-for-you arm. None when there is none."""
|
||||
@@ -77,7 +96,7 @@ def receive(peer, schema):
|
||||
raise RuntimeError(f'unexpected first control reply {kind}')
|
||||
|
||||
|
||||
def hello(schema, flatbuffers, fingerprint=0, major=1, token='p65-smoke-token', identifier=b'MGLC'):
|
||||
def hello(schema, flatbuffers, fingerprint=0, major=1, token=kToken, identifier=b'MGLC'):
|
||||
builder = flatbuffers.Builder(512)
|
||||
build = builder.CreateString('intentionally-different-build-for-p65-control')
|
||||
auth = builder.CreateString(token)
|
||||
@@ -108,18 +127,62 @@ def hello(schema, flatbuffers, fingerprint=0, major=1, token='p65-smoke-token',
|
||||
return struct.pack('<4sI', b'MGLF', len(payload)) + payload
|
||||
|
||||
|
||||
@contextmanager
|
||||
def supervisor(server, log, same_build=False):
|
||||
with socket.socket() as reserve:
|
||||
reserve.bind(('127.0.0.1', 0))
|
||||
port = reserve.getsockname()[1]
|
||||
base = log.with_suffix('.library.log')
|
||||
def supervisor_environment(log, token, same_build=False):
|
||||
"""The env a supervisor is started with, minus everything ServerMain's scrub catches."""
|
||||
env = dict(os.environ, MOBILEGL_IPC_ROLE='server', MOBILEGL_IPC_DIAL='no',
|
||||
MOBILEGL_IPC_TOKEN='p65-smoke-token', MOBILEGL_IPC_REQUIRE_SAME_BUILD=str(int(same_build)),
|
||||
MOBILEGL_IPC_LOG_FORWARD='0', MOBILEGL_LOG_FILE_PATH=str(base))
|
||||
MOBILEGL_IPC_REQUIRE_SAME_BUILD=str(int(same_build)),
|
||||
MOBILEGL_IPC_LOG_FORWARD='0', MOBILEGL_LOG_FILE_PATH=str(log))
|
||||
if token is None:
|
||||
env.pop('MOBILEGL_IPC_TOKEN', None)
|
||||
else:
|
||||
env['MOBILEGL_IPC_TOKEN'] = token
|
||||
for name in ('MOBILEGL_TRANSPORT', 'MOBILEGL_IPC_SERVER_PATH', 'MOBILEGL_IPC_RING_MB', 'MOBILEGL_IPC_STAGE_MB',
|
||||
'MOBILEGL_IPC_CONTROL', 'MOBILEGL_IPC_ENDPOINT', 'MOBILEGL_BACKEND_TYPE'):
|
||||
env.pop(name, None)
|
||||
return env
|
||||
|
||||
|
||||
def free_loopback_port():
|
||||
with socket.socket() as reserve:
|
||||
reserve.bind(('127.0.0.1', 0))
|
||||
return reserve.getsockname()[1]
|
||||
|
||||
|
||||
def refused_listen(server, log, endpoint, token):
|
||||
"""Start a supervisor that must NOT come up, and return (exit code, everything it said).
|
||||
|
||||
PH-7 (2)(3), ID-P7-3. Both listen refusals are asserted this way rather than through
|
||||
SocketTransport::Listen's return code, because the property is not "the function returns
|
||||
PROTOCOL_MISMATCH" - it is that the PROCESS dies, says which policy killed it, and does not
|
||||
leave a half-configured server listening. A supervisor that degraded to loopback-only after a
|
||||
misconfigured token would pass a return-code test and fail an operator.
|
||||
"""
|
||||
base = log.with_suffix('.library.log')
|
||||
env = supervisor_environment(base, token)
|
||||
with log.open('wb') as output:
|
||||
child = subprocess.Popen([server, endpoint, '--serve'], env=env,
|
||||
stdout=output, stderr=output, start_new_session=True)
|
||||
try:
|
||||
code = child.wait(timeout=30)
|
||||
except subprocess.TimeoutExpired:
|
||||
# THE RED SHAPE OF THIS CONTROL IS A SUPERVISOR THAT CAME UP, so it is still listening
|
||||
# and would answer the next control's peers. Killed here rather than left for the
|
||||
# assertion below, which is what makes the red a red and not a cascade.
|
||||
os.killpg(child.pid, signal.SIGKILL)
|
||||
child.wait(timeout=10)
|
||||
code = None
|
||||
text = log.read_text(errors='replace')
|
||||
role = base.with_name(base.stem + '.server' + base.suffix)
|
||||
if role.is_file():
|
||||
text += role.read_text(errors='replace')
|
||||
return code, text
|
||||
|
||||
|
||||
@contextmanager
|
||||
def supervisor(server, log, same_build=False):
|
||||
port = free_loopback_port()
|
||||
base = log.with_suffix('.library.log')
|
||||
env = supervisor_environment(base, kToken, same_build=same_build)
|
||||
with log.open('wb') as output:
|
||||
child = subprocess.Popen([server, f'tcp://127.0.0.1:{port}', '--serve'], env=env,
|
||||
stdout=output, stderr=output, start_new_session=True)
|
||||
@@ -247,6 +310,32 @@ def main():
|
||||
schema = {name: importlib.import_module('MobileGL.Wire.' + name)
|
||||
for name in ('CtrlEnvelope', 'CtrlMsg', 'Hello', 'LinkTerms', 'Refuse', 'Welcome')}
|
||||
evidence = {}
|
||||
|
||||
# ---- PH-7 (2)(3), ID-P7-3: THE TWO LISTEN REFUSALS -------------------------------
|
||||
#
|
||||
# Both are the SAME policy from two directions: a listener that can be reached from off
|
||||
# this machine has to have a credential, and a credential has to be one.
|
||||
#
|
||||
# (a) No token, non-loopback bind. The mechanism has been in the tree since P6.5
|
||||
# (SocketTransport.cpp's ListenTcp) and the plan's own gate row called it "done
|
||||
# (mechanism)" with the caveat that nothing referenced it. This is the reference.
|
||||
# (b) A token shorter than 16 bytes, on LOOPBACK, where a short token is otherwise
|
||||
# harmless. It still fails, and that is the ruling: a configured token is either a
|
||||
# credential or a refusal, never a warning. Before this package a one-byte token
|
||||
# unlocked `tcp://0.0.0.0`.
|
||||
code, said = refused_listen(args.server, args.out / 'wildcard-no-token.log',
|
||||
'tcp://0.0.0.0:40699', None)
|
||||
assert code == kListenRefusedExit, (code, said)
|
||||
assert 'Refuse{Authentication}' in said, said
|
||||
evidence['wildcard_listen_without_a_token'] = {'exit': code, 'line': next(
|
||||
l.strip() for l in said.splitlines() if 'Refuse{Authentication}' in l)}
|
||||
short = f'tcp://127.0.0.1:{free_loopback_port()}'
|
||||
code, said = refused_listen(args.server, args.out / 'short-token.log', short, kShortToken)
|
||||
assert code == kListenRefusedExit, (code, said)
|
||||
assert 'Refuse{Authentication}' in said and 'minimum is 16' in said, said
|
||||
assert kShortToken not in said, 'the refusal printed the token'
|
||||
evidence['short_token_listen'] = {'exit': code, 'line': next(
|
||||
l.strip() for l in said.splitlines() if 'Refuse{Authentication}' in l)}
|
||||
with supervisor(args.server, args.out / 'supervisor.log') as (port, process, serverLog):
|
||||
with pair(port) as held:
|
||||
with pair(port) as second:
|
||||
|
||||
Reference in New Issue
Block a user