Separate Greif scoring from independently gated Drive archival

This commit is contained in:
Codex committed 2026-11-19 21:43:44 +08:00
1 parent dbb03c7dfa
commit 18e0e7298f
8 files changed
+559 -150

No files matched your search

+151 -112
View File
@@ -1,6 +1,6 @@
"""Exercise the real Greif custody gate with synthetic Drive API metadata."""
"""CPU replay of independent local scoring and the complete Drive gate."""
from contextlib import ExitStack
from contextlib import contextmanager, ExitStack
import hashlib
from pathlib import Path
from tempfile import TemporaryDirectory
@@ -16,123 +16,162 @@ from track_b_gino_shapenet_entry import read, save, sha
EVIDENCE = {}
OWNER_EMAIL = 'fixture-owner@example.invalid'
ARCHIVE_ID = 'fixture-archive'
CASE = 'synthetic_part'
PROJECT = dict(private_drive_folder_id=acl.PROJECT_FOLDER)
@contextmanager
def replay():
with TemporaryDirectory() as folder, ExitStack() as stack:
root = Path(folder)
for name in ('contract.json','models-frozen.json','predictions-frozen.json'):
save(root/name,{})
archive = root/'gino-greif-models-and-predictions.zip'
archive.write_bytes(b'synthetic immutable archive')
digest, size = sha(archive), archive.stat().st_size
bundle = dict(path=str(archive),sha256=digest,bytes=size,contract_sha256=sha(root/'contract.json'),
model_index_sha256=sha(root/'models-frozen.json'),prediction_index_sha256=sha(root/'predictions-frozen.json'))
save(root/'drive-upload-index.json',bundle)
compare, reference = root/'comparison.json', root/'reference.json'
save(reference,dict(status='COMPLETE',rows=[dict(case=CASE)]+[
dict(case=f'other-{i}') for i in range(551)]))
save(compare,dict(roster=[dict(case=CASE,fold=0)],h2_score=dict(path=str(reference),sha256=sha(reference))))
pilot, query = root/'pilot.json', root/'query.json'
save(pilot,{})
save(query,dict(rows=[dict(case=CASE,included=True)]))
pins={str(p):sha(p) for p in (pilot,query)}
c=dict(budgets={'score_cpu_seconds':3600},comparison_contract=str(compare),comparison_contract_sha256=sha(compare))
forecasts=[dict(case=CASE,fold=0,seed=s) for s in (0,1)]
owner=dict(id='fixture-owner-id',type='user',role='owner',emailAddress=OWNER_EMAIL)
outside=dict(id='foreign-id',type='user',role='reader',emailAddress='foreign@example.invalid',
permissionDetails=[dict(inherited=True,inheritedFrom=acl.PROJECT_MY_DRIVE_ROOT)])
linked=dict(id='anyone',type='anyone',role='reader',allowFileDiscovery=False)
queried=[]
state=dict(before='project',after='project')
def provider(path, args, token):
assert token=='fixture-token'
queried.append((path,args.get('pageToken')))
after_upload=(root/'drive-readback.json').exists()
mode=state['after' if after_upload else 'before']
if path.endswith('/permissions'):
assert args['includePermissionsForView']=='published'
if mode=='missing-permissions':
return {}
if mode=='anyone-link-page2' and path==ARCHIVE_ID+'/permissions':
if args.get('pageToken')=='page-two':
return dict(permissions=[linked])
return dict(permissions=[owner],nextPageToken='page-two')
if mode=='inherited-outside' and path==acl.PROJECT_MY_DRIVE_ROOT+'/permissions':
return dict(permissions=[owner,outside])
if mode=='domain' and path==ARCHIVE_ID+'/permissions':
return dict(permissions=[owner,dict(id='domain',type='domain',role='reader')])
return dict(permissions=[owner])
item=dict(id=path,ownedByMe=True,trashed=False,version='1',permissionIds=[owner['id']],mimeType=acl.FOLDER_TYPE)
if path==ARCHIVE_ID:
return dict(item,parents=[acl.PROJECT_FOLDER],mimeType='application/zip',size=str(size),sha256Checksum=digest)
if path==acl.PROJECT_FOLDER:
return dict(item,parents=[acl.PROJECT_MY_DRIVE_ROOT])
if path=='root':
return dict(item,id=acl.PROJECT_MY_DRIVE_ROOT)
raise AssertionError('Unexpected item beyond the fixed project chain')
stack.enter_context(patch.dict('os.environ',CUDA_VISIBLE_DEVICES=''))
custody.os.environ.pop(acl.TOKEN_FD,None)
stack.enter_context(patch.object(entry,'ROOT',root))
# No Drive authority field is supplied to the local scoring path.
stack.enter_context(patch.object(entry,'authorize',return_value=({},0.)))
for k,v in dict(PILOT=pilot,QUERY=query,PINS=pins).items():
stack.enter_context(patch.object(custody,k,v))
stack.enter_context(patch.object(custody,'frozen',return_value=([],forecasts)))
stack.enter_context(patch.object(custody.resource,'setrlimit'))
stack.enter_context(patch.object(acl,'PROJECT_OWNER_SHA256',hashlib.sha256(OWNER_EMAIL.encode()).hexdigest()))
stack.enter_context(patch.object(acl,'_get_json',side_effect=provider))
stack.enter_context(patch.object(custody,'summary',return_value={}))
targets=stack.enter_context(patch.object(custody,'target_array',return_value='synthetic target'))
def read_case(*_):
start=read(root/'score/custody-start.json')
assert start['model_manifest_sha256']==sha(root/'models-frozen.json')
assert start['manifest_sha256']==sha(root/'predictions-frozen.json')
targets({},CASE)
return {'case':CASE}
stack.enter_context(patch.object(custody,'one_case',side_effect=read_case))
def mark_uploaded():
# The legacy assertion is intentionally still present and is ignored.
save(root/'drive-readback.json',dict(sha256Checksum=digest,size=str(size),parent_id=acl.PROJECT_FOLDER,
file_id=ARCHIVE_ID,project_private=True,contract_sha256=bundle['contract_sha256']))
yield root,c,state,queried,targets,mark_uploaded
class CustodyACL(unittest.TestCase):
def replay(self, mode):
with TemporaryDirectory() as folder, ExitStack() as stack:
root = Path(folder)
for name in ('contract.json','models-frozen.json','predictions-frozen.json'):
save(root/name, {})
archive = root/'gino-greif-models-and-predictions.zip'
archive.write_bytes(b'synthetic immutable archive')
digest, size = sha(archive), archive.stat().st_size
scope = dict(private_drive_folder_id=acl.PROJECT_FOLDER)
if mode == 'other-folder':
scope['private_drive_folder_id'] = 'out-of-scope'
bundle = dict(path=str(archive), sha256=digest, bytes=size,contract_sha256=sha(root/'contract.json'),
model_index_sha256=sha(root/'models-frozen.json'),
prediction_index_sha256=sha(root/'predictions-frozen.json'))
save(root/'drive-upload-index.json',bundle)
# This is the assertion that formerly bypassed all permission checks.
save(root/'drive-readback.json',dict(sha256Checksum=digest,size=str(size),
parent_id=scope['private_drive_folder_id'],file_id=ARCHIVE_ID,project_private=True,
contract_sha256=bundle['contract_sha256']))
case = 'synthetic_part'
compare = root/'comparison.json'
reference = root/'reference.json'
save(reference,dict(status='COMPLETE',rows=[dict(case=case)]+[
dict(case=f'other-{i}') for i in range(551)]))
save(compare,dict(roster=[dict(case=case,fold=0)],h2_score=dict(path=str(reference),sha256=sha(reference))))
pilot, query = root/'pilot.json',root/'query.json'
save(pilot,{})
save(query,dict(rows=[dict(case=case,included=True)]))
pins = {str(p):sha(p) for p in (pilot,query)}
c=dict(budgets={'score_cpu_seconds':3600},comparison_contract=str(compare),comparison_contract_sha256=sha(compare))
forecasts=[dict(case=case,fold=0,seed=s) for s in (0,1)]
owner=dict(id='fixture-owner-id',type='user',role='owner',emailAddress=OWNER_EMAIL)
inherited=dict(id='foreign-id',type='user',role='reader',emailAddress='foreign@example.invalid',
permissionDetails=[dict(inherited=True,inheritedFrom=acl.PROJECT_MY_DRIVE_ROOT)])
linked=dict(id='anyone',type='anyone',role='reader',allowFileDiscovery=False)
calls=[]
def provider(path, query, token):
self.assertEqual(token,'fixture-token')
calls.append((path, query.get('pageToken')))
if path.endswith('/permissions'):
self.assertEqual(query['includePermissionsForView'],'published')
if mode=='missing-acl' and path==ARCHIVE_ID+'/permissions':
return {}
if mode=='anyone-link-page2' and path==ARCHIVE_ID+'/permissions':
if query.get('pageToken')=='fixture-page-2':
return dict(permissions=[linked])
return dict(permissions=[owner],nextPageToken='fixture-page-2')
if mode=='inherited-outside' and path==acl.PROJECT_MY_DRIVE_ROOT+'/permissions':
return dict(permissions=[owner,inherited])
return dict(permissions=[owner])
item=dict(id=path,ownedByMe=True,trashed=False,version='1',permissionIds=[owner['id']],mimeType=acl.FOLDER_TYPE)
if path==ARCHIVE_ID:
return dict(item,parents=[acl.PROJECT_FOLDER],mimeType='application/zip',size=str(size),sha256Checksum=digest)
if path==acl.PROJECT_FOLDER:
return dict(item,parents=[acl.PROJECT_MY_DRIVE_ROOT])
if path=='root':
return dict(item,id=acl.PROJECT_MY_DRIVE_ROOT)
raise AssertionError('Unexpected item outside the fixed chain')
def test_scoring_with_no_drive_capability_or_receipts(self):
with replay() as (root,c,_,queried,targets,_):
self.assertEqual(custody.score(c),0)
targets.assert_called_once()
self.assertEqual(queried,[])
self.assertFalse((root/'drive-preflight.json').exists())
EVIDENCE['score_with_drive_unavailable']=dict(synthetic_target_reads=1,provider_queries=0)
stack.enter_context(patch.dict('os.environ',CUDA_VISIBLE_DEVICES=''))
stack.enter_context(patch.object(entry,'ROOT',root))
stack.enter_context(patch.object(entry,'authorize',return_value=(scope,0.)))
for k,v in dict(PILOT=pilot,QUERY=query,PINS=pins).items():
stack.enter_context(patch.object(custody,k,v))
stack.enter_context(patch.object(custody,'frozen',return_value=([],forecasts)))
stack.enter_context(patch.object(custody.resource,'setrlimit'))
stack.enter_context(patch.object(acl,'PROJECT_OWNER_SHA256',hashlib.sha256(OWNER_EMAIL.encode()).hexdigest()))
if mode=='no-transport':
custody.os.environ.pop(acl.TOKEN_FD,None)
else:
stack.enter_context(patch.object(acl,'_credential',return_value='fixture-token'))
stack.enter_context(patch.object(acl,'_get_json',side_effect=provider))
stack.enter_context(patch.object(custody,'summary',return_value={}))
read_target=stack.enter_context(patch.object(custody,'target_array',return_value='synthetic target'))
def test_missing_or_external_parent_permission_stops_before_upload(self):
for mode in ('missing-permissions','inherited-outside'):
with self.subTest(mode=mode), replay() as (root,c,state,queried,targets,_):
state['before']=mode
with patch.object(acl,'_credential',return_value='fixture-token'):
self.assertEqual(custody.drive_preflight(c,PROJECT),1)
self.assertEqual(read(root/'drive-preflight.json')['status'],'HOLD_FURTHER_DRIVE_UPLOADS')
self.assertEqual(read(root/'drive-preflight-hold.json')['stage'],'BEFORE_UPLOAD')
self.assertFalse((root/'drive-readback.json').exists())
targets.assert_not_called()
EVIDENCE['before_'+mode]=dict(provider_queries=queried,upload_eligible=False)
def case_reached(*_):
proof=root/'score/drive-acl-evidence.json'
self.assertEqual(read(root/'score/custody-start.json')['drive_acl_evidence_sha256'],sha(proof))
read_target({},case)
return dict(case=case)
def test_missing_archive_evidence_link_only_and_domain_stop_further_uploads(self):
for mode in ('missing-permissions','anyone-link-page2','domain','inherited-outside'):
with self.subTest(mode=mode), replay() as (root,c,state,queried,targets,mark_uploaded):
with patch.object(acl,'_credential',return_value='fixture-token'):
self.assertEqual(custody.drive_preflight(c,PROJECT),0)
state['after']=mode
mark_uploaded()
self.assertEqual(custody.drive_readback(c,PROJECT),1)
count=len(queried)
with self.assertRaises(PermissionError):
custody.drive_preflight(c,PROJECT)
self.assertEqual(len(queried),count)
if mode=='anyone-link-page2':
self.assertIn((ARCHIVE_ID+'/permissions','page-two'),queried)
self.assertTrue((root/'drive-readback.json').exists())
self.assertEqual(read(root/'drive-upload-hold.json')['stage'],'AFTER_UPLOAD')
self.assertFalse((root/'drive-upload-verified.json').exists())
targets.assert_not_called()
EVIDENCE['after_'+mode]=dict(further_uploads_blocked=True,evidence_retained=True,
provider_queries=queried)
reader=stack.enter_context(patch.object(custody,'one_case',side_effect=case_reached))
if mode=='project-only':
self.assertEqual(custody.score(c),0)
read_target.assert_called_once()
proof=read(root/'score/drive-acl-evidence.json')
self.assertEqual([x['file_id'] for x in proof['chain']],
[ARCHIVE_ID,acl.PROJECT_FOLDER,acl.PROJECT_MY_DRIVE_ROOT])
EVIDENCE[mode] = dict(custody_reached=True,synthetic_reads=1,provider_queries=calls)
else:
with self.assertRaises(PermissionError):
custody.score(c)
reader.assert_not_called()
read_target.assert_not_called()
self.assertFalse((root/'score').exists())
EVIDENCE[mode] = dict(custody_reached=False,synthetic_reads=0,provider_queries=calls)
def test_complete_private_project_folder_and_archive_acl_pass_both_checks(self):
with replay() as (root,c,_,queried,targets,mark_uploaded):
with patch.object(acl,'_credential',return_value='fixture-token'):
self.assertEqual(custody.drive_preflight(c,PROJECT),0)
before=read(root/'drive-preflight.json')
self.assertTrue(before['does_not_authorize_upload'])
self.assertEqual([row['file_id'] for row in before['drive']['chain']],
[acl.PROJECT_FOLDER,acl.PROJECT_MY_DRIVE_ROOT])
mark_uploaded()
self.assertEqual(custody.drive_readback(c,PROJECT),0)
evidence=read(root/'drive-upload-verified.json')
self.assertEqual(evidence['status'],'PRIVATE_DRIVE_ARCHIVE_VERIFIED')
self.assertEqual([r['file_id'] for r in evidence['chain']],
[ARCHIVE_ID,acl.PROJECT_FOLDER,acl.PROJECT_MY_DRIVE_ROOT])
self.assertEqual(evidence['sha256'],sha(root/'gino-greif-models-and-predictions.zip'))
targets.assert_not_called()
EVIDENCE['normal_private_archive']=dict(provider_queries=queried,verified=True)
def test_missing_current_transport_and_missing_effective_acl_stop(self):
for mode in ('no-transport','missing-acl'):
self.replay(mode)
def test_unlisted_link_reader_is_blocked_even_on_later_page(self):
self.replay('anyone-link-page2')
self.assertIn((ARCHIVE_ID+'/permissions','fixture-page-2'), EVIDENCE['anyone-link-page2']['provider_queries'])
def test_inherited_non_project_user_is_blocked(self):
self.replay('inherited-outside')
def test_wrong_folder_is_rejected_before_provider_access(self):
self.replay('other-folder')
self.assertEqual(EVIDENCE['other-folder']['provider_queries'],[])
def test_project_acl_and_entire_ancestry_positive_control(self):
self.replay('project-only')
def test_no_existing_transport_prevents_any_provider_attempt(self):
with replay() as (root,c,_,queried,targets,_):
self.assertEqual(custody.drive_preflight(c,PROJECT),1)
self.assertEqual(queried,[])
self.assertEqual(read(root/'drive-preflight-hold.json')['stage'],'BEFORE_UPLOAD')
targets.assert_not_called()
EVIDENCE['no_transport']=dict(provider_queries=0,upload_eligible=False)
if __name__=='__main__':