@yz-social/civildefense.io 5.0.0 → 5.1.1

package/public/javascripts/pubsub.js

@@ -37,18 +37,26 @@ const PUBLISH_TIMEOUT = 24 * 60 * 60e3;      // Delete after 24 hours.
 const TRACK_TIMEOUT = PUBLISH_TIMEOUT;
 
 let invoke;
-export function setReceiver(receiver) { // Set the means by which we fire events over a connection.
+export function setSender(receiver) { // Set the means by which we fire events over a direct connection.
   invoke = receiver; // E.g. (nodeId, handlerId, envelope) => getSocket(nodeId).send(JSON.stringify([handlerId, envelope]));
 }
-async function fireEvent(...rest) { // Send envelope to a subscribed hander.
-  try {
-    invoke(...rest);
-  } catch (error) { // Error sending, e.g., nodeTag is gone and we had not yet noticed.
+
+function directFireEvent(...rest) { // Send envelope to a subscribed hander.
+  return invoke(...rest).catch(async error => { // Error sending, e.g., nodeTag is gone and we had not yet noticed.
+    console.log(new Date(), error.message || error);
     const [nodeTag, id, envelope] = rest;
     await deleteSubscriber(nodeTag);
-    const subscription = await store.get('sub', await deriveTopicId(envelope.topic), id);
-    if (subscription) push(envelope, subscription, PUBLISH_TIMEOUT);
-  }
+    const topic = envelope.topic;
+    const topicId = await deriveTopicId(topic);
+    const subscription = await store.get('sub', topicId, id);
+    console.log('push error activation:', topic, topicId, id, subscription);
+    if (subscription) push(envelope, subscription, PUBLISH_TIMEOUT); // Do not wait for push.
+  });
+}
+
+let burstQueue = Promise.resolve();
+function sendBurst(thunk) { // Serialize outbursts so that we and a client that subscribed to a bunch both have time to send/accept ack's.
+  burstQueue = burstQueue.then(thunk);
 }
 
 export async function subscribe(topic, nodeTag, {since = 'all', pushData = null}) {
@@ -58,27 +66,34 @@ export async function subscribe(topic, nodeTag, {since = 'all', pushData = null}
   const id = uuidv4();
   await store.set('sub', topicId, nodeTag, id, SUBSCRIPTION_TIMEOUT);
   // If pushData, store it separately by nodeTag until it needs to be activated.
-  if (pushData) await store.set('track', topicId, nodeTag, pushData, TRACK_TIMEOUT);
-  else store.remove('track', topicId, nodeTag);
+  if (pushData) {
+    console.log('track push sub', topicId, nodeTag, pushData.endpoint.slice(0, 80));
+    await store.set('track', topicId, nodeTag, pushData, TRACK_TIMEOUT);
+  } else {
+    store.remove('track', topicId, nodeTag);
+  }
   if (since) { // invoke handler on any sticky data, but only after we have told client the subscription id. TODO: is there a better way?
     setTimeout(async () => {
-      let lastEnvelope = null, lastTime = 0;
-      for (const envelope of await store.values('pub', topicId)) {
-	switch (since) {
-	case 'all':
-	  await fireEvent(nodeTag, id, envelope);
-	  break;
-	case 'latest':
-	  if (envelope.ts > lastTime) {
-	    lastTime = envelope.ts;
-	    lastEnvelope = envelope;
+      //sendBurst(async () => {
+	let lastEnvelope = null, lastTime = 0;
+	for (const envelope of await store.values('pub', topicId)) {
+	  if (!await store.get('sub', topicId, nodeTag)) return;
+	  switch (since) {
+	  case 'all':
+	    await directFireEvent(nodeTag, id, envelope);
+	    break;
+	  case 'latest':
+	    if (envelope.ts > lastTime) {
+	      lastTime = envelope.ts;
+	      lastEnvelope = envelope;
+	    }
+	    break;
+	  default: // Must be a timestamp
+	    if (envelope.ts === since) await directFireEvent(nodeTag, id, envelope);
 	  }
-	  break;
-	default: // Must be a timestamp
-	  if (envelope.ts === since) await fireEvent(nodeTag, id, envelope);
 	}
-      }
-      if (lastEnvelope) fireEvent(nodeTag, id, lastEnvelope);
+	if (lastEnvelope) directFireEvent(nodeTag, id, lastEnvelope);
+      //});
     }, 100);
   }
   return {topicName: {name, region, owner, write}, topicId, id};
@@ -89,26 +104,28 @@ export async function unsubscribe(topic, nodeTag, {pushId}) {
   // Additionally, an activated sticky pushId will be removed if specified - it is the nodeTag from a previous session).
 
   const topicId = await deriveTopicId(topic);
-  let id = await store.remove('sub', topicId, nodeTag);
+  let id = await store.remove('sub', topicId, nodeTag), tracked;
   // Also remove any sticky push subscription:
   // If not yet promoted to sub, it's in track under our current, protectable nodeTag.
   await store.remove('track', topicId, nodeTag);
   // Otherwise, it might have been activated in sub under pushId (i.e., a previous session nodeTag).
   // TODO: pushId should probably be a JWS that was signed in the subscribing node's previous session by the pushId,
   // thus proving that the request actually came from the succcessor to that node.
-  if (pushId) pushId = await store.remove('sub', topicId, pushId);  // pushId must match that used during activation.
-  return {ok: !!id, id, pushId}; // Axona doesn't return the id(s) of the subscription(s), but it is convenient for us to do so.
+  if (pushId) tracked = await store.remove('sub', topicId, pushId);  // pushId must match that used during activation.
+  //if (pushId) console.log('normal unsubscribe remove tracking', pushId, tracked?.endpoint.slice(0, 80));
+  return {ok: !!id, id, pushId: tracked}; // Axona doesn't return the id(s) of the subscription(s), but it is convenient for us to do so.
 }
 
 export async function deleteSubscriber(nodeTag) {
-  // The node is gone: lost connection, or fireEvent failed.
-
+  // The node is gone: lost connection, or directFireEvent failed.
+  console.log('deleteSubscriber', nodeTag);
   for (const topicId of await store.topics('sub')) { // Remove in all topics.
-    await store.remove('sub', topicId, nodeTag);
+    const sub = await store.remove('sub', topicId, nodeTag);
+    if (sub) console.log('removed sub', topicId, nodeTag, sub);
     // Activate pending push subscription, if any, by moving it from 'track' to active 'sub'.
     const pushSubscription = await store.remove('track', topicId, nodeTag);
     if (pushSubscription) {
-      //console.log('activiting', topicId, nodeTag, pushSubscription);
+      console.log('activating', topicId, nodeTag, pushSubscription.endpoint.slice(0, 80));
       await store.set('sub', topicId, nodeTag, pushSubscription, TRACK_TIMEOUT);
     }
   }
@@ -122,9 +139,11 @@ async function handleEvents(topicId, envelope)  {
   // Each sub's handlerInfo can be an ordinary subscription nodeId, or a sticky push subscription data.
   return Promise.all(subs.map(([nodeTag, handlerInfo]) => {
     if (isConnectedSubscription(handlerInfo)) { // nodeId
-      return fireEvent(nodeTag, handlerInfo, envelope);
+      return directFireEvent(nodeTag, handlerInfo, envelope);
     } else { // activated sticky push subscription data object.
-      return push(envelope, handlerInfo, PUBLISH_TIMEOUT);
+      console.log('pushing for nodeId', nodeTag, handlerInfo?.endpoint.slice(0, 80));
+      push(envelope, handlerInfo, PUBLISH_TIMEOUT);
+      return null; // Do not wait for push
     }
   }));
 }
@@ -153,3 +172,5 @@ export async function unpublish(topic, msgId, {signWith}) {
   await handleEvents(topicId, envelope);
   return {ok: true};
 }
+
+export const operators = {setSender, subscribe, unsubscribe, deleteSubscriber, publish, unpublish};

package/public/javascripts/push.js

@@ -23,6 +23,6 @@ export async function push(envelope, {applicationServerKey, applicationId, ...su
   // to correlate known topic activity with someone's push records obtained from the service.
   const reply = await webpush.sendNotification?.(subscription, JSON.stringify(envelope), options)
       .catch(error => console.error(`${error.message} for push ${subscription?.endpoint}.`));
-  //console.log('push', {envelope, subscription, options, reply});
+  console.log('push', {msgId: envelope.msgId, endpoint: subscription.endpoint, status: reply?.statusCode});
   return reply;
 }

package/public/javascripts/service-manager.js

@@ -1,6 +1,6 @@
 const { Request, Response, URL, localStorage, BroadcastChannel } = globalThis;
 import { appVersion } from './versions.js';
-import { resetInactivityTimer, clickTip, closeAbout } from './main.js';
+import { resetInactivityTimer, clickTip, closeAbout, delay } from './main.js';
 import { openDisplay } from './display.js';
 import { go, getShareableURL } from './alert.js';
 import { Int } from './translations.js';
@@ -79,7 +79,10 @@ async function installUpdate(event, newVersion) {
   event.stopPropagation();
   event.target.textContent = Int`Installing...`; // In case there is some delay, tell the user what we're trying to do. Will be cleared with reload.
   event.target.disabled = true;
-  await caches.delete(appVersion); // Must be before cacheSource, or we'll just recache the same files!
+  // Must be before cacheSource, or we'll just recache the same files!
+  const cacheNames = await caches.keys();
+  await Promise.all(cacheNames.map(name => caches.delete(name))); // Includes ALL cache storage, such as seen notifications.
+
   await cacheSource(newVersion);
   closeAbout();
   // Reload, but convince all browsers to re-"fetch" (through the new service worker that is now running).
@@ -141,6 +144,8 @@ await navigator.serviceWorker
 	resolveCached?.(params);
 	break;
       case 'go':
+	await delay();
+	resetInactivityTimer();
 	go(params);
 	break;
       default:

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 = '5.0.0';
+const serviceVersion = '5.1.1';
 
 const cacheList = [ // The files we need.
   "/",
@@ -174,7 +174,7 @@ self.addEventListener('activate', async event => {
   // Apply to running clients now, so that first fresh install sees updatefound event.
   // Otherwise, the service worker wouldn't fire until the code NEXT time the page loads after
   // registration, and thus the initial load would not see any updatefound events.
-  event.waitUntil(self.clients.claim());
+  event.waitUntil(self.clients.claim().then(expireStaleAlerts));
 });
 
 self.addEventListener('fetch', event => {
@@ -203,8 +203,36 @@ async function cacheSource(version, event) { // Cache source in the given versio
   return version;
 }
 
-const issued = new Set();
-function showNotification({lat, lng, issuedTime, hashtag, alert, body = '', force = false}) { // Promise to show a platform notification. There are two paths to here:
+// The service worker is stopped and restarted for events, and so we can't keep an in-memory set of issued alerts.
+// Here we keep it in cache, and manually clean up expired entries.
+const alertCache = 'alerts-' + serviceVersion;
+function hasSeenAlert(seenKey) { // Have we noted seenKey before?
+  return caches.open(alertCache).then(cache => cache.match(seenKey));
+}
+function noteSeenAlert(seenKey, issuedTime) { // Record seenKey and it's expiration timestamp.
+  return caches.open(alertCache).then(cache => cache.put(seenKey, new Response(issuedTime.toString())));
+}
+const ALERT_EXPIRATION_MS = 24 * 60 * 60e3;
+let lastMaintenance = 0;
+const SERVICE_INTERVAL = 60 * 60e3;
+async function expireStaleAlerts() { // Maintenance: declutter notifications and cache storage.
+  const now = Date.now();
+  if (now < lastMaintenance + SERVICE_INTERVAL) return;
+  lastMaintenance = now;
+  const cache = await caches.open(alertCache);
+  const firstSafeIssuedTime = Date.now() - ALERT_EXPIRATION_MS;
+  const firstSafeIssuedString = firstSafeIssuedTime.toString();
+  for (const key of await cache.keys()) {
+    const response = await cache.match(key);
+    if (!response) console.error('how can there not be a response at', key);
+    else if (firstSafeIssuedString > await response.text()) {console.log('removing stale seen', key); cache.delete(key); }
+  }
+  for (const notification of await self.registration.getNotifications()) {
+    if (firstSafeIssuedTime > notification.data.issuedTime) {console.log('removing stale alert', notification.close());}
+  }
+}
+
+async function showNotification({lat, lng, issuedTime, hashtag, alert, body = '', force = false}) { // Promise to show a platform notification. There are two paths to here:
   // 1. The app handles data from network connections, and determines that it should alert the user.
   //    In this case, the app sends the data to this service worker.
   // 2. An upstream node would like to send the data over the network, but finds that we are not connected,
@@ -213,21 +241,24 @@ function showNotification({lat, lng, issuedTime, hashtag, alert, body = '', forc
   // in path 2, so it has to be here if we want to have the code in just one place.
   // Any filtering (e.g., do not show notifications for one's own alerts) happens upstream of here. (We don't know the Agent.current and the sender isn't in the notification.)
   const seenKey = alert + body;  // If we click on a notification for an off-screen alert, we may process the alert again and try to notify again.
-  if (!force && issued.has(seenKey)) return null;
-  issued.add(seenKey);
+  const seen = !force && await hasSeenAlert(seenKey);
+  console.log({seenKey, seen});
+  if (seen) return null;
+  noteSeenAlert(seenKey, issuedTime);
   const base = location.href;
   const timestamp = issuedTime;
   const icon = new URL('./images/civil-defense-192.png', base).href;
   const queryString = `./?tags=${encodeURIComponent(hashtag)}&lat=${lat}&lng=${lng}&alert=${alert}`;
   const url = new URL(queryString, base).href; // For opening page when it has been closed.
-  const data = {lat, lng, url};
+  const data = {lat, lng, url, issuedTime};
   const options = {icon, timestamp, body, data, tag: alert, renotify: true};
   console.log('showNotification', {seenKey, hashtag, options});
-  return self.registration.showNotification(hashtag, options);
+  await self.registration.showNotification(hashtag, options);
+  return expireStaleAlerts();
 }
 
 function showNotificationFromEnvelope({deleted, message, msgId}) { // We get the generic, application-independent envelope.
-  //console.log('envelope', message, msgId);
+  console.log('received push', msgId, deleted ? 'cancel' : '');
   if (deleted) return cancelNotification(msgId);
   const {issuedTime, hashtag, payload, alert = msgId} = message;
   let {lat, lng, message:body, name = ''} = payload;
@@ -237,7 +268,7 @@ function showNotificationFromEnvelope({deleted, message, msgId}) { // We get the
 
 async function cancelNotification(tag, body = '') { // Cancel those that match tag, and if body, then only those also matching body.
   for (const notification of await self.registration.getNotifications({tag})) {
-    console.log('cancel', {tag, body, notification});
+    console.log('cancel notification', {tag, body, notification});
     if (!body || (body === notification.body)) notification.close();
   }
 }

package/public/stylesheets/style.css

@@ -205,6 +205,7 @@ button, .leaflet-control-zoom > a, .leaflet-popup-close-button, md-outlined-icon
     bottom: 55px;
     max-height: 45dvh; /* leaving room for portrait keyboard. landscape keyboard has no room at all *\/ */
     overflow-y: auto;
+    overscroll-behavior: contain;      /* don't chain scroll to page */
     width: fit-content;
     min-width: var(--combobox-minWidth);
     z-index: 1000;
@@ -253,7 +254,7 @@ button, .leaflet-control-zoom > a, .leaflet-popup-close-button, md-outlined-icon
 }
 .alert-marker {
     text-shadow: 8px -3px 10px rgb(0 0 0 / 60%);
-    animation: pulse ease 0.8s 1;
+    animation: pulse08 ease 0.8s 1;
     transition: opacity 0.4s;
 }
 .alert-commented {
@@ -288,7 +289,7 @@ button, .leaflet-control-zoom > a, .leaflet-popup-close-button, md-outlined-icon
     left: -5px;
     background-image: radial-gradient(transparent 30%, var(--md-sys-color-primary), transparent 70%);
     transition: opacity 0.8s;
-    animation: pulse ease 0.8s 1;
+    animation: pulse08 ease 0.8s 1;
 }
 .aggregate.alert-pin.starting {
     font-size: 0px;
@@ -296,19 +297,43 @@ button, .leaflet-control-zoom > a, .leaflet-popup-close-button, md-outlined-icon
 .aggregate.alert-pin.starting:after {
     opacity: 0;
 }
-@keyframes pulse {
-    0% { filter: saturate(1); }
-    25% { filter: saturate(4); }
-    50% { filter: saturate(1); }
-    75% { filter: saturate(0); }
-    100% { filter: saturate(1); }
-}
-@keyframes pulse2 { /* for restarting */
-    0% { filter: saturate(1); }
-    25% { filter: saturate(4); }
-    50% { filter: saturate(1); }
-    75% { filter: saturate(0); }
-    100% { filter: saturate(1); }
+@keyframes pulse08 {
+      0% { filter: saturate(1); background-color: rgb(189, 46, 47, 0%); border-radius: 8px; }
+     25% { filter: saturate(4); background-color: rgb(189, 46, 47, 25%); }
+     50% { filter: saturate(1); background-color: rgb(189, 46, 47, 40%); }
+     75% { filter: saturate(0); background-color: rgb(189, 46, 47, 25%); }
+    100% { filter: saturate(1);  background-color: rgb(189, 46, 47, 0%); border-radius: 8px;}
+}
+/* 0.2s               0.2s  */
+/*   <-0.8s-> <-0.8s->      */
+/*   4       4       4      */
+/* 1   1   1   1   1   1    */
+/*       0       0          */
+@keyframes pulse20 {
+      0% { filter: saturate(1); background-color: rgb(189, 46, 47, 0%); border-radius: 8px; }
+     10% { filter: saturate(4); background-color: rgb(189, 46, 47, 25%); }
+     20% { filter: saturate(1); background-color: rgb(189, 46, 47, 50%); }
+     30% { filter: saturate(0); }
+     40% { filter: saturate(1); }
+     50% { filter: saturate(4); }
+     60% { filter: saturate(1); }
+     70% { filter: saturate(0); }
+     80% { filter: saturate(1);  background-color: rgb(189, 46, 47, 50%); }
+     90% { filter: saturate(4); background-color: rgb(189, 46, 47, 25%); }
+    100% { filter: saturate(1); background-color: rgb(189, 46, 47, 0%); border-radius: 8px; }
+}
+@keyframes pulse20border {
+      0% { filter: saturate(1); background-color: rgb(189, 46, 47, 0%); border-radius: 8px; border: solid thin rgb(189, 46, 47, 0);}
+     10% { filter: saturate(4); background-color: rgb(189, 46, 47, 25%); border: solid thick rgb(189, 46, 47, 100%); }
+     20% { filter: saturate(1); background-color: rgb(189, 46, 47, 50%); }
+     30% { filter: saturate(0); }
+     40% { filter: saturate(1); }
+     50% { filter: saturate(4); }
+     60% { filter: saturate(1); }
+     70% { filter: saturate(0); }
+     80% { filter: saturate(1);  background-color: rgb(189, 46, 47, 50%); }
+     90% { filter: saturate(4); background-color: rgb(189, 46, 47, 25%); border: solid thick rgb(189, 46, 47, 100%); }
+    100% { filter: saturate(1); background-color: rgb(189, 46, 47, 0%); border-radius: 8px; border: solid thin rgb(189, 46, 47, 0); }
 }
 
 #checkForUpdates, #downloadUpdates, #updateContainer md-elevated-button {
@@ -320,7 +345,7 @@ button, .leaflet-control-zoom > a, .leaflet-popup-close-button, md-outlined-icon
     gap: 10px;
 }
 .pub {
-    animation: pulse ease 0.8s 1;
+    animation: pulse08 ease 0.8s 1;
     --_label-text-weight: 800;
     --_selected-label-text-color: var(--md-sys-color-secondary);
     --md-filter-chip-selected-leading-icon-color: var(--md-sys-color-secondary);

package/server/websocket.js

@@ -1,12 +1,47 @@
 // Offer a websocket connection for testing, that skips the DHT entirely, and accepts publishing by pushing to subscribers over the websocket.
 import { WebSocketServer } from 'ws';
-import * as operator from '../public/javascripts/pubsub.js';
+import { operators } from '../public/javascripts/pubsub.js';
 
 const sockets = {};
-operator.setReceiver((nodeId, id, envelope) => {
+operators.setSender((nodeId, eventHandlerId, envelope) => new Promise((resolve, reject) => {
+  // Setup pubsub to receive events, by supplying a function that promises to send the event.
+  //
+  // When a client goes to the background, it will stay connected for at least a few seconds. An alert during that time will be transmitted in the usual way.
+  // If the client politely closes, our close handler will catch this, and call pubsub's deleteSubscriber(), which activates any sticky subs.
+  //    An alert after that be transmitted by the sticky push sub, if any.
+  // We have a 20 second heartbeat to all clients: when someone has gone dark by being in the background, that will supply the cose.
+  //    An alert after heartbeat expiration wil be transmitted by the sticky push sub, if any.
+  // But... Sending on a websocket that isn't listening will silently appear to succeed.
+  // (The protocol is designed that way so that operating systems can buffer the output, so any tcp ack failure could occur
+  // long after socket.send() returned.)
+  // Oy.
+  // If the OS suspends the client, say, 5 seconds after going into the background, an alert between 5 and 20 seconds would not be delivered!
+  // In order to prevent this, outgoing events send an ackTag string (in addition to the event envelope), which the client must send back.
+  // Here we set the event publisher to answer a Promise. If the sender acknowledges the event within ACK_TIME_MS, it resolves to undefined.
+  // But if there is no acknowledgement (or if the updated readyState after sending is not OPEN), then the promise is rejected,
+  // and pubsub can catch that and transmit by the sticky push sub, if any.
   const socket = sockets[nodeId];
-  socket.send(JSON.stringify([id, envelope])); // We want an error if socket is gone, closed, etc.
-});
+  if (!socket) return;
+  const ACK_TIME_MS = 20e3;
+  const ackTag = nodeId + '-' + socket.sendCounter++;
+  const fail = reason => {
+    delete sockets[nodeId]; // Keep close() from removing any sticky sub.
+    delete operators[ackTag];
+    socket.terminate(); // close will be asynchronous.
+    reject(reason); // Reject now (before close), so that caller can catch this and push message to sticky sub, if any.
+  };
+  console.log(new Date(), 'socket send', socket.readyState, ackTag, eventHandlerId);
+  const timer = setTimeout(() => fail(`No acknowledgement for ${ackTag} in state ${socket.readyState} for handler ${eventHandlerId}.`), ACK_TIME_MS);
+  operators[ackTag] = () => {
+    console.log('ack', ackTag, 'from eventHandlerId', eventHandlerId);
+    clearTimeout(timer);
+    delete operators[ackTag];
+    resolve();
+  };
+  socket.send(JSON.stringify([eventHandlerId, ackTag, envelope])); // We want an error if socket is gone, closed, etc.
+  // State might not update until we attempt to actually send.
+  if (socket.readyState !== WebSocket.OPEN) fail(`Bad state send to ${ackTag}, state ${socket.readyState} for handler ${eventHandlerId}.`);
+}));
 
 function heartbeat() {
   this.isAlive = true;
@@ -17,13 +52,15 @@ export function configureWebsocket(server) {
   wss.on('connection', (ws, req) => {
     const nodeTag = req.url.slice(1);
     console.log('Connected', nodeTag);
+    ws.sendCounter = 0;
     sockets[nodeTag] = ws;
 
     ws.on('message', async message => {
       try {
-	const [id, methodName, ...rest] = JSON.parse(message);
-	const result = await operator[methodName](...rest);
-	if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify([id, result]));
+	const parsed = JSON.parse(message);
+	const [id, methodName, ...rest] = parsed;
+	const result = await operators[methodName](...rest);
+	if (id && (ws.readyState === WebSocket.OPEN)) ws.send(JSON.stringify([id, result]));
       } catch (error) {
 	console.error(`Incomming ${error.message}: ${message}\n${error.stack}`);
       }
@@ -34,15 +71,19 @@ export function configureWebsocket(server) {
 
     ws.on('error', console.error);
     ws.on('close', () => {
-      console.log('Disconnected', nodeTag);
+      console.log(new Date(), 'Disconnected', nodeTag);
+      // Guarded, so that we don't double delete, and remove an active sticky sub.
+      if (sockets[nodeTag]) operators.deleteSubscriber(nodeTag);
       delete sockets[nodeTag];
-      operator.deleteSubscriber(nodeTag);
     });
   });
 
   const interval = setInterval(function ping() { // Keep-alive ping/pong on interval
     wss.clients.forEach(function each(ws) {
-      if (!ws.isAlive) return ws.terminate();
+      if (!ws.isAlive) {
+	console.log('heartbeat failure');
+	return ws.terminate();
+      }
       if (ws.readyState == WebSocket.OPEN) {
 	ws.isAlive = false;
 	ws.ping();