@dra2020/baseclient 1.0.0

package/lib/ot-js/otengine.ts

@@ -0,0 +1,71 @@
+import * as LogAbstract from "../logabstract/all";
+
+import * as OT from "./ottypes";
+import * as OTC from "./otcomposite";
+
+export interface IOTEngine
+{
+  cid(): string;
+  rid(): string;
+
+  toPartialValue(resourceName: string): any;
+
+  startLocalEdit(): OTC.OTCompositeResource;
+  addLocalEdit(e: OTC.OTCompositeResource): void;
+}
+
+export class OTEngine implements IOTEngine
+{
+  ilog: LogAbstract.ILog;
+  onList: any;
+
+	// Constructor
+	constructor(ilog: LogAbstract.ILog)
+		{
+      this.ilog = ilog;
+      this.onList = {};
+		}
+
+  on(eventName: string, cb: any): void
+    {
+      let aCB: any = this.onList[eventName];
+      if (aCB === undefined)
+      {
+        aCB = [];
+        this.onList[eventName] = aCB;
+      }
+      aCB.push(cb);
+    }
+
+  off(eventName: string, cb: any): void
+    {
+      let aCB: any = this.onList[eventName];
+      if (aCB !== undefined)
+      {
+        for (let i: number = 0; i < aCB.length; i++)
+        {
+          if (aCB[i] === cb)
+          {
+            aCB.splice(i, 1);
+            break;
+          }
+        }
+      }
+    }
+
+  emit(eventName: string): void
+    {
+      let aCB: any[] = this.onList[eventName];
+      if (aCB !== undefined)
+        for (let i: number = 0; i < aCB.length; i++)
+          (aCB[i])();
+    }
+
+  cid(): string { return ''; }
+  rid(): string { return ''; }
+
+  toPartialValue(resourceName: string): any { return null; }
+
+  startLocalEdit(): OTC.OTCompositeResource { return null; }
+  addLocalEdit(e: OTC.OTCompositeResource): void { }
+}

package/lib/ot-js/otmap.ts

@@ -0,0 +1,144 @@
+import * as Util from '../util/all';
+
+import * as OT from './ottypes';
+
+// This implements OT for a dictionary of objects. OT is pretty trivial for maps - last wins.
+
+export const OpMapSet = 1;
+export const OpMapDel = 2;
+export type MapEdit = [ number, string, any ];	// Op, Key, Value
+
+export class OTMapResource extends OT.OTResourceBase
+{
+	constructor(rid: string)
+		{
+			super(rid, 'map');
+		}
+	static factory(rid: string): OTMapResource { return new OTMapResource(rid); }
+
+  // Set a property
+  set(p: string, a: any): OTMapResource
+    {
+      this.edits.push([ OpMapSet, p, a ]);
+      return this;
+    }
+
+  // Delete a property
+  del(p: string): OTMapResource
+    {
+      this.edits.push([ OpMapDel, p, 0 ]);
+      return this;
+    }
+
+	// copy an instance
+	copy(): OTMapResource
+		{
+			let c: OTMapResource = new OTMapResource(this.resourceName);
+			for (let i: number = 0; i < this.length; i++)
+			{
+				let e: MapEdit = this.edits[i];
+				c.edits.push([ e[0], e[1], e[2] ]);
+			}
+			return c;
+		}
+
+	// Test whether two operations are effectively equivalent
+	effectivelyEqual(rhs: OTMapResource): boolean
+		{
+			// This should really be a structural error
+			if (this.length != rhs.length)
+				return false;
+
+			// This checks for exact structural equivalency. Really the ordering shouldn't matter for Map so
+			// an improvement to this algorithm would be to be more robust to ordering differences.
+			for (let i: number = 0; i < this.length; i++)
+			{
+				let e1: MapEdit = this.edits[i];
+				let e2: MapEdit = rhs.edits[i];
+				if (e1[0] != e2[0] || e1[1] != e2[1] || !Util.deepEqual(e1[2], e2[2]))
+					return false;
+			}
+			return true;
+		}
+
+	// Core OT algorithm for this type
+	transform(prior: OTMapResource, bPriorIsService: boolean): void
+		{
+			// Last wins - if I'm last, my sets and deletes are all preserved
+			if (bPriorIsService)
+				return;
+
+			// OK, remove any operations (either sets or deletes), that conflict with me
+			// First load in my properties
+			let myEdits: any = this.toObject();
+
+			// Now delete any that are overridden
+			for (let i: number = 0; i < prior.length; i++)
+				delete myEdits[(prior.edits[i])[1]];
+
+			// Now restore edit array from edited object
+			this.fromObject(myEdits);
+		}
+
+	// compose two edit actions
+	compose(rhs: OTMapResource): void 			// throws on error
+		{
+			let o: any = this.toObject();
+			for (let i: number = 0; i < rhs.length; i++)
+			{
+				let eR: MapEdit = rhs.edits[i];
+				o[eR[1]] = [ eR[0], eR[1], eR[2] ];		// Note this overwrites any existing operation on this key, set or del
+			}
+			this.fromObject(o);
+		}
+
+	apply(startValue: any): any
+		{
+			if (startValue == null)
+				startValue = { };
+			for (let i: number = 0; i < this.length; i++)
+			{
+				let e: MapEdit = this.edits[i];
+				switch (e[0])
+				{
+					case OpMapSet:
+						startValue[e[1]] = e[2];
+						break;
+					case OpMapDel:
+						delete startValue[e[1]];
+						break;
+				}
+			}
+			return startValue;
+		}
+
+	minimize(): any
+		{
+			// Effectively removes OpMapDel
+			let o: any = this.apply({});
+			this.edits = [];
+			for (var p in o)
+				if (o.hasOwnProperty(p))
+					this.edits.push([ OpMapSet, p, o[p] ]);
+		}
+
+	loadObject(o: any): any
+		{
+			for (let i: number = 0; i < this.length; i++)
+				o[(this.edits[i])[1]] = this.edits[i];
+			return o;
+		}
+
+	toObject(): any
+		{
+			return this.loadObject({ });
+		}
+
+	fromObject(o: any): void
+		{
+			this.edits = [];
+			for (var p in o)
+				if (o.hasOwnProperty(p))
+					this.edits.push(o[p]);
+		}
+}

package/lib/ot-js/otserverengine.ts

@@ -0,0 +1,329 @@
+// Shared libraries
+import * as LogAbstract from '../logabstract/all';
+
+// Local libraries
+import * as OT from "./ottypes";
+import * as OTC from "./otcomposite";
+import * as OTS from "./otsession";
+import * as OTE from "./otengine";
+
+export const ClientIDForServer: string = '-Server-';
+
+export class OTServerEngine extends OTE.OTEngine
+{
+  // Data members
+  stateServer: OTC.OTCompositeResource;
+  logServer: OTC.OTCompositeResource[];
+  valCache: any;
+  fullCache: any;
+  highSequence: any;
+  clientSequenceNo: number;
+
+  // Constructor
+  constructor(ilog: LogAbstract.ILog, rid: string)
+    {
+      super(ilog);
+
+      this.stateServer = new OTC.OTCompositeResource(rid, "");
+      this.logServer = [];
+      this.highSequence = {};
+      this.clientSequenceNo = 0;
+      this.valCache = {};
+      this.fullCache = null;
+    }
+
+  serverClock(): number
+    {
+      return this.stateServer.clock;
+    }
+
+  rid(): string
+    {
+      return this.stateServer.resourceName;
+    }
+
+  cid(): string
+    {
+      return ClientIDForServer;
+    }
+
+  startLocalEdit(): OTC.OTCompositeResource
+    {
+      return new OTC.OTCompositeResource(this.rid(), this.cid());
+    }
+
+  resetCaches(): void
+    {
+      this.valCache = {};
+      this.fullCache = null;
+    }
+
+  toPartialValue(resourceName: string): any
+    {
+      if (this.valCache[resourceName] === undefined)
+        this.valCache[resourceName] = this.stateServer.toPartialValue(resourceName);
+      return this.valCache[resourceName];
+    }
+
+  toValue(): any
+    {
+      // In general, server does not require this but maybe for testing purposes
+      if (this.fullCache == null)
+        this.fullCache = this.stateServer.toValue();
+      return this.fullCache;
+    }
+
+  getProp(s: string): any
+    {
+      let o = this.toPartialValue('WellKnownName_meta');
+      return o == null ? '' : o[s];
+    }
+
+  getName(): string
+    {
+      return this.getProp('name');
+    }
+
+  getType(): string
+    {
+      return this.getProp('type');
+    }
+
+  getDescription(): string
+    {
+      return this.getProp('description');
+    }
+
+  getCreatedBy(): string
+    {
+      return this.getProp('createdby');
+    }
+
+  getCreateTime(): string
+    {
+      return this.getProp('createtime');
+    }
+
+  getCreatedByName(): string
+    {
+      let s: string = this.getCreatedBy();
+      if (s != '')
+      {
+        let users: any = this.toPartialValue('WellKnownName_users');
+        if (users && users[s] && users[s]['name'])
+          return users[s]['name'];
+      }
+
+      return '';
+    }
+
+  hasSeenEvent(orig: OTC.OTCompositeResource): boolean
+    {
+      let clientSequenceNo: any = this.highSequence[orig.clientID];
+      let bSeen = (clientSequenceNo !== undefined && Number(clientSequenceNo) >= orig.clientSequenceNo);
+      return bSeen;
+    }
+
+  isNextEvent(orig: OTC.OTCompositeResource): boolean
+    {
+      let nSeen: any = this.highSequence[orig.clientID];
+      let bNext = (nSeen === undefined && orig.clientSequenceNo == 0)
+          || (Number(nSeen)+1 == orig.clientSequenceNo);
+      if (! bNext)
+      {
+        if (nSeen === undefined)
+          this.ilog.event( { event: 'OT anomaly: non-zero client seqNo for new client', sessionid: this.stateServer.resourceID } );
+        else
+          this.ilog.event( { event: 'OT anomaly: unexpected client seqNo', sessionid: this.stateServer.resourceID } );
+      }
+      return bNext;
+    }
+
+  rememberSeenEvent(orig: OTC.OTCompositeResource): void
+    {
+      this.highSequence[orig.clientID] = orig.clientSequenceNo;
+    }
+
+  forgetEvents(orig: OTC.OTCompositeResource): void
+    {
+      delete this.highSequence[orig.clientID];
+    }
+  
+  clientHighSequence(cid: string): number
+    {
+      let clientSequenceNo: any = this.highSequence[cid];
+
+      return clientSequenceNo === undefined ? 0 : Number(clientSequenceNo);
+    }
+
+  garbageCollect(): void
+    {
+      let resources = this.toPartialValue('WellKnownName_resource');
+      if (this.stateServer.garbageCollect(resources))
+      {
+        this.resetCaches();
+        this.emit('state');
+      }
+
+      // TODO: Also remove entries from log to minimize memory use.
+    }
+
+  // Function: addServer
+  //
+  // Description:
+  //  This is the server state update processing upon receiving an event from an endpoint.
+  //  The received event is transformed (if possible) and added to the server state.
+  //  The logic here is straight-forward - transform the incoming event so it is relative to
+  //  the current state and then apply.
+
+  addServer(orig: OTC.OTCompositeResource): number
+    {
+      try
+      {
+        // First transform, then add to log
+        let i: number;
+        let a: OTC.OTCompositeResource = orig.copy();
+
+        for (i = this.logServer.length; i > 0; i--)
+        {
+          let aService: OTC.OTCompositeResource = this.logServer[i-1];
+
+          if (aService.clock == a.clock)
+            break;
+        }
+
+        // Handle if we've seen it already (client did not receive ack, probably communication error on response)
+        if (this.hasSeenEvent(orig))
+        {
+          // Treat this as success if we still have event in log - the client did not receive an
+          // ack but is now re-connected and will get resynced correctly.
+          if (i > 0)
+          {
+            this.ilog.event({ sessionid: this.stateServer.resourceID, event: `addServer: duplicate event: no problem` });
+            //console.log('addServer: seen event - handling cleanly');
+            return OTS.ESuccess;
+          }
+          else
+          {
+            //console.log('addServer: seen event - resetting client');
+            this.ilog.event({ sessionid: this.stateServer.resourceID, event: `addServer: duplicate event: resetting client` });
+            this.forgetEvents(orig);  // we are now resetting client in this case, so forget this client
+            return OTS.EClockSeen;
+          }
+        }
+
+        // If this isn't next in sequence, I lost one (probably because I went "back in time"
+        // due to server restart). In that case client is forced to re-initialize (losing local
+        // edits). I also need to re-initialize sequence numbering.
+        if (! this.isNextEvent(orig))
+        {
+          //console.log('addServer: received out-of-order (future) event');
+          this.ilog.event({ sessionid: this.stateServer.resourceID, event: `addServer: received out-of-order event` });
+          this.forgetEvents(orig);
+          return OTS.EClockAnomaly;
+        }
+
+        // Fail if we have discarded that old state
+        if (a.clock >= 0 && i == 0)
+        {
+          this.ilog.event({ sessionid: this.stateServer.resourceID, event: `addServer: received old event` });
+
+          // This should really be ClockFailure which would force the client to resend with a newer
+          // clock value. But there appears to be a bug when session is reloaded that results in
+          // client never getting synced up. So for now force a reset (which might result in some
+          // client edits being discarded).
+          this.forgetEvents(orig);
+          return OTS.EClockReset;
+          //return OTS.EClockFailure;
+        }
+
+        // OK, all good, transform and apply
+        if (i < this.logServer.length)
+        {
+          let aPrior: OTC.OTCompositeResource = this.logServer[i].copy();
+
+          for (i++; i < this.logServer.length; i++)
+            aPrior.compose(this.logServer[i]);
+
+          a.transform(aPrior, true);
+        }
+
+        a.clock = this.stateServer.clock + 1;
+        this.stateServer.compose(a);
+        this.resetCaches();
+        this.emit('state');
+        this.logServer.push(a.copy());
+
+        this.rememberSeenEvent(orig);
+        return OTS.ESuccess;
+      }
+      catch (err)
+      {
+        this.ilog.error('addServer: unexpected exception');
+        this.forgetEvents(orig);
+        return OTS.EClockReset;
+        //return OTS.EClockFailure;
+      }
+    }
+
+  addLocalEdit(orig: OTC.OTCompositeResource): void
+    {
+      orig.clock = this.serverClock();
+      orig.clientSequenceNo = this.clientSequenceNo++;
+      let errno: number = this.addServer(orig);
+    }
+
+  toJSON(): any
+    {
+      let log: any[] = [];
+      for (let i: number = 0; i < this.logServer.length; i++)
+        log.push(this.logServer[i].toJSON());
+      return { state: this.stateServer.toJSON(), highSequence: this.highSequence, log: log };
+    }
+
+  validateLog(): void
+    {
+      // Yikes, invalid log created by bad revision reverting - validate on load and truncate if necessary
+      try
+      {
+        if (this.logServer.length > 0)
+        {
+          let aPrior: OTC.OTCompositeResource = this.logServer[0].copy();
+
+          for (let i: number = 1; i < this.logServer.length; i++)
+            aPrior.compose(this.logServer[i]);
+        }
+      }
+      catch (err)
+      {
+        this.ilog.event({ sessionid: this.stateServer.resourceID, event: `OTServer: corrupted log truncated` });
+        this.logServer = [];
+        this.logServer.push(this.stateServer.copy());
+      }
+    }
+
+  loadFromObject(o: any): void
+    {
+      if (o.state !== undefined)
+      {
+        this.stateServer = OTC.OTCompositeResource.constructFromObject(o.state);
+        this.logServer = [];
+        this.resetCaches();
+        this.emit('state');
+      }
+      if (o.log !== undefined)
+      {
+        for (let i: number = 0; i < o.log.length; i++)
+          this.logServer.push(OTC.OTCompositeResource.constructFromObject(o.log[i]));
+        this.validateLog();
+      }
+      else
+      {
+        this.logServer = [];
+        this.logServer.push(this.stateServer.copy());
+      }
+      if (o.highSequence !== undefined)
+        this.highSequence = o.highSequence;
+      this.clientSequenceNo = this.clientHighSequence(ClientIDForServer) + 1;
+    }
+}