@visns-studio/visns-components 6.28.0 → 6.31.0

package/src/components/callQueue/CallQueuePop.jsx

@@ -20,15 +20,25 @@ import { subscriptionMonitor } from '../sms/smsLiveState';
 import {
     appendCallPopLog,
     installCallPopStatusHook,
+    noteCallPopChannelPresent,
     noteCallPopConnectionState,
     noteCallPopEvent,
     updateCallPopStatus,
 } from './callPopStatus';
 
+// The header's phone badge listens on this SAME channel, and Echo's `leave()`
+// destroys a channel for everyone who holds it — see sharedPrivateChannel.js.
+import {
+    acquirePrivateChannel,
+    hasPrivateChannel,
+    releasePrivateChannel,
+} from '../echo/sharedPrivateChannel';
+
 // Pure helpers live in a plain .js sibling so `node --test` can import them;
 // re-exported below so this file's public surface is unchanged.
 import {
     CLIENT_DETAIL_FIELDS,
+    DEFAULT_MAX_RINGING_MS,
     FALLBACK_QUEUE_NAME,
     KIND_DIRECT,
     MONITOR_PERMISSION,
@@ -42,6 +52,7 @@ import {
     defaultTaskUrl,
     demoClientDetails,
     directRingingLine,
+    expiredCallIds,
     formatAuPhone,
     formatDueDate,
     formatElapsed,
@@ -65,6 +76,7 @@ export {
     clientDetails,
     demoClientDetails,
     directRingingLine,
+    expiredCallIds,
     formatAuPhone,
     formatDueDate,
     formatElapsed,
@@ -112,13 +124,28 @@ export {
  * nothing: `.queue.missed` marks the card and starts a `missedGraceMs` timer
  * instead of removing it, and a further `.queue.ringing` for the same call
  * cancels that timer. Only `.queue.answered`/`.queue.ended` take a card away
- * outright.
+ * outright — plus one backstop: a card still ringing after `maxRingingMs` is
+ * dropped, because the alternative to trusting an event that never arrived is
+ * a phantom card ringing all afternoon.
+ *
+ * Both of those windows belong to the server, which is the side that decides
+ * when a call is over; it sends its own figures as the snapshot's
+ * `missed_grace_ms` and `max_ringing_ms`, and those win over the props.
  *
  * The snapshot is a catch-up mechanism, not just a first paint: it runs again
  * whenever the socket reconnects and whenever a hidden tab is looked at again,
  * and reconciles both ways, so a call that started or ended while this browser
  * was deaf is not stuck on (or missing from) the screen.
  *
+ * The channel is SHARED: the header's phone badge listens on the same private
+ * channel, and laravel-echo's `leave()` destroys a channel for everyone rather
+ * than just for its caller — so the badge unmounting (the CRM hides its header
+ * on record pages) used to silently unsubscribe the pop, with `subscribed`
+ * still reading true. Both sides now go through the ref-counted registry in
+ * ../echo/sharedPrivateChannel, and the pop rechecks the channel on every
+ * socket reconnect and every `resubscribeCheckMs` while the tab is visible,
+ * resubscribing when it finds it gone.
+ *
  * The caller -> client match arrives already resolved, as each call's `client`
  * block (computed once by the Zoom webhook, server-side). This component never
  * looks a caller up itself — every watching member of staff sees every pop, and
@@ -199,8 +226,15 @@ const EXIT_MS = 220;
  * enough for the next leg's `.queue.ringing` to arrive and cancel it, short
  * enough that a call nobody took stops sitting on screen. Override with the
  * `missedGraceMs` prop.
+ *
+ * 20s to match the server's own `missed_grace_seconds`. It was 10s — half the
+ * server's figure — which took the card away ten seconds BEFORE the server
+ * considered the call gone: a leg declining on a call still ringing elsewhere
+ * cleared the pop off everybody's screen while the phone was still ringing.
+ * The snapshot's `missed_grace_ms` overrides this, so the two sides cannot
+ * drift apart again.
  */
-const DEFAULT_MISSED_GRACE_MS = 10000;
+const DEFAULT_MISSED_GRACE_MS = 20000;
 
 /**
  * Minimum gap between snapshot refreshes, for every reason except mount. A
@@ -209,6 +243,16 @@ const DEFAULT_MISSED_GRACE_MS = 10000;
  */
 const SNAPSHOT_MIN_GAP_MS = 5000;
 
+/**
+ * How often the pop checks that its channel is still there, and resubscribes
+ * if it is not. A dropped socket announces itself; a channel taken away by
+ * another component's `echo.leave()` announces nothing at all, so the only way
+ * to find out is to look. Once a minute is cheap (a property read, and one
+ * throttled snapshot) and bounds the blind window at a minute. Override with
+ * the `resubscribeCheckMs` prop; 0 turns the poll off.
+ */
+const DEFAULT_RESUBSCRIBE_CHECK_MS = 60000;
+
 /** Title shown on alternate ticks while a call rings in a hidden tab. */
 const FLASH_TITLE = '📞 Incoming call…';
 
@@ -254,6 +298,25 @@ const resolveUrl = (option, token, value, fallback) => {
     return fallback(value);
 };
 
+/**
+ * A duration from the snapshot, or null when there is nothing usable there.
+ *
+ * Coerced rather than type-checked because a Laravel config value that has been
+ * through `.env` arrives as the string '20000' just as readily as the number,
+ * and a window the server clearly meant to state should not be ignored over
+ * that. Zero and negatives are null: "no timeout" is not a thing either of
+ * these windows can express, so a 0 is a misconfiguration, and falling back to
+ * the prop is the safer reading of it.
+ */
+const positiveMs = (value) => {
+    if (value === null || value === undefined || value === '') {
+        return null;
+    }
+
+    const number = Number(value);
+
+    return Number.isFinite(number) && number > 0 ? number : null;
+};
 
 /**
  * Is the user actually looking at this tab? Both checks matter: a focused but
@@ -300,6 +363,8 @@ const CallQueuePop = ({
     clientDetailFields = CLIENT_DETAIL_FIELDS,
     demoEnabled = true,
     missedGraceMs = DEFAULT_MISSED_GRACE_MS,
+    maxRingingMs = DEFAULT_MAX_RINGING_MS,
+    resubscribeCheckMs = DEFAULT_RESUBSCRIBE_CHECK_MS,
 }) => {
     const [calls, setCalls] = useState([]);
     const [now, setNow] = useState(() => Date.now());
@@ -310,6 +375,20 @@ const CallQueuePop = ({
     // Environment-scoped Echo channel name, delivered by the snapshot.
     const [echoChannel, setEchoChannel] = useState(null);
 
+    /*
+     * The two timing windows, as the server states them in its snapshot.
+     *
+     * The server is the side that decides when a call is over — it holds the
+     * webhook ledger and the config — so whatever it sends wins over the props,
+     * which are only the figures to use until it has spoken (and for a host
+     * running an older backend, which sends neither).
+     */
+    const [serverMissedGraceMs, setServerMissedGraceMs] = useState(null);
+    const [serverMaxRingingMs, setServerMaxRingingMs] = useState(null);
+
+    const effectiveMissedGraceMs = serverMissedGraceMs ?? missedGraceMs;
+    const effectiveMaxRingingMs = serverMaxRingingMs ?? maxRingingMs;
+
     // Open-task drill-down, keyed by callId: which cards are expanded, and the
     // tasks fetched for each as `{ status: idle|loading|ready|error, tasks }`.
     const [expandedTasks, setExpandedTasks] = useState({});
@@ -457,7 +536,7 @@ const CallQueuePop = ({
 
     /**
      * A ringing leg was declined or timed out. The call may still be ringing on
-     * someone else's device, so the card is marked and given `missedGraceMs` to
+     * someone else's device, so the card is marked and given the grace period to
      * prove it: a `.queue.ringing` inside that window cancels the timer, and
      * nothing arriving lets it remove the card the same way `.queue.ended`
      * would.
@@ -489,11 +568,11 @@ const CallQueuePop = ({
             const timer = setTimeout(() => {
                 missedTimers.current.delete(id);
                 removeCall(id);
-            }, missedGraceMs);
+            }, effectiveMissedGraceMs);
 
             missedTimers.current.set(id, timer);
         },
-        [missedGraceMs, removeCall]
+        [effectiveMissedGraceMs, removeCall]
     );
 
     /** Drop the whole stack (no exit animation — used by clear). */
@@ -890,8 +969,9 @@ const CallQueuePop = ({
      * reconcileSnapshot for the two exceptions), so a call that started while
      * the socket was down appears, and one that ended while it was down goes.
      *
-     * @param {string} reason 'mount' | 'reconnect' | 'visible' — logged, so the
-     *   diagnostics panel says why each refresh happened.
+     * @param {string} reason 'mount' | 'reconnect' | 'visible' | 'resubscribe'
+     *   | 'poll' — logged, so the diagnostics panel says why each refresh
+     *   happened. Nothing validates the value; it is a label.
      */
     const refreshSnapshot = useCallback(
         (reason) => {
@@ -912,6 +992,25 @@ const CallQueuePop = ({
                             setEchoChannel(result.channel);
                         }
 
+                        // Timing windows, when this server states them. Both
+                        // are optional: an older backend sends neither, and the
+                        // props stand in.
+                        const grace = positiveMs(
+                            result?.missed_grace_ms ?? result?.missedGraceMs
+                        );
+
+                        if (grace !== null) {
+                            setServerMissedGraceMs(grace);
+                        }
+
+                        const maxRinging = positiveMs(
+                            result?.max_ringing_ms ?? result?.maxRingingMs
+                        );
+
+                        if (maxRinging !== null) {
+                            setServerMaxRingingMs(maxRinging);
+                        }
+
                         if (result?.pickup_codes ?? result?.pickupCodes) {
                             const codes = normalisePickupCodes(
                                 result.pickup_codes ?? result.pickupCodes
@@ -1148,14 +1247,24 @@ const CallQueuePop = ({
         let subscription = null;
         let stopMonitoring = () => {};
         let unbindState = () => {};
+        let resubscribeTimer = null;
+
+        /**
+         * Bind every `.queue.*` listener plus the subscription monitor.
+         *
+         * Broken out of the effect body because a resubscribe has to do all of
+         * this again against a brand new subscription object — the old one is
+         * a corpse once Echo has dropped the channel.
+         *
+         * @param {object} target The subscription to bind to.
+         * @returns {Function} Stops the monitor again.
+         */
+        const attachListeners = (target) => {
+            if (!target) {
+                return () => {};
+            }
 
-        try {
-            // Until /broadcasting/auth knows this channel the subscription just
-            // fails auth — pusher-js logs a warning, nothing of ours throws.
-            // That silence is exactly what the monitor below breaks.
-            subscription = instance.private(activeChannel);
-
-            subscription.listen(EVENT_RINGING, (event) => {
+            target.listen(EVENT_RINGING, (event) => {
                 const call = event?.call ?? event;
 
                 noteCallPopEvent(EVENT_RINGING);
@@ -1163,7 +1272,7 @@ const CallQueuePop = ({
                 ingestCall(call);
             });
 
-            subscription.listen(EVENT_ANSWERED, (event) => {
+            target.listen(EVENT_ANSWERED, (event) => {
                 const callId =
                     event?.callId ?? event?.call_id ?? event?.call?.callId;
 
@@ -1175,7 +1284,7 @@ const CallQueuePop = ({
                 }
             });
 
-            subscription.listen(EVENT_ENDED, (event) => {
+            target.listen(EVENT_ENDED, (event) => {
                 const callId =
                     event?.callId ?? event?.call_id ?? event?.call?.callId;
 
@@ -1190,7 +1299,7 @@ const CallQueuePop = ({
             // One leg said no. The call is not over — it may be ringing on
             // three other devices — so this starts a grace period rather than
             // removing anything.
-            subscription.listen(EVENT_MISSED, (event) => {
+            target.listen(EVENT_MISSED, (event) => {
                 const callId =
                     event?.callId ?? event?.call_id ?? event?.call?.callId;
 
@@ -1204,7 +1313,7 @@ const CallQueuePop = ({
 
             // The diagnostics panel's round-trip probe. It settles nothing and
             // pops nothing — it only proves this browser is being delivered to.
-            subscription.listen(EVENT_PING, (event) => {
+            target.listen(EVENT_PING, (event) => {
                 const nonce = event?.nonce ?? event?.id ?? null;
 
                 noteCallPopEvent(EVENT_PING, {
@@ -1216,7 +1325,7 @@ const CallQueuePop = ({
                 trace('event .queue.diagnostic-ping', nonce);
             });
 
-            stopMonitoring = subscriptionMonitor(subscription, {
+            return subscriptionMonitor(target, {
                 onSuccess: () => {
                     appendCallPopLog(`Subscribed to ${activeChannel}`, 'info', {
                         subscribed: true,
@@ -1258,6 +1367,113 @@ const CallQueuePop = ({
                     );
                 },
             });
+        };
+
+        /** Unbind whatever `attachListeners` bound. Never throws. */
+        const detachListeners = (target) => {
+            try {
+                stopMonitoring();
+            } catch (error) {
+                // Already gone.
+            }
+
+            stopMonitoring = () => {};
+
+            try {
+                if (target) {
+                    target.stopListening(EVENT_RINGING);
+                    target.stopListening(EVENT_ANSWERED);
+                    target.stopListening(EVENT_ENDED);
+                    target.stopListening(EVENT_MISSED);
+                    target.stopListening(EVENT_PING);
+                }
+            } catch (error) {
+                // A dead channel has nothing left to unbind.
+            }
+        };
+
+        /**
+         * Confirm the channel is still there, and rebuild it when it is not.
+         *
+         * The failure this exists for is silent by construction: another
+         * component calling `echo.leave()` on the shared channel unsubscribes
+         * us without any event, so `subscribed` stays true and the pop simply
+         * stops popping. Nothing tells us — we have to look.
+         *
+         * @returns {boolean} True when a resubscribe was performed.
+         */
+        const ensureSubscribed = () => {
+            let present = false;
+
+            try {
+                present = hasPrivateChannel(instance, activeChannel, subscription);
+            } catch (error) {
+                present = false;
+            }
+
+            noteCallPopChannelPresent(present);
+
+            if (present) {
+                return false;
+            }
+
+            appendCallPopLog('Channel was gone — resubscribing', 'warn', {
+                channel: activeChannel,
+                subscribed: false,
+                subscriptionError: null,
+            });
+            trace(`channel private-${activeChannel} was gone — resubscribing`);
+
+            detachListeners(subscription);
+            // Release before acquiring so the ref count nets out unchanged:
+            // this component held one reference before and holds one after.
+            releasePrivateChannel(instance, activeChannel);
+
+            try {
+                subscription = acquirePrivateChannel(instance, activeChannel);
+                stopMonitoring = attachListeners(subscription);
+                noteCallPopChannelPresent(
+                    hasPrivateChannel(instance, activeChannel, subscription)
+                );
+            } catch (error) {
+                subscription = null;
+                appendCallPopLog(
+                    `Could not resubscribe to ${activeChannel}: ${error?.message ?? error}`,
+                    'error',
+                    {
+                        subscribed: false,
+                        channelPresent: false,
+                        subscriptionError: {
+                            status: null,
+                            message: String(error?.message ?? error),
+                        },
+                    }
+                );
+                trace('resubscribe threw', error?.message ?? error);
+
+                return false;
+            }
+
+            // Anything that rang while we were unsubscribed was broadcast to
+            // nobody here, so the snapshot is the only way to learn about it.
+            requestSnapshot('resubscribe');
+
+            return true;
+        };
+
+        try {
+            // Until /broadcasting/auth knows this channel the subscription just
+            // fails auth — pusher-js logs a warning, nothing of ours throws.
+            // That silence is exactly what the monitor below breaks.
+            //
+            // Ref-counted rather than `instance.private()` directly: the
+            // header's phone badge shares this channel and unmounts on record
+            // pages, and its `leave()` used to take our subscription with it.
+            subscription = acquirePrivateChannel(instance, activeChannel);
+            stopMonitoring = attachListeners(subscription);
+            noteCallPopChannelPresent(
+                hasPrivateChannel(instance, activeChannel, subscription)
+            );
         } catch (error) {
             subscription = null;
             appendCallPopLog(
@@ -1265,6 +1481,7 @@ const CallQueuePop = ({
                 'error',
                 {
                     subscribed: false,
+                    channelPresent: false,
                     subscriptionError: {
                         status: null,
                         message: String(error?.message ?? error),
@@ -1293,6 +1510,11 @@ const CallQueuePop = ({
                     // only when the socket actually went away, otherwise every
                     // ordinary connecting -> connected on load would refetch.
                     if (current === 'connected') {
+                        // A socket can come back without our channel: pusher-js
+                        // resubscribes what it still holds, and a channel that
+                        // was `leave()`n is no longer among them.
+                        ensureSubscribed();
+
                         if (sawDisconnect.current) {
                             requestSnapshot('reconnect');
                         }
@@ -1327,30 +1549,42 @@ const CallQueuePop = ({
             // says whether this browser is live, which is what it said before.
         }
 
-        return () => {
-            unbindState();
+        // The backstop. `state_change` covers a socket that visibly went away;
+        // this covers the case with no signal at all — the channel removed
+        // underneath a perfectly healthy socket. Only while the tab is being
+        // looked at: a backgrounded tab that nobody can see a pop in has
+        // nothing to catch up for, and the visibilitychange effect above
+        // already refreshes on the way back.
+        if (resubscribeCheckMs > 0) {
+            resubscribeTimer = setInterval(() => {
+                if (
+                    typeof document !== 'undefined' &&
+                    document.visibilityState !== 'visible'
+                ) {
+                    return;
+                }
 
-            try {
-                stopMonitoring();
-            } catch (error) {
-                // Already gone.
+                ensureSubscribed();
+                requestSnapshot('poll');
+            }, resubscribeCheckMs);
+        }
+
+        return () => {
+            if (resubscribeTimer !== null) {
+                clearInterval(resubscribeTimer);
+                resubscribeTimer = null;
             }
 
-            try {
-                if (subscription) {
-                    subscription.stopListening(EVENT_RINGING);
-                    subscription.stopListening(EVENT_ANSWERED);
-                    subscription.stopListening(EVENT_ENDED);
-                    subscription.stopListening(EVENT_MISSED);
-                    subscription.stopListening(EVENT_PING);
-                }
+            unbindState();
+            detachListeners(subscription);
 
-                instance.leave(activeChannel);
-            } catch (error) {
-                // Nothing to clean up.
-            }
+            // Only really leaves the channel when nobody else (the header's
+            // phone badge) is still holding it.
+            releasePrivateChannel(instance, activeChannel);
 
-            updateCallPopStatus({ subscribed: false });
+            // `channelPresent` goes back to unknown rather than false: the pop
+            // is no longer watching, so it has nothing to report either way.
+            updateCallPopStatus({ subscribed: false, channelPresent: null });
         };
     }, [
         activeChannel,
@@ -1359,25 +1593,56 @@ const CallQueuePop = ({
         markMissed,
         removeCall,
         requestSnapshot,
+        resubscribeCheckMs,
     ]);
 
     /**
      * One interval for the whole stack, started only while cards are on screen
      * and torn down the moment the stack empties.
+     *
+     * It ticks the elapsed timers, and it sweeps. The sweep is the backstop for
+     * an end that never came: `.queue.answered`/`.queue.ended` are the only
+     * things that take a card away, and one dropped webhook or one lost frame
+     * leaves a card ringing on screen indefinitely — long after the caller hung
+     * up, which is exactly the call somebody then rings back for nothing. Any
+     * card older than the effective max ringing time goes (see expiredCallIds).
      */
     useEffect(() => {
         if (calls.length === 0) {
             return undefined;
         }
 
-        setNow(Date.now());
+        const tick = () => {
+            const timestamp = Date.now();
+
+            setNow(timestamp);
+
+            const expired = expiredCallIds(
+                callsRef.current,
+                timestamp,
+                effectiveMaxRingingMs
+            );
+
+            // One line per card, not per tick: `removeCall` marks it leaving
+            // immediately, and `expiredCallIds` skips a card on its way out.
+            expired.forEach((callId) => {
+                appendCallPopLog(
+                    `Call ${callId} has been ringing for over ` +
+                        `${Math.round(effectiveMaxRingingMs / 1000)}s with no ` +
+                        'answered/ended event — removing the card',
+                    'warn'
+                );
+                trace('expired card', callId);
+                removeCall(callId);
+            });
+        };
+
+        tick();
 
-        const interval = setInterval(() => {
-            setNow(Date.now());
-        }, 1000);
+        const interval = setInterval(tick, 1000);
 
         return () => clearInterval(interval);
-    }, [calls.length]);
+    }, [calls.length, effectiveMaxRingingMs, removeCall]);
 
     /**
      * Ask for notification permission, lazily and only for gated-in users.

package/src/components/callQueue/callPopStatus.js

@@ -49,6 +49,15 @@ export const emptyCallPopStatus = () => ({
     /** Has the channel reported pusher:subscription_succeeded? */
     subscribed: false,
     subscribedAt: null,
+    /**
+     * Does Echo still hold the channel? null = not checked yet.
+     *
+     * Separate from `subscribed` on purpose: a channel torn down by somebody
+     * else's `echo.leave()` leaves `subscribed` stuck at true — nothing tells
+     * the pop it has been unsubscribed — so "we think we are subscribed" and
+     * "the channel is actually there" have to be two readings, not one.
+     */
+    channelPresent: null,
     /** `{status, message}` from pusher:subscription_error, else null. */
     subscriptionError: null,
     /** The one-shot `/ajax/call-queue/live` snapshot. */
@@ -207,6 +216,20 @@ export const noteCallPopConnectionState = (state) => {
     });
 };
 
+/**
+ * Record whether Echo still holds the pop's channel.
+ *
+ * Written by the pop's periodic check and whenever it (re)subscribes, so the
+ * diagnostics panel can show the one thing `subscribed` cannot: a subscription
+ * that was confirmed once and has since been thrown away underneath us.
+ *
+ * @param {boolean|null} present
+ */
+export const noteCallPopChannelPresent = (present) =>
+    updateCallPopStatus({
+        channelPresent: typeof present === 'boolean' ? present : null,
+    });
+
 /**
  * Expose the reader on `window` next to the demo hooks, so support can run
  * `callPopStatus()` in a staff member's console without a build of anything.

package/src/components/callQueue/callQueueHelpers.js

@@ -575,6 +575,72 @@ export const reconcileSnapshot = (
     return { add, remove };
 };
 
+/**
+ * How long a card may ring before this browser stops believing in it.
+ *
+ * A card's whole life depends on a `.queue.answered` / `.queue.ended` arriving,
+ * and that is one Zoom webhook and one broadcast away from never happening — a
+ * webhook Zoom retried into a dead queue worker, a socket frame lost on the way
+ * here. Nothing else removes the card, so it rings on screen forever and
+ * somebody eventually picks up a call that finished twenty minutes ago.
+ *
+ * Two minutes is well past the point Zoom itself stops ringing a queue, so a
+ * card older than that is not a call anybody can still answer. The server sends
+ * its own figure as the snapshot's `max_ringing_ms`; this is the fallback.
+ */
+export const DEFAULT_MAX_RINGING_MS = 120000;
+
+/**
+ * Cards that have rung too long to still be real — the ids to drop.
+ *
+ * Deliberately blunt, because what it defends against is the ABSENCE of a
+ * signal rather than a signal: only the age of the card is consulted. A card
+ * with no parseable `startedAt` is left alone — "we cannot date it" is not
+ * evidence the call is over — as is one already animating out, and a demo card,
+ * which has no server behind it to end it (`reconcileSnapshot` exempts demo
+ * cards for the same reason).
+ *
+ * @param {Array}  calls        Cards on screen (normalised calls).
+ * @param {number} now
+ * @param {number} maxRingingMs Age limit in ms; 0 or less disables the sweep.
+ *
+ * @returns {Array<string>} callIds to remove.
+ */
+export const expiredCallIds = (
+    calls,
+    now = Date.now(),
+    maxRingingMs = DEFAULT_MAX_RINGING_MS
+) => {
+    const list = Array.isArray(calls) ? calls : [];
+
+    if (!Number.isFinite(maxRingingMs) || maxRingingMs <= 0) {
+        return [];
+    }
+
+    return list
+        .filter((call) => {
+            if (!call || call.leaving || call.isDemo) {
+                return false;
+            }
+
+            // `null` is checked before `new Date`, which reads it as the
+            // epoch rather than as a bad date and would age every undated card
+            // straight off the screen.
+            if (call.startedAt === null || call.startedAt === undefined) {
+                return false;
+            }
+
+            const started = new Date(call.startedAt).getTime();
+
+            if (Number.isNaN(started)) {
+                return false;
+            }
+
+            return now - started > maxRingingMs;
+        })
+        .map((call) => call.callId);
+};
+
 /**
  * Coerce the snapshot's `pickup_codes` block into a plain `{ queueId: code }`
  * map, dropping anything that is not a non-empty string on both sides. A queue