@yz-social/civildefense.io 4.4.4 → 4.5.5

package/public/javascripts/p2pWebNetwork.js

@@ -2,7 +2,6 @@ import { v4 as uuidv4 } from 'uuid';
 import { createNodeIdentity, createAuthorIdentity, geoCellId, geoCellCenter, WIRE_VERSION, KERNEL_VERSION } from '@axona/protocol';
 import { stringToBytes, bytesToString, publishChunkedBytes, receiveChunkedBytes } from '@axona/protocol/std';
 import { connect } from '@axona/protocol/connect.js';
-globalThis.RTCPeerConnection ||= await import('node-datachannel/polyfill').then(ndc => ndc.RTCPeerConnection);
 const { BigInt, URL, File, pica } = globalThis;
 
 /* Example:
@@ -20,21 +19,24 @@ export class P2PWebNetwork {
   static setSessionRegion = resolveSessionRegion;
   static sessionRegion = sessionRegionPromise;
   static async create({infoLogger = console.log, debugLogger,
-		       region = this.sessionRegion, bridgeUrl = 'wss://bridge.axona.net',
+		       region = this.sessionRegion,
+		       bridgeUrl = globalThis.process?.env.BRIDGE_URL || 'wss://bridge.axona.net',
 		      } = {}) {
     // Promise a ready-to-use network peer.
-    const { peer, nodeIdentity, status, disconnect } = await connect({
+    region = await region;
+
+    const { peer, nodeIdentity, transport, status, disconnect } = await connect({
       bridge: bridgeUrl,
-      location: await region,
+      location: region,
       author: false
     });
 
     const network = new this();
-    Object.assign(network, {infoLogger, debugLogger, /*identity, transport, node,*/ disconnector: disconnect, identity: nodeIdentity, peer});
+    Object.assign(network, {infoLogger, debugLogger, disconnector: disconnect, transport, nodeIdentity, peer});
     network.resetStatePromises();
     network.info(`Created network node for kernel ${this.kernelVersion} region 0x${this.regionCode(region.lat, region.lng).toString(16)}.`);
     const { peers, ms } = status;
-    network.info(`Connected ${peers} connections in ${ms.toLocaleString()} ms.`);
+    network.info(`Connected ${peers} connections through ${bridgeUrl} in ${ms.toLocaleString()} ms.`);
     network.attached(network);
     return network;
   }
@@ -161,10 +163,10 @@ export class P2PWebNetwork {
 	const {message, deleted, msgId, signerPubkey, topic, ts} = envelope;
 	this.debug('received', {msgId, topic, ts, signerPubkey, deleted, message});
 	if (deleted) {
-	  handler({subject: msgId, payload: null, agent: signerPubkey, topic, ts}); // fixme remove topic, ts here and below.
+	  handler({tag: msgId, payload: null, agent: signerPubkey, topic, ts}); // fixme remove topic, ts here and below.
 	  return;
 	}
-	handler({...message, agent: signerPubkey, subject: msgId, topic, ts});
+	handler({...message, agent: signerPubkey, tag: msgId, topic, ts});
       };
       await this.peer.sub(topic, callback, {since});
     } else {
@@ -172,17 +174,18 @@ export class P2PWebNetwork {
     }
   }
   static currentPublishIdentity = null;
-  async publish({eventName, region, owner, signWith = this.constructor.currentPublishIdentity, issuedTime = Date.now(), subject, payload, ...rest}) {
+  async publish({eventName, region, owner, signWith = this.constructor.currentPublishIdentity, issuedTime = Date.now(), killTag, payload, ...rest}) {
     // Publish data to subscribers of eventName.
+    if (killTag && payload) throw new Error(`Specify killTag (${killTag}) or payload ($(JSON.stringify(payload)}), but not both.`);
     await this.attachment; // Get connected.
     const topic = {region, name: eventName};
     if (owner) topic.owner = owner;
     const options = {signWith};
-    this.debug('published', {topic, subject, payload, issuedTime, rest, signWith});
+    this.debug('published', {topic, killTag, payload, issuedTime, rest, signWith});
     if (payload) return await this.peer.pub(topic, {issuedTime, payload, ...rest}, options);
     // The next would not normally happen, but until since:'latest' works, we need a way to send a null payload and have the handler delete the entry.
-    if (!subject) return await this.peer.pub(topic, {issuedTime, payload, ...rest}, options);
-    return await this.peer.kill(topic, subject, options);
+    if (!killTag) return await this.peer.pub(topic, {issuedTime, payload, ...rest}, options);
+    return await this.peer.kill(topic, killTag, options);
   }
 
   host() {
@@ -215,10 +218,10 @@ export class P2PWebNetwork {
   }
   // Todo: Integrate with AxonaPeer's complex logging.
   debug(...rest) { // Add debug logspam.
-    this.debugLogger?.(this.identity.id, ...rest);
+    this.debugLogger?.(this.nodeIdentity.id, ...rest);
   }
   info(...rest) { // Add debug logspam.
-    (this.infoLogger || this.debugLogger)?.(this.identity.id, ...rest);
+    (this.infoLogger || this.debugLogger)?.(this.nodeIdentity.id, ...rest);
   }
 }
 export default P2PWebNetwork;

package/public/javascripts/service-manager.js

@@ -2,7 +2,7 @@ const { Request, Response, URL, localStorage, BroadcastChannel } = globalThis;
 import { appVersion } from './versions.js';
 import { resetInactivityTimer, clickTip } from './main.js';
 import { openDisplay } from './display.js';
-import { go } from './map.js';
+import { go } from './alert.js';
 import { Int } from './translations.js';
 
 /*

package/public/javascripts/versions.js

@@ -1,6 +1,6 @@
 import pkg from '../package.json' with {type: 'json'};
 export const appVersion = pkg.version; // Overall semver of app. Used in display, and for comparison by service worker.
-export const dataVersion = appVersion.split('.')[0];  // Compatability differentiator used below.
+export const dataVersion = globalThis.process?.env.EVENT_VERSION || appVersion.split('.')[0];  // Compatability differentiator used below.
 
 export function stripLeadingEmoji(string) { // Return string without any leading emoji (which might be of varying
     // length) followed by an optional emoji break character and any whitespace.

package/public/service-worker.js

@@ -1,6 +1,6 @@
 const { Request, Response, URL, clients} = self;
 // Little point in trying to automatically pull this through package.json, as we need a byte change in THIS file to trigger a new worker.
-const serviceVersion = '4.4.4';
+const serviceVersion = '4.5.4';
 
 async function cacheFirst({request, event}) {
   // Handle request from any cache, else fetch and store it in serviceCache.
@@ -82,7 +82,9 @@ async function cacheSource(version, event) { // Cache source in the given versio
     "javascripts/versions.js",
     "javascripts/main.js",
     "javascripts/display.js",
-    "javascripts/map.js",
+    "javascripts/conversation.js",
+    "javascripts/alert.js",    
+    "javascripts/map.js",    
     "javascripts/hashtags.js",
     "javascripts/s2.js",
     "javascripts/agent.js",
@@ -163,6 +165,7 @@ async function cacheSource(version, event) { // Cache source in the given versio
 
     // TODO: the libraries
   ].map(name => new Request(name, {cache: 'no-store'}))); // Might not be necessary, but if any browsers insist on their own caching...
+
   await Promise.all([
     // These are referenced within material web, but missing. Turns out we don't need them,
     // but let's cache empty responses to keep the console cleaner.
@@ -205,10 +208,10 @@ self.addEventListener('notificationclick', event => {
     clients
       .matchAll({type: 'window', includeUncontrolled: true})
       .then(async clientList => {
-	console.log('notification', {title, body, data, clientList});
+	console.log('notification', {title, body, tag, data, clientList});
         for (const client of clientList) {
 	  console.log('notification click found client');
-	  return client.focus().then(() => client.postMessage({method: 'go', params: {subject: tag, ...data}}));
+	  return client.focus().then(() => client.postMessage({method: 'go', params: {alert: tag, ...data}}));
         }
 	// Client has been closed. Open one.
 	console.log('notification click opening client', data.url);

package/server/app.js

@@ -18,7 +18,7 @@ const argv = yargs(hideBin(process.argv))
       .option('nPortals', {
 	alias: 'p',
 	type: 'number',
-	default: logicalCores,
+	default: Math.min(logicalCores, 5),
 	description: "The number of steady nodes that handle initial connections."
       })
       .option('baseURL', {
@@ -82,7 +82,6 @@ if (cluster.isPrimary) { // Parent process with portal webserver through which c
   // expressWs(app);
   // const Yz = await import('./routes/index.js');
 
-  //console.log(`${cpus()[0].model}, ${logicalCores} logical cores. Starting ${argv.nPortals}.`);
   app.use(express.json());
 
   app.use('/images', express.static(resolve('../public/images'), {
@@ -96,17 +95,19 @@ if (cluster.isPrimary) { // Parent process with portal webserver through which c
 
   app.listen(port);
   console.log('Listening on', port, 'and starting', argv.nPortals, 'nodes.');
-  for (let i = 0; i < argv.nPortals; i++) cluster.fork();
+  for (let i = 0; i < argv.nPortals; i++) {
+    cluster.fork();
+    await new Promise(resolve => setTimeout(resolve, 1e3));
+  }
 } else {
   process.title = 'axona-starting';
   const { P2PWebNetwork, location } = await import('../index.js');
-  await P2PWebNetwork.delay(cluster.worker?.id * 1e3); // One second between startups.
   const network = await P2PWebNetwork.create({region: location});
-  process.title = 'axona-' + network.identity.id;
-  let update = null//setInterval(() => network.info(network.health().axonRoles.map(role => role.topic)), 5e3);
+  process.title = 'axona-' + network.nodeIdentity.id;
+  //let update = setInterval(() => network.info(network.peer.health().axonRoles.length, 'axons'), 10e3);
   process.on('SIGINT', async () => { // Leave the network politely.
     console.log(process.title, 'Shutdown for Ctrl+C');
-    clearInterval(update)
+    //clearInterval(update)
     await network.disconnect();
     process.exit(0);
 });

package/server/getLocation.js

@@ -14,6 +14,6 @@ export const data = await import(filename, {with: { type: 'json' }})
     await fs.writeFile(resolve(filename), string, 'utf8');
     return {default: JSON.parse(string)};
   });
-export const [lat, lng] = data.default.loc.split(',').map(parseFloat);
+export const [lat, lng] = (globalThis.process?.env.LAT_LNG || data.default.loc).split(',').map(parseFloat);
 export const location = {lat, lng};
 

package/server/location.json

@@ -2,6 +2,6 @@
   "uswest/80": "37.4852,-122.2364",
   "useast/89": "40,-75",
   "uscentle/88": "35,-83",
-  "easteu/47": "50,17",  
-  "loc": "37.4852,-122.2364"
+  "easteu/47": "50,17",
+  "loc": "37,-122"
 }

package/spec/axonSpec.js

@@ -1,31 +1,29 @@
 /*
   FIXME: Things that either don't pass, or require undocumented workarounds.
   TODO: Things that ought to be dealt with at some point, but can be deferred until later.
-  CURRENTLY:
-  - This passes (with the FIXMEs in place) in main/3.8.0
-  - This usually fails to receive some of the expected subscription callbacks in testnet/4.3.2, and thus hangs.
 
   To RUN, e.g., in NodeJS:
   - You may need to adjust the path to webTransport. See the first TODO entry.
-  - To switch between them, don't forget to change the wss url a few lines down from hehre.
+  - To switch between them, don't forget to change the wss url a few lines down from here.
   - Have jasmine or the like installed and initialized, and then e.g., npx jasmine spec/axonSpec.js.
 
   It is worth running this several times. It sometimes works once, and then fails or has enormous connect times on another run.
 
   The logging tells the story.
-  Alice, Bob, and Carol are Node instances. (Defined below, followed by the Jasmine test suite.)
+  Alice, Bob, Carol, David, and Emma are Node instances. (Defined below, followed by the Jasmine test suite.)
   Alice and Bob will subscribe and publish to an open/since:'all' topic.
   Carol will join and subscribe between the previous subscriptions and their publications.
   After publications, Bob will politely disconnect, and then restart and subscribe again to get same results.
   Carol will restart without an explicit disconnect, and subscribe again after publications.
   David will join and subscribe after publications.
+  Alice kills her publication and Emma joins.
 */
 const { describe, it, expect, beforeAll, afterAll, BigInt } = globalThis;
 import { createAuthorIdentity, regionCenter, geoCellId, geoCellCenter, WIRE_VERSION, KERNEL_VERSION, deriveTopicId, metricTopic } from '@axona/protocol';
 import { connect } from '@axona/protocol/connect.js';
 globalThis.RTCPeerConnection ||= await import('node-datachannel/polyfill').then(ndc => ndc.RTCPeerConnection);
 
-class Node {  // Stuff we have to do every time. TODO: build something like this into Axona.
+class Node {  // Stuff we have to do every time.
   static version = KERNEL_VERSION;
   log(...rest) {
     console.log(new Date(), this.label, this.nodeIdentity.id.slice(0, 10), ...rest);
@@ -132,10 +130,6 @@ describe("CivilDefense", function () {
       return this.ready = new Promise(resolve => {
 	const handlerTime = Date.now();
 	this.handler = ({message, receiver, ts:pubTime}) => { // Ensure that the receiver's events[currentOperation] is a list, and push message on to it.
-	  // FIXME: ts is undefined for a kill, which is weird:
-	  // 1. I would think that Axona needs the time in order to dedupe and order properly?
-	  // 2. The app may need the time, especially since we are not reliably getting events in ts order. (See "wrong order" comment, below.)
-	  pubTime ||= 0;
 	  const start = Math.max(pubTime, handlerTime);
 	  const elapsed = Date.now() - start;
 	  const data = receiver.events[currentOperation] ||= [];
@@ -175,8 +169,8 @@ describe("CivilDefense", function () {
     currentOperation = 'initial';
     // 'alice pub' starts and completes before 'bob pub' starts.
     aliceKillTag = await alice.publish({message: 'alice pub'});
-    await TestNode.delay(500); // FIXME: without this delay, subscription handlers are called in the wrong order.
     console.log('alice published');
+    await TestNode.delay(500); // FIXME: without this delay, subscription handlers are called in the wrong order.
     await   bob.publish({message: '  bob pub'});
     console.log('bob published');
     //alice.subscribeOpenMetrics({eventName, region:regionCode, handler: envelope => console.log('*** fixme got metrics', envelope)});

package/spec/conversationSpec.js

@@ -0,0 +1,116 @@
+const { describe, it, expect, beforeAll, afterAll, BigInt } = globalThis;
+import { Conversation } from '../public/javascripts/conversation.js';
+
+describe("Conversation", function () {
+  let agent;
+  let conversation;
+  const tag = '123';
+  const payload = 'cake';
+  beforeAll(function () {
+    agent = {handle: 'alice'};
+    conversation = Conversation.ensure({tag, payload, agent});
+  });
+  describe("creation", function () {
+    it("initializes properties.", function () {
+      expect(conversation.agent).toBe(agent);
+      expect(conversation.payload).toBe(payload);
+    });
+    it("remembers conversations with the same tag.", function () {
+      expect(Conversation.ensure({tag, payload, agent})).toBe(conversation);
+    });
+    it("Properties can be ommitted for existing tag.", function () {
+      expect(Conversation.ensure({tag, payload})).toBe(conversation);
+    });
+    it("rejects changes by default.", function () {
+      expect(() => Conversation.ensure({tag, payload: 'other', agent})).toThrow();
+    });
+    describe("caching", function () {
+      let keep = true;
+      let tag = "caching";
+      class CacheConversation extends Conversation {
+	update() { return keep && this; }
+	initialize() { return keep && this; }
+      }
+      it("ends with explicit removal.", function () {
+	let initial = Conversation.ensure({tag, agent, payload});
+	expect(initial).toBeTruthy();
+	expect(Conversation.getItem(tag)).toBe(initial);
+	expect(Conversation.removeItem(tag)).toBe(initial);
+	expect(Conversation.getItem(tag)).toBeFalsy();
+      });
+      describe("deleting data", function () {
+	it("keeps new if not deleting.", function () {
+	  tag = 'keep';
+	  let initial = Conversation.ensure({tag, agent, payload});
+	  expect(initial).toBeTruthy();
+	  expect(Conversation.ensure({tag, agent, payload})).toBe(initial);
+	  expect(Conversation.getItem(tag)).toBe(initial);
+	});
+	it("is skipped if delete data.", function () {
+	  tag = 'skip';	  
+	  let initial = Conversation.ensure({tag, agent});
+	  expect(initial).toBeFalsy();
+	  expect(Conversation.getItem(tag)).toBeFalsy();
+	});
+	it("is removed if delete data.", function () {
+	  tag = 'skip';	  
+	  let initial = Conversation.ensure({tag, agent, payload});
+	  expect(initial).toBeTruthy();
+	  expect(Conversation.getItem(tag)).toBeTruthy();
+	  Conversation.ensure({tag, agent});
+	  expect(Conversation.getItem(tag)).toBeFalsy();
+	});
+      });
+      describe("null/item caching convention", function () {
+	// Do we really need/want this convetion?
+	it("keeps if initialize answers conversation.", function () {
+	  keep = true;
+	  tag = 'keepA';
+	  let initial = CacheConversation.ensure({tag, agent, payload});
+	  expect(initial).toBeTruthy();
+	  expect(CacheConversation.ensure({tag, agent, payload})).toBe(initial);
+	  expect(CacheConversation.getItem(tag)).toBe(initial);
+	});
+	it("is skipped if initialize answers falsy.", function () {
+	  keep = false;
+	  tag = 'skipA';	  
+	  let initial = CacheConversation.ensure({tag, agent, payload});
+	  expect(initial).toBeFalsy();
+	  expect(CacheConversation.getItem(tag)).toBeFalsy();
+	});
+	it("keeps existing if update answers conversation.", function () {
+	  keep = true;
+	  tag = 'keepB';
+	  let initial = CacheConversation.ensure({tag, agent, payload});
+	  expect(CacheConversation.ensure({tag, agent, payload})).toBe(initial);
+	  expect(CacheConversation.ensure({tag, agent, payload})).toBe(initial);
+	  expect(CacheConversation.getItem(tag)).toBe(initial);
+	});
+	it("destroys existing if update answers falsy.", function () {
+	  keep = true;
+	  tag = 'skipB';
+	  let initial = CacheConversation.ensure({tag, agent, payload});
+	  expect(CacheConversation.ensure({tag, agent, payload})).toBe(initial);
+	  keep = false;
+	  expect(CacheConversation.ensure({tag, agent, payload})).toBeFalsy();
+	  expect(CacheConversation.getItem(tag)).toBeFalsy();
+	});
+      });
+    });
+  });
+
+  describe("replies", function () {
+    beforeAll(function () {
+      conversation.ensure({payload: "second", issuedTime: 3, tag: 'z'});
+      conversation.ensure({payload: "deleted", issuedTime: 2, tag: 'y'});
+      conversation.ensure({payload: "first", issuedTime: 1, tag: 'x'});
+      conversation.ensure({payload: null, issuedTime: 4, tag: 'y'});
+    });
+    it("adds replies in timestamp order.", function () {
+      expect(conversation.items.map(reply => reply.payload)).toEqual(["first", "second"]);
+    });
+    it("removes deleted replies.", function () { // fixme eachReply
+      expect(conversation.items.find(reply => !reply.payload)).toBeFalsy();
+    });
+  });
+});