Bind visible inventory to the active view and test concurrent bootstrap

This commit is contained in:
2026-11-17 22:09:45 +01:00
parent 6aa54ef3c1
commit fae4b4562b
2 changed files with 72 additions and 20 deletions
+58 -7
View File
@@ -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()}
+14 -13
View File
@@ -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<T>(
deps: React.DependencyList,
poll = false
) {
const [data, setData] = useState<T | null>(null),
[error, setError] = useState<string | null>(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<typeof setTimeout> | 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<T>(
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) };
}