Separate Greif scoring from independently gated Drive archival
This commit is contained in:
1 parent
dbb03c7dfa
commit
18e0e7298f
8 files changed
+559
-150
No files matched your search
@@ -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__':
|
||||
|
||||
Reference in new issue
Block a user