Make synchronizer use the received MutableObject in the validation of ops, instead of lifting one from the database.

Author: sbazerque

src/data/model/MutableObject.ts

@@ -502,7 +502,7 @@ abstract class MutableObject extends HashedObject {
     }
 
     createSyncAgent(peerGroupAgent: PeerGroupAgent) : StateSyncAgent {
-        return new HeaderBasedSyncAgent(peerGroupAgent, this.getLastHash(), this.getResources() as Resources, this._acceptedMutationOpClasses, this.getSyncAgentStateFilter());
+        return new HeaderBasedSyncAgent(peerGroupAgent, this, this.getResources() as Resources, this._acceptedMutationOpClasses, this.getSyncAgentStateFilter());
         //return new TerminalOpsSyncAgent(peerGroupAgent, this.getLastHash(), this.getStore(), this._acceptedMutationOpClasses);
     }
 

src/mesh/agents/state/HeaderBasedSyncAgent.ts

@@ -1,4 +1,4 @@
-import { Hash, HashedObject, HashedSet, Literal, LiteralUtils, MutationOp } from 'data/model';
+import { Hash, HashedObject, HashedSet, Literal, LiteralUtils, MutableObject, MutationOp } from 'data/model';
 import { AgentPod } from 'mesh/service/AgentPod';
 import { Store } from 'storage/store';
 import { Logger, LogLevel } from 'util/logging';
@@ -27,7 +27,8 @@ class HeaderBasedSyncAgent extends PeeringAgentBase implements StateSyncAgent {
 
     static MaxRequestsPerRemote = 2;
 
-    mutableObj: Hash;
+    mutableObj: MutableObject;
+    mutableObjHash: Hash;
     acceptedMutationOpClasses: string[];
     stateOpFilter?: StateFilter;
 
@@ -50,10 +51,11 @@ class HeaderBasedSyncAgent extends PeeringAgentBase implements StateSyncAgent {
     controlLog: Logger;
     messageLog: Logger;
 
-    constructor(peerGroupAgent: PeerGroupAgent, mutableObj: Hash, resources: Resources, acceptedMutationOpClasses : string[], stateOpFilter?: StateFilter) {
+    constructor(peerGroupAgent: PeerGroupAgent, mutableObj: MutableObject, resources: Resources, acceptedMutationOpClasses : string[], stateOpFilter?: StateFilter) {
         super(peerGroupAgent);
 
-        this.mutableObj = mutableObj;
+        this.mutableObj  = mutableObj;
+        this.mutableObjHash = mutableObj.hash();
         this.acceptedMutationOpClasses = acceptedMutationOpClasses;
         this.stateOpFilter = stateOpFilter;
 
@@ -75,7 +77,7 @@ class HeaderBasedSyncAgent extends PeeringAgentBase implements StateSyncAgent {
 
 
     getAgentId(): string {
-        return HeaderBasedSyncAgent.syncAgentIdFor(this.mutableObj, this.peerGroupAgent.peerGroupId);
+        return HeaderBasedSyncAgent.syncAgentIdFor(this.mutableObjHash, this.peerGroupAgent.peerGroupId);
     }
 
     ready(pod: AgentPod): void {
@@ -111,7 +113,7 @@ class HeaderBasedSyncAgent extends PeeringAgentBase implements StateSyncAgent {
 
         let isNew = false;
 
-        if (state instanceof HeaderBasedState && state.mutableObj === this.mutableObj) {
+        if (state instanceof HeaderBasedState && state.mutableObj === this.mutableObjHash) {
 
 
 
@@ -174,18 +176,18 @@ class HeaderBasedSyncAgent extends PeeringAgentBase implements StateSyncAgent {
     // Monitoring local state for changes: 
 
     watchStoreForOps() {
-        this.store.watchReferences('targetObject', this.mutableObj, this.opCallback);
+        this.store.watchReferences('targetObject', this.mutableObjHash, this.opCallback);
     }
 
     unwatchStoreForOps() {
-        this.store.removeReferencesWatch('targetObject', this.mutableObj, this.opCallback);
+        this.store.removeReferencesWatch('targetObject', this.mutableObjHash, this.opCallback);
     }
 
     async opCallback(opHash: Hash): Promise<void> {
 
         if (this.terminated) return;
 
-        this.controlLog.trace('Op ' + opHash + ' found for object ' + this.mutableObj + ' in peer ' + this.peerGroupAgent.getLocalPeer().endpoint);
+        this.controlLog.trace('Op ' + opHash + ' found for object ' + this.mutableObjHash + ' in peer ' + this.peerGroupAgent.getLocalPeer().endpoint);
 
         let op = await this.store.load(opHash) as MutationOp;
         if (this.shouldAcceptMutationOp(op)) {
@@ -202,7 +204,7 @@ class HeaderBasedSyncAgent extends PeeringAgentBase implements StateSyncAgent {
             const fields    = LiteralUtils.getFields(literal);
             const className = LiteralUtils.getClassName(literal);
 
-            if (fields['targetObject'] !== undefined && fields['targetObject']._hash === this.mutableObj &&
+            if (fields['targetObject'] !== undefined && fields['targetObject']._hash === this.mutableObjHash &&
                 this.acceptedMutationOpClasses.indexOf(className) >= 0) {
 
                 valid = true;
@@ -229,7 +231,7 @@ class HeaderBasedSyncAgent extends PeeringAgentBase implements StateSyncAgent {
     }*/
 
     private async loadStateFromStore(): Promise<HeaderBasedState> {
-        let terminalOpsInfo = await this.store.loadTerminalOpsForMutable(this.mutableObj);
+        let terminalOpsInfo = await this.store.loadTerminalOpsForMutable(this.mutableObjHash);
 
         if (terminalOpsInfo === undefined) {
             terminalOpsInfo = {terminalOps: []};
@@ -244,7 +246,7 @@ class HeaderBasedSyncAgent extends PeeringAgentBase implements StateSyncAgent {
 
             terminalOpHeaders.push(terminalOpHeader as OpHeader)
         }
-        const state = HeaderBasedState.create(this.mutableObj, terminalOpHeaders);
+        const state = HeaderBasedState.create(this.mutableObjHash, terminalOpHeaders);
 
         if (this.stateOpFilter === undefined) {
             return state;
@@ -257,7 +259,7 @@ class HeaderBasedSyncAgent extends PeeringAgentBase implements StateSyncAgent {
         const stateHash = state.hash();
 
         if (this.stateHash === undefined || this.stateHash !== stateHash) {
-            HeaderBasedSyncAgent.controlLog.trace('Found new state ' + stateHash + ' for ' + this.mutableObj + ' in ' + this.peerGroupAgent.getLocalPeer().endpoint);
+            HeaderBasedSyncAgent.controlLog.trace('Found new state ' + stateHash + ' for ' + this.mutableObjHash + ' in ' + this.peerGroupAgent.getLocalPeer().endpoint);
             this.state = state;
             this.stateHash = stateHash;
             this.stateOpHeadersByOpHash = new Map();
@@ -278,17 +280,17 @@ class HeaderBasedSyncAgent extends PeeringAgentBase implements StateSyncAgent {
 
     private shouldAcceptMutationOp(op: MutationOp): boolean {
 
-        return this.mutableObj === op.targetObject?.hash() &&
+        return this.mutableObjHash === op.targetObject?.hash() &&
                this.acceptedMutationOpClasses.indexOf(op.getClassName()) >= 0;
     }
 
     async lastStoredOpsDescription(limit=25) {
 
-        const load = await this.store.loadByReference('targetObject', this.mutableObj, { order: 'desc', limit: limit});
+        const load = await this.store.loadByReference('targetObject', this.mutableObjHash, { order: 'desc', limit: limit});
 
         const last = load.objects.length === limit? 'last ' : '';
 
-        let contents = 'Showing ' + last + load.objects.length + ' ops in store for ' + this.mutableObj + '\n';
+        let contents = 'Showing ' + last + load.objects.length + ' ops in store for ' + this.mutableObjHash + '\n';
 
         let idx=0;
         for (const op of load.objects) {

src/mesh/agents/state/history/HistoryProvider.ts

@@ -175,8 +175,8 @@ class HistoryProvider {
                 requestArrivalTimestamp: Date.now()
             };
 
-            if (msg.mutableObj !== this.syncAgent.mutableObj) {
-                const detail = 'Rejecting request ' + respInfo.request.requestId + ', mutableObj is ' + respInfo.request.mutableObj + ' but it should be ' + this.syncAgent.mutableObj;
+            if (msg.mutableObj !== this.syncAgent.mutableObjHash) {
+                const detail = 'Rejecting request ' + respInfo.request.requestId + ', mutableObj is ' + respInfo.request.mutableObj + ' but it should be ' + this.syncAgent.mutableObjHash;
                 this.rejectRequest(respInfo, 'invalid-request', detail);
                 return;
             } else {
@@ -285,7 +285,7 @@ class HistoryProvider {
 
         // Generate history fragment to include in the response
 
-        const respDelta = new HistoryDelta(this.syncAgent.mutableObj, this.syncAgent.store);
+        const respDelta = new HistoryDelta(this.syncAgent.mutableObjHash, this.syncAgent.store);
 
         let maxHistory = req.maxHistory;
         let maxOps     = req.maxLiterals;

src/mesh/agents/state/history/HistorySynchronizer.ts

@@ -106,12 +106,12 @@ class HistorySynchronizer {
 
         this.syncAgent = syncAgent;
 
-        this.localStateFragment   = new HistoryFragment(this.syncAgent.mutableObj);
+        this.localStateFragment   = new HistoryFragment(this.syncAgent.mutableObjHash);
         this.remoteStateFragments = new Map();
 
-        this.discoveredHistory = new HistoryFragment(this.syncAgent.mutableObj);
+        this.discoveredHistory = new HistoryFragment(this.syncAgent.mutableObjHash);
 
-        this.requestedOps      = new HistoryFragment(this.syncAgent.mutableObj);
+        this.requestedOps      = new HistoryFragment(this.syncAgent.mutableObjHash);
 
         this.requests = new Map();
 
@@ -427,7 +427,7 @@ class HistorySynchronizer {
         const msg: RequestMsg = {
             type: MessageType.Request,
             requestId: new RNGImpl().randomHexString(128),
-            mutableObj: this.syncAgent.mutableObj,
+            mutableObj: this.syncAgent.mutableObjHash,
             mode: mode,
             maxLiterals: MaxLiteralsPerRequest,
             maxHistory: MaxHistoryPerRequest
@@ -609,7 +609,7 @@ class HistorySynchronizer {
         let remoteState = this.remoteStateFragments.get(remote);
 
         if (remoteState === undefined) {
-            remoteState = new HistoryFragment(this.syncAgent.mutableObj);
+            remoteState = new HistoryFragment(this.syncAgent.mutableObjHash);
             this.remoteStateFragments.set(remote, remoteState);
         }
 
@@ -859,6 +859,7 @@ class HistorySynchronizer {
             if (resp.sendingOps !== undefined && resp.sendingOps.length > 0) {
                 reqInfo.receivedObjects = new Context();
                 reqInfo.receivedObjects.resources = this.syncAgent.resources;
+                reqInfo.receivedObjects.objects.set(this.syncAgent.mutableObjHash, this.syncAgent.mutableObj);
             }
 
             if (resp.omittedObjsOwnershipProofs !== undefined &&
@@ -983,7 +984,7 @@ class HistorySynchronizer {
                 }
 
             } else {
-                const detail = '\n'+this.logPrefix+'\nReceived op '+ literal.hash +' is not valid for mutableObj ' + this.syncAgent.mutableObj + ', in response to request ' + reqInfo.request.requestId + '(op sequence: ' + reqInfo.nextOpSequence + ')';
+                const detail = '\n'+this.logPrefix+'\nReceived op '+ literal.hash +' is not valid for mutableObj ' + this.syncAgent.mutableObjHash + ', in response to request ' + reqInfo.request.requestId + '(op sequence: ' + reqInfo.nextOpSequence + ')';
                 this.cancelRequest(reqInfo, 'invalid-literal', detail);
                 return false;
             }
@@ -1135,7 +1136,7 @@ class HistorySynchronizer {
             // Validate received history
 
             if (resp.history !== undefined) {
-                receivedHistory = new HistoryFragment(this.syncAgent.mutableObj);
+                receivedHistory = new HistoryFragment(this.syncAgent.mutableObjHash);
 
                 // Verify all received op history literals and create a fragment from 'em:
                 for (const opHistoryLiteral of resp.history) {
@@ -1194,7 +1195,7 @@ class HistorySynchronizer {
 
             // The reply MAY contain ops we didn't request, if they directly follow our stated current state.
             // Make a history fragment using this additional ops to check that is indeed the case.
-            const additionalOpsHistory = new HistoryFragment(this.syncAgent.mutableObj);
+            const additionalOpsHistory = new HistoryFragment(this.syncAgent.mutableObjHash);
 
             if (resp.sendingOps !== undefined) {
                 for (const hash of resp.sendingOps) {