From fae4b4562bf31ed137a0a6dbe27251b3f56dd4cb Mon Sep 17 00:00:00 2001 From: Kevin Janssen Date: Tue, 17 Nov 2026 22:09:45 +0100 Subject: [PATCH] Bind visible inventory to the active view and test concurrent bootstrap --- tests/release_bootstrap_gateway.py | 65 ++++++++++++++++++++++++++---- web/src/resource.tsx | 27 +++++++------ 2 files changed, 72 insertions(+), 20 deletions(-) diff --git a/tests/release_bootstrap_gateway.py b/tests/release_bootstrap_gateway.py index e652e6b..270e8e9 100644 --- a/tests/release_bootstrap_gateway.py +++ b/tests/release_bootstrap_gateway.py @@ -1,6 +1,7 @@ """Exercise release publication and fresh enrollment on disposable loopback TLS/PostgreSQL.""" import argparse import base64 +from concurrent.futures import ThreadPoolExecutor from contextlib import ExitStack import hashlib import http.client @@ -23,6 +24,7 @@ import uuid ROOT = Path(__file__).resolve().parents[1] sys.path.insert(0, str(ROOT / 'tools')) import agent_release as release +import dev_customer_starters as starters TENANT = '11111111-1111-4111-8111-111111111111' @@ -139,7 +141,61 @@ def test(binary, directory, stack): return {'artifact_id':str(uuid.uuid4()),'sha256':hashlib.sha256(data).hexdigest(),'bytes':len(data)} original_worker=(artifacts/'rmm-agent-updater').read_bytes() original=stable_blob(original_worker) + # Model a previously published source catalog. Both customers must be able to + # reference exactly the same signed IDs, and each needs its own verified objects. + tenant_b = '22222222-2222-4222-8222-222222222222' + b_store = state/'objects'/tenant_b + b_store.mkdir(mode=0o700) + for name, blob in zip(release.FILES[release.LINUX], [*ma['artifacts'], original]): + release.save_once(b_store/blob['sha256'], (artifacts/name).read_bytes()) + agent, helper = ma['artifacts'] + env_raw = release.encoded(a) + sha = lambda data: hashlib.sha256(data).hexdigest() + def scoped(tenant, statement): + return sql('rmm_app','rmm', f"BEGIN; SET LOCAL app.tenant_id='{tenant}'; {statement}; COMMIT;") + for blob in ma['artifacts']: + scoped(tenant_b, f"""INSERT INTO agent_update_artifacts(tenant_id,artifact_id,sha256,size_bytes) + VALUES('{tenant_b}','{blob["artifact_id"]}','{blob["sha256"]}',{blob["bytes"]})""") + scoped(tenant_b, f"""INSERT INTO agent_update_releases(tenant_id,release_id,platform,release_sequence, + manifest_sha256,envelope_sha256,envelope,agent_artifact_id,agent_sha256,agent_bytes, + helper_artifact_id,helper_sha256,helper_bytes) VALUES('{tenant_b}','{ma["release_id"]}', + '{release.LINUX}',1,'{sha(release.encoded(ma))}','{sha(env_raw)}',decode('{env_raw.hex()}','hex'), + '{agent["artifact_id"]}','{agent["sha256"]}',{agent["bytes"]}, + '{helper["artifact_id"]}','{helper["sha256"]}',{helper["bytes"]})""") + # This source itself uses a starter worker, with a different pin from the global default. + b_worker = original_worker + b'tenant B starter' + b_desc = stable_blob(b_worker) + release.save_once(b_store/b_desc['sha256'], b_worker) + scoped(tenant_b, f"""INSERT INTO customer_starter_workers VALUES('{tenant_b}','{release.LINUX}', + '{b_desc["sha256"]}',{b_desc["bytes"]})""") + starters.publish(tenant_b,release.LINUX,ma['release_id'],root=state,database_container=db,service_uid=os.getuid()) + dist = state/'config/customer-starters' + packaged = json.loads((dist/(release.LINUX+'.json')).read_bytes()) + assert packaged['worker']['sha256'] == b_desc['sha256'] + assert scoped(TENANT, 'SELECT count(*) FROM agent_update_releases') == '0' + # A partial distribution must leave the catalog empty and is repairable by republishing. + (dist/helper['sha256']).unlink() + ask('POST',path+'/enrollment-tokens',{},auth,status=409) + assert scoped(TENANT, 'SELECT count(*) FROM agent_update_artifacts') == '0' + assert scoped(TENANT, 'SELECT count(*) FROM customer_starter_workers') == '0' + starters.publish(tenant_b,release.LINUX,ma['release_id'],root=state,database_container=db,service_uid=os.getuid()) + with ThreadPoolExecutor(max_workers=2) as workers: + issues = [workers.submit(ask,'POST',path+'/enrollment-tokens',{},auth) for _ in range(2)] + first, retry = [request.result()[1] for request in issues] + assert first['release_platforms'] == retry['release_platforms'] == [release.LINUX] + assert first['token'] != retry['token'] + for customer in (TENANT, tenant_b): + assert scoped(customer, 'SELECT release_id FROM agent_update_releases') == ma['release_id'] + assert scoped(customer, 'SELECT count(*) FROM agent_update_artifacts') == '2' + first_auth = {'Authorization':'Enrollment '+first['token']} + current_path = '/agent/v1/bootstrap/current?platform='+release.LINUX + metadata = ask('GET',current_path,headers=first_auth)[1] + assert metadata['release_envelope'] == a and metadata['tenant_id'] == TENANT + assert ask('GET','/agent/v1/bootstrap/updater?platform='+release.LINUX,headers=first_auth)[1] == b_worker + print('Empty customer receives source signed IDs, separate verified objects and its protected worker; incomplete seed can retry') upload(original,original_worker) + release.save_once(state/'config'/('linux-bootstrap.'+TENANT+'.json'), + release.encoded({'current':{'sha256':original['sha256'],'bytes':original['bytes']},'previous':[]})) def send_pair(manifest): for name,blob in zip(release.FILES[release.LINUX],manifest['artifacts']): upload(blob,(artifacts/name).read_bytes()) @@ -205,16 +261,11 @@ def test(binary, directory, stack): assert ask('GET',bootstrap,headers=credential)[1]['updater']==pin updater('0'*64,404) assert json.loads((state/'config/linux-bootstrap.json').read_bytes())['updater_sha256']==original['sha256'] - # Set up B's already published default worker. This fixture has only one - # interactive dev principal (tenant A), so seed the independent tenant directly. - tenant_b='22222222-2222-4222-8222-222222222222' + # B keeps its independent worker when A has a per-customer rotation. token_b=secrets.token_hex(32) sql('rmm_app','rmm',f"BEGIN; SET LOCAL app.tenant_id='{tenant_b}'; SELECT issue_enrollment_token('{hashlib.sha256(token_b.encode()).hexdigest()}'); COMMIT;") - b_store=state/'objects'/tenant_b - b_store.mkdir(mode=0o700) - shutil.copy2(state/'objects'/TENANT/original['sha256'],b_store/original['sha256']) b_auth={'Authorization':'Enrollment '+token_b} - assert ask('GET','/agent/v1/bootstrap/updater?platform='+release.LINUX,headers=b_auth)[1]==original_worker + assert ask('GET','/agent/v1/bootstrap/updater?platform='+release.LINUX,headers=b_auth)[1]==b_worker ask('GET','/agent/v1/bootstrap/updater?platform='+release.LINUX+'&sha256='+new['sha256'],headers=b_auth,status=404) print('worker-only publication preserves the signed release, tenant isolation and in-flight downloads; stale predecessor rejected') install={'token':token['token'],'csr_pem':(tls/'device.csr').read_text()} diff --git a/web/src/resource.tsx b/web/src/resource.tsx index 7bd9ddd..aa1e921 100644 --- a/web/src/resource.tsx +++ b/web/src/resource.tsx @@ -1,4 +1,4 @@ -import React, { useEffect, useState } from 'react'; +import React, { useEffect, useMemo, useState } from 'react'; export const errorText = (error: unknown) => error instanceof Error ? error.message : 'Unbekannter Fehler'; @@ -14,24 +14,23 @@ export function useResource( deps: React.DependencyList, poll = false ) { - const [data, setData] = useState(null), - [error, setError] = useState(null), - [revision, setRevision] = useState(0); + const [revision, setRevision] = useState(0); + const requestKey = useMemo(() => ({}), [...deps, revision]); + const [response, setResponse] = useState<{ key: object; data: T | null; error: string | null } | null>(null); useEffect(() => { let active = true; const controller = new AbortController(); let timer: ReturnType | undefined; - setData(null); - setError(null); const run = async () => { try { const result = await load(controller.signal); - if (active) { - setData(result); - setError(null); - } + if (active) setResponse({ key: requestKey, data: result, error: null }); } catch (e) { - if (active) setError(errorText(e)); + if (active) setResponse(previous => ({ + key: requestKey, + data: previous?.key === requestKey ? previous.data : null, + error: errorText(e) + })); } finally { if (active && poll) timer = setTimeout(run, 4000); } @@ -42,6 +41,8 @@ export function useResource( controller.abort(); clearTimeout(timer); }; - }, [...deps, revision]); - return { data, error, reload: () => setRevision((v) => v + 1) }; + }, [requestKey]); + // A view change can render before its effect runs. Only expose data for the active request. + const current = response?.key === requestKey ? response : null; + return { data: current?.data ?? null, error: current?.error ?? null, reload: () => setRevision((v) => v + 1) }; }