From 1e2a58e563955afc074487e02df39bc541d5f9c7 Mon Sep 17 00:00:00 2001 From: Thomas Date: Mon, 2 Nov 2026 11:00:58 +0100 Subject: [PATCH] =?UTF-8?q?Jagd=20auf=20WS=20Abbr=C3=BCche?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- CMBNet/cmbnet/ws/broker.py | 75 +++++++-- CMBNet/static/css/mobile.css | 69 +++++++++ CMBNet/static/js/reload_notice.js | 39 ++++- CMBNet/static/js/sw.js | 2 +- CMBNet/static/js/views/dispatcher.js | 48 +++++- CMBNet/static/js/views/mobile.js | 207 ++++++++++++++++++++++--- CMBNet/templates/dispatcher_mobil.html | 2 + CMBNet/templates/gruppen.html | 2 + doc/broker.md | 69 ++++++++- 9 files changed, 462 insertions(+), 51 deletions(-) diff --git a/CMBNet/cmbnet/ws/broker.py b/CMBNet/cmbnet/ws/broker.py index 2280611..80769f0 100644 --- a/CMBNet/cmbnet/ws/broker.py +++ b/CMBNet/cmbnet/ws/broker.py @@ -66,6 +66,15 @@ class WebSocketBroker: self.disconnected_clients = {} self.queue_lock = Lock() + # Sequenznummern werden pro Client-ID vergeben und bleiben über einen + # WebSocket-Reconnect derselben Webview hinweg erhalten. Dadurch kann + # der Client nach einem Reconnect erkennen, ob ihm Frames fehlen. + # client_sequences[(tenant_id, client_id)] = zuletzt zugestellte Sequenz + self.client_sequences = {} + # Ein Lock pro Client-ID serialisiert Sequenzvergabe und Sendevorgang + # auch dann, wenn die Verbindung während eines Reconnects ersetzt wird. + self.client_sequence_locks = {} + # Zeitpunkt des letzten Code-2-Pongs je Gruppe (monotonic). self.group_last_pong = {} self.group_online_since = {} @@ -138,6 +147,10 @@ class WebSocketBroker: 'last_ping': datetime.now(), 'connected_at': time.monotonic(), 'last_pong_at': None, + # Zuletzt an diese Client-ID zugestellte Sequenznummer. Die + # maßgebliche Zählung liegt in self.client_sequences, damit sie + # einen Reconnect überlebt. + 'seq': self.client_sequences.get((tenant_id, client_id), 0), # Ob diese Client-ID bereits vor diesem Handshake bekannt war. # Nur dann bleibt ihre Queue auch bei einem fehlgeschlagenen # erneuten Handshake erhalten. @@ -156,24 +169,48 @@ class WebSocketBroker: return True def send_to_connection(self, tenant_id, client_id, data): - """Sendet einen Frame thread-sicher an eine registrierte Client-Verbindung.""" - conn = self._get_connection(tenant_id, client_id) - if not conn: - return False + """Sendet einen Frame mit Sequenznummer thread-sicher an einen Client. - try: - lock = conn.get('send_lock') - if lock is None: - lock = Lock() - conn['send_lock'] = lock - with lock: - conn['ws'].send(data) - return True - except Exception: - # Eine fehlerhafte Verbindung darf den Versand an andere Clients - # nicht verhindern. Das Aufräumen übernimmt die Route beim - # Schließen der Verbindung. - return False + Die Sequenz wird pro Client-ID vergeben. Sie wird erst nach einem + erfolgreichen Socket-Send fortgeschrieben, damit ein fehlgeschlagener + Versand beim erneuten Zustellen keine Lücke erzeugt. Die Zählung bleibt + über Reconnects derselben Webview erhalten. + """ + key = (tenant_id, client_id) + seq_lock = self.client_sequence_locks.setdefault(key, Lock()) + + with seq_lock: + conn = self._get_connection(tenant_id, client_id) + if not conn: + return False + + try: + payload = json.loads(data) + if not isinstance(payload, dict): + return False + + last_seq = self.client_sequences.get(key) + if last_seq is None: + last_seq = int(conn.get('seq') or 0) + next_seq = last_seq + 1 + payload['seq'] = next_seq + framed = json.dumps(payload, ensure_ascii=False) + + send_lock = conn.get('send_lock') + if send_lock is None: + send_lock = Lock() + conn['send_lock'] = send_lock + with send_lock: + conn['ws'].send(framed) + + self.client_sequences[key] = next_seq + conn['seq'] = next_seq + return True + except Exception: + # Eine fehlerhafte Verbindung darf den Versand an andere Clients + # nicht verhindern. Das Aufräumen übernimmt die Route beim + # Schließen der Verbindung. + return False def is_authenticated(self, tenant_id, client_id): """Prüft, ob ein Client den Code-0-Handshake erfolgreich absolviert hat.""" @@ -282,6 +319,8 @@ class WebSocketBroker: account_id = self.client_accounts.pop((tenant_id, client_id), None) self.client_queues.pop((tenant_id, client_id), None) self.disconnected_clients.pop((tenant_id, client_id), None) + self.client_sequences.pop((tenant_id, client_id), None) + self.client_sequence_locks.pop((tenant_id, client_id), None) if account_id is not None: clients = self.account_clients.get((tenant_id, account_id)) if clients is not None: @@ -496,6 +535,8 @@ class WebSocketBroker: account_id = self.client_accounts.pop(key, None) self.client_queues.pop(key, None) self.disconnected_clients.pop(key, None) + self.client_sequences.pop(key, None) + self.client_sequence_locks.pop(key, None) if account_id is not None: clients = self.account_clients.get((tenant_id, account_id)) if clients is not None: diff --git a/CMBNet/static/css/mobile.css b/CMBNet/static/css/mobile.css index db89458..015997f 100644 --- a/CMBNet/static/css/mobile.css +++ b/CMBNet/static/css/mobile.css @@ -80,6 +80,75 @@ body.mobile-page main.container { font-weight: 600; font-size: 0.95rem; padding: 0.4rem 0.2rem; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.mobile-ws-status { + flex: 0 0 auto; + display: inline-flex; + align-items: center; + gap: 0.3rem; + padding: 0.2rem 0.45rem; + border: 1px solid var(--mobile-border); + border-radius: 999px; + background: var(--mobile-bg); + color: var(--mobile-subtext); + font-size: 0.7rem; + font-weight: 600; + line-height: 1.2; + white-space: nowrap; +} + +.mobile-ws-status::before { + content: ''; + width: 0.5rem; + height: 0.5rem; + border-radius: 50%; + background: currentColor; + flex: 0 0 auto; +} + +.mobile-ws-status.is-connected { + color: #15803d; + border-color: #86efac; +} + +.mobile-ws-status.is-connecting { + color: #b45309; + border-color: #fcd34d; +} + +.mobile-ws-status.is-disconnected { + color: var(--mobile-subtext); +} + +.mobile-ws-status.is-error { + color: #dc2626; + border-color: #fca5a5; +} + +html[data-theme="dark"] .mobile-ws-status.is-connected { + color: #4ade80; + border-color: #166534; +} + +html[data-theme="dark"] .mobile-ws-status.is-connecting { + color: #fbbf24; + border-color: #92400e; +} + +html[data-theme="dark"] .mobile-ws-status.is-error { + color: #f87171; + border-color: #991b1b; +} + +@media (max-width: 420px) { + .mobile-ws-status { + font-size: 0.62rem; + padding: 0.15rem 0.3rem; + } } .mobile-icon-btn { diff --git a/CMBNet/static/js/reload_notice.js b/CMBNet/static/js/reload_notice.js index 71d335a..7efa8d4 100644 --- a/CMBNet/static/js/reload_notice.js +++ b/CMBNet/static/js/reload_notice.js @@ -14,6 +14,7 @@ let adminSocket = null; let adminRetryTimer = null; let adminStopped = false; + let lastAdminWsSeq = null; function ensureDialog() { if (dialog) return dialog; @@ -89,6 +90,25 @@ } } + function checkAdminWsSequence(message) { + if (!Object.prototype.hasOwnProperty.call(message, 'seq')) return; + + const seq = Number(message.seq); + if (!Number.isFinite(seq) || seq <= 0) return; + + if (lastAdminWsSeq !== null && seq !== lastAdminWsSeq + 1) { + showReloadNotice( + `Die WebSocket-Verbindung hat Nachrichten verloren ` + + `(erwartet: ${lastAdminWsSeq + 1}, empfangen: ${seq}). ` + + 'Bitte lade die Seite neu, damit alle Änderungen sichtbar werden.' + ); + } + + lastAdminWsSeq = lastAdminWsSeq === null + ? seq + : Math.max(lastAdminWsSeq, seq); + } + function appUrl(path) { if (typeof window.CMBNET_APP_URL === 'function') { return window.CMBNET_APP_URL(path); @@ -141,6 +161,9 @@ } catch (error) { return; } + + checkAdminWsSequence(message); + if (Number(message.code) === 1) { if (ws.readyState === WebSocket.OPEN) { ws.send(JSON.stringify({code: 2, msg: 'pong'})); @@ -154,13 +177,21 @@ showReloadNotice(text); }); - ws.addEventListener('close', () => { - if (adminSocket === ws) adminSocket = null; + ws.addEventListener('close', event => { + if (adminSocket !== ws) return; + console.warn('[WS] Admin-Watcher geschlossen', { + code: event.code, + reason: event.reason, + wasClean: event.wasClean + }); + adminSocket = null; scheduleAdminReconnect(); }); - ws.addEventListener('error', () => { - if (adminSocket === ws) adminSocket = null; + ws.addEventListener('error', event => { + if (adminSocket !== ws) return; + console.warn('[WS] Admin-Watcher-Fehler', event); + adminSocket = null; scheduleAdminReconnect(); }); } catch (error) { diff --git a/CMBNet/static/js/sw.js b/CMBNet/static/js/sw.js index 0461b24..9914c07 100644 --- a/CMBNet/static/js/sw.js +++ b/CMBNet/static/js/sw.js @@ -5,7 +5,7 @@ * damit er sowohl die mobilen Views als auch die statischen Assets * kontrolliert. Der Cache-Name wird pro App-Wurzel gebildet. */ -const VERSION = 'cmbnet-pwa-v9'; +const VERSION = 'cmbnet-pwa-v11'; const BASE = new URL('./', self.location).href; const SHELL_CACHE = `${VERSION}-shell`; const TILE_CACHE = `${VERSION}-tiles`; diff --git a/CMBNet/static/js/views/dispatcher.js b/CMBNet/static/js/views/dispatcher.js index 3a76ba3..f07d87d 100644 --- a/CMBNet/static/js/views/dispatcher.js +++ b/CMBNet/static/js/views/dispatcher.js @@ -50,6 +50,7 @@ const dispatcherState = { ws: null, authenticated: false, reconnectTimer: null, + lastWsSeq: null, crosshairGroupId: null, currentStreetId: null, streetsDialogGroupId: null, @@ -2717,13 +2718,21 @@ async function connectWebSocket() { ws.addEventListener('message', handleWsMessage); - ws.addEventListener('close', () => { + ws.addEventListener('close', event => { + if (dispatcherState.ws !== ws) return; + console.warn('[WS] Verbindung geschlossen', { + code: event.code, + reason: event.reason, + wasClean: event.wasClean + }); dispatcherState.authenticated = false; setConnectionStatus('Getrennt – neuer Versuch …', 'disconnected'); scheduleReconnect(); }); - ws.addEventListener('error', () => { + ws.addEventListener('error', event => { + if (dispatcherState.ws !== ws) return; + console.warn('[WS] Verbindungsfehler', event); setConnectionStatus('Verbindungsfehler', 'disconnected'); }); } catch (error) { @@ -2762,6 +2771,27 @@ function sendWs(message) { return true; } +function checkWsSequence(message) { + if (!Object.prototype.hasOwnProperty.call(message, 'seq')) return; + + const seq = Number(message.seq); + if (!Number.isFinite(seq) || seq <= 0) return; + + const lastSeq = dispatcherState.lastWsSeq; + if (lastSeq !== null && seq !== lastSeq + 1) { + const text = `Die WebSocket-Verbindung hat Nachrichten verloren ` + + `(erwartet: ${lastSeq + 1}, empfangen: ${seq}). ` + + 'Bitte lade die Seite neu, damit alle Änderungen sichtbar werden.'; + if (typeof window.showReloadNotice === 'function') { + window.showReloadNotice(text); + } else { + alert(`${text}\n\nBitte die Webseite neu laden.`); + } + } + + dispatcherState.lastWsSeq = lastSeq === null ? seq : Math.max(lastSeq, seq); +} + function handleWsMessage(event) { let message; try { @@ -2771,6 +2801,7 @@ function handleWsMessage(event) { return; } + checkWsSequence(message); console.debug('[WS RX]', message); console.log('[WS RX]', JSON.stringify(message)); @@ -2946,8 +2977,18 @@ function handleStreetUpdate(message) { recolorStreet(street); + // Ein offener Straßendialog muss den neuen Serverzustand anzeigen. + const streetModal = document.getElementById('streetModal'); + if (streetModal && streetModal.open + && dispatcherState.currentStreetId === Number(street.id)) { + const stateSelect = document.getElementById('streetStateSelect'); + if (stateSelect) stateSelect.value = street.state || 'unbearbeitet'; + fillStreetGroupOptions(street.group_id); + updateStreetGroupVisibility(); + } + const streetsDialog = document.getElementById('groupStreetsModal'); - if (dispatcherState.streetsDialogGroupId && streetsDialog.open) { + if (dispatcherState.streetsDialogGroupId && streetsDialog && streetsDialog.open) { renderGroupStreetsDialog(dispatcherState.streetsDialogGroupId); } } @@ -2964,6 +3005,7 @@ function handleGroupStateUpdate(message) { if (GROUP_STATES.includes(payload.state)) { group.state = payload.state; updateGroupSummary(group); + refreshGroupControls(); } } diff --git a/CMBNet/static/js/views/mobile.js b/CMBNet/static/js/views/mobile.js index 07990df..7d77136 100644 --- a/CMBNet/static/js/views/mobile.js +++ b/CMBNet/static/js/views/mobile.js @@ -48,6 +48,7 @@ const state = { authenticated: false, outbox: [], reconnectTimer: null, + lastWsSeq: null, chatMessages: [], chatKeys: new Set(), userMarker: null, @@ -694,7 +695,7 @@ function buildGroupSelect() { state.groups.forEach(g => { const opt = document.createElement('option'); opt.value = g.id; - opt.textContent = g.aliasname || g.id; + opt.textContent = `${g.aliasname || g.id} (${g.state || 'offen'})`; sel.appendChild(opt); }); } @@ -1141,8 +1142,51 @@ function openGroupNavigation() { window.location.href = buildNavigationUrl(coordinates.lat, coordinates.lon); } +function setMobileWsStatus(label, status) { + const element = document.getElementById('mobileWsStatus'); + if (!element) return; + + element.textContent = `WS: ${label}`; + element.title = `WebSocket: ${label}`; + element.classList.remove('is-connected', 'is-connecting', 'is-disconnected', 'is-error'); + element.classList.add(`is-${status}`); +} + +function scheduleMobileReconnect() { + if (state.reconnectTimer) return; + state.reconnectTimer = setTimeout(() => { + state.reconnectTimer = null; + connectWebSocket(); + }, 3000); +} + +function checkWsSequence(message) { + if (!Object.prototype.hasOwnProperty.call(message, 'seq')) return; + + const seq = Number(message.seq); + if (!Number.isFinite(seq) || seq <= 0) return; + + const lastSeq = state.lastWsSeq; + if (lastSeq !== null && seq !== lastSeq + 1) { + const text = `Die WebSocket-Verbindung hat Nachrichten verloren ` + + `(erwartet: ${lastSeq + 1}, empfangen: ${seq}). ` + + 'Bitte lade die Seite neu, damit alle Änderungen sichtbar werden.'; + if (typeof window.showReloadNotice === 'function') { + window.showReloadNotice(text); + } else { + alert(`${text}\n\nBitte die Webseite neu laden.`); + } + } + + // Bei einer Dublette nicht rückwärts zählen; so löst nicht jede folgende + // Nachricht erneut einen vermeintlichen Sprung aus. + state.lastWsSeq = lastSeq === null ? seq : Math.max(lastSeq, seq); +} + function connectWebSocket() { if (state.ws && (state.ws.readyState === WebSocket.OPEN || state.ws.readyState === WebSocket.CONNECTING)) return; + + setMobileWsStatus('verbinde …', 'connecting'); fetchJson(`${apiBase}/auth/ws-token`).then(res => { const token = res.token; const ws = new WebSocket(wsUrl); @@ -1151,6 +1195,7 @@ function connectWebSocket() { // Der Server bestätigt den Handshake mit Code 0. Bis dahin werden // fachliche Nachrichten im Outbox-Puffer gesammelt. state.authenticated = false; + setMobileWsStatus('Anmeldung …', 'connecting'); ws.send(JSON.stringify({ code: 0, msg: token, @@ -1167,17 +1212,31 @@ function connectWebSocket() { && ws.readyState === WebSocket.OPEN && !state.authenticated) { state.authenticated = true; + setMobileWsStatus('verbunden', 'connected'); flushWsOutbox(); } }, 1500); }); ws.addEventListener('message', handleWs); - ws.addEventListener('close', () => { + ws.addEventListener('close', event => { + if (state.ws !== ws) return; + console.warn('[WS] Verbindung geschlossen', { + code: event.code, + reason: event.reason, + wasClean: event.wasClean + }); state.authenticated = false; - setTimeout(connectWebSocket, 3000); + setMobileWsStatus('getrennt', 'disconnected'); + scheduleMobileReconnect(); + }); + ws.addEventListener('error', event => { + if (state.ws !== ws) return; + console.warn('[WS] Verbindungsfehler', event); + setMobileWsStatus('Fehler', 'error'); }); }).catch(() => { - setTimeout(connectWebSocket, 3000); + setMobileWsStatus('Token-Fehler', 'error'); + scheduleMobileReconnect(); }); } @@ -1325,16 +1384,127 @@ function parseFlexibleTimestamp(value) { return Number.isNaN(parsed) ? null : parsed; } +function applyMobileStreetUpdate(payload) { + if (!payload) return; + + const streetId = Number(payload.street_id); + const hasGroup = Object.prototype.hasOwnProperty.call(payload, 'group_id'); + const newGroupId = hasGroup && payload.group_id !== null && payload.group_id !== '' + ? Number(payload.group_id) + : null; + const ownGroupId = Number(state.currentGroupId) || null; + + let street = Number.isFinite(streetId) ? state.streetById.get(streetId) : null; + if (!street && payload.name) { + street = state.streets.find(item => item.name === payload.name) || null; + } + + if (!street) { + // Eine Straße kann durch eine Zuweisung neu in der Gruppe auftauchen. + // Der Broker liefert Name, ID, Status und Zielgruppe im Payload mit. + if (ownGroupId && newGroupId === ownGroupId + && Number.isFinite(streetId) && payload.name) { + street = { + id: streetId, + name: payload.name, + state: payload.state || 'zugewiesen', + group_id: ownGroupId + }; + state.streets.push(street); + state.streetById.set(street.id, street); + } else { + console.warn('[WS] Code 100: Straße nicht im lokalen Zustand', payload); + return; + } + } else { + if (payload.state) street.state = payload.state; + if (hasGroup) street.group_id = newGroupId; + + const index = state.streets.indexOf(street); + if (ownGroupId && hasGroup && newGroupId !== ownGroupId && index >= 0) { + // Die Straße wurde einer anderen Gruppe zugewiesen und gehört + // nicht mehr zur ToDo-Liste dieser Webview. + state.streets.splice(index, 1); + state.streetById.delete(street.id); + } else if (ownGroupId && newGroupId === ownGroupId && index < 0) { + state.streets.push(street); + state.streetById.set(street.id, street); + } + } + + const isCurrent = state.currentStreetId == street.id; + if (isCurrent && state.streetById.has(street.id)) { + if (state.currentPolyline) { + state.currentPolyline.setStyle({ + color: STREET_COLORS[street.state] || STREET_COLORS.unbearbeitet + }); + } + + const dialog = document.getElementById('mobileStreetStateDialog'); + if (dialog && dialog.open) { + document.getElementById('mobileStreetStateTitle').textContent = + `Straße: ${street.name}`; + document.getElementById('mobileStreetStateSelect').value = + street.state || 'unbearbeitet'; + fillMobileStreetGroupSelect(street.group_id); + updateMobileStreetGroupVisibility(); + } + } else if (isCurrent && !state.streetById.has(street.id)) { + if (state.currentPolyline) { + map.removeLayer(state.currentPolyline); + state.currentPolyline = null; + } + state.currentStreetId = null; + closeMobileStreetState(); + if (state.streets.length) { + selectStreet(state.streets[0]); + } + } + + buildStreetList(); + updateWorkButton(); +} + +function applyMobileGroupStateUpdate(message) { + const payload = typeof message.msg === 'string' + ? JSON.parse(message.msg) + : message.msg; + if (!payload) return; + + const groupId = Number(payload.group_id ?? message.receiver_id); + const group = state.groupById.get(groupId); + if (!group) { + console.warn('[WS] Code 200: Gruppe nicht im lokalen Zustand', payload); + return; + } + + if (payload.state) group.state = payload.state; + + if (viewMode === 'mobile_dispatcher') { + const select = document.getElementById('mobileGroupSelect'); + const option = select + ? select.querySelector(`option[value="${group.id}"]`) + : null; + if (option) { + option.textContent = `${group.aliasname || group.id} (${group.state || 'offen'})`; + } + updateNavigationButton(); + } +} + function handleWs(event) { let message; try { message = JSON.parse(event.data); } catch(e) { return; } + checkWsSequence(message); console.debug('[WS RX]', message); if (message.code === 0) { state.authenticated = true; + setMobileWsStatus('verbunden', 'connected'); flushWsOutbox(); } else if (message.code === 1) { + setMobileWsStatus('verbunden', 'connected'); if (state.ws && state.ws.readyState === WebSocket.OPEN) { state.ws.send(JSON.stringify({code: 2, msg: 'pong'})); } @@ -1351,20 +1521,17 @@ function handleWs(event) { // Street update try { const p = typeof message.msg === 'string' ? JSON.parse(message.msg) : message.msg; - if (p && p.street_id) { - const street = state.streetById.get(Number(p.street_id)); - if (street) { - if (p.state) street.state = p.state; - if (p.group_id !== undefined) street.group_id = p.group_id; - if (state.currentStreetId == street.id && state.currentPolyline) { - state.currentPolyline.setStyle({color: STREET_COLORS[street.state] || STREET_COLORS.unbearbeitet}); - } - buildStreetList(); - } else { - console.warn('[WS] Code 100: Straße nicht im lokalen Zustand', p); - } - } - } catch(e) {} + applyMobileStreetUpdate(p); + } catch(e) { + console.warn('[WS] Code 100 konnte nicht verarbeitet werden', e, message.msg); + } + } else if (message.code === 200) { + // Group state update + try { + applyMobileGroupStateUpdate(message); + } catch(e) { + console.warn('[WS] Code 200 konnte nicht verarbeitet werden', e, message.msg); + } } else if (message.code === 300) { // Group position try { @@ -1410,10 +1577,6 @@ function handleWs(event) { if (Number(message.sender_id) !== currentAccountId) { playSound(); showChatPopup(text, getSenderName(message, payload)); - // Switch to chat tab - document.querySelectorAll('.mobile-tab').forEach(b => { - if (b.dataset.tab === 'chat') b.click(); - }); } } } diff --git a/CMBNet/templates/dispatcher_mobil.html b/CMBNet/templates/dispatcher_mobil.html index fd7a7c1..bae25f9 100644 --- a/CMBNet/templates/dispatcher_mobil.html +++ b/CMBNet/templates/dispatcher_mobil.html @@ -25,6 +25,8 @@
+ WS: getrennt
diff --git a/CMBNet/templates/gruppen.html b/CMBNet/templates/gruppen.html index e675899..6cf5820 100644 --- a/CMBNet/templates/gruppen.html +++ b/CMBNet/templates/gruppen.html @@ -25,6 +25,8 @@
Gruppe
+ WS: getrennt
diff --git a/doc/broker.md b/doc/broker.md index fb62c01..77b07a0 100644 --- a/doc/broker.md +++ b/doc/broker.md @@ -96,6 +96,7 @@ Nach erfolgreicher Prüfung antwortet der Server mit einer Code-0-Bestätigung: "sender_id": 0, "receiver_id": null, "ts": 1793449907241, + "seq": 1, "msg": "authenticated" } ``` @@ -115,6 +116,7 @@ Alle Nachrichten werden als JSON-Text übertragen: "receiver_id": 20, "code": 100, "ts": 1793449907246, + "seq": 42, "msg": "{\"street_id\": 30, \"state\": \"erledigt\"}" } ``` @@ -124,8 +126,24 @@ Alle Nachrichten werden als JSON-Text übertragen: - `receiver_id`: Empfänger-ID, soweit sinnvoll; bei Broadcasts `null`. - `code`: primäres Steuerungsmerkmal. - `ts`: Zeitstempel in Millisekunden. +- `seq`: fortlaufende Sequenznummer für genau diese Client-ID. - `msg`: Text oder JSON-String mit dem fachlichen Inhalt. +Die Sequenznummer wird vom Broker erst beim tatsächlichen Versand an eine +Client-Verbindung ergänzt. Jede Client-ID besitzt eine eigene Zählung; mehrere +Clients desselben Accounts beeinflussen sich nicht. Die Zählung beginnt bei 1 +und bleibt über einen WebSocket-Reconnect derselben Webview erhalten. Wird eine +Nachricht gepuffert, erhält sie ihre Sequenznummer erst bei der späteren +Zustellung. Ein fehlgeschlagener Sendevorgang verbraucht keine Sequenznummer. +Nach einem Neuladen der Seite entsteht eine neue Client-ID und damit eine neue +Zählung ab 1. + +Clients merken sich die zuletzt empfangene Sequenznummer. Trifft nach einem +Reconnect eine andere Nummer als `zuletzt + 1` ein, zeigt der Client einen +Code-99-ähnlichen Neulade-Dialog an. Die Sequenzzählung liegt bewusst nur im +Broker-Prozess und nicht in der Datenbank; nach einem Broker-Neustart beginnt +sie neu und löst bei bereits geöffneten Clients den Neulade-Hinweis aus. + `sender_id` und `receiver_id` werden nicht in jedem Fall mit lesbaren Namen ergänzt. Chat-Nachrichten enthalten zusätzlich ein `sender`-Objekt mit Accountname, Rolle und Gruppenalias. Bei Code 100/200/300 enthält das Payload @@ -176,7 +194,7 @@ Der Broker sendet standardmäßig jede Minute eine Nachricht mit Code 1 an alle authentifizierten Verbindungen: ```json -{"sender_id": 0, "receiver_id": null, "code": 1, "ts": 1793449907241, "msg": "ping"} +{"sender_id": 0, "receiver_id": null, "code": 1, "ts": 1793449907241, "seq": 17, "msg": "ping"} ``` Die Heartbeat-Routine läuft in einem Daemon-Timer. Sie räumt zusätzlich @@ -282,6 +300,41 @@ Aktuelle Implementierung: aber keinen Historieneintrag und keinen Transaktionseintrag. - Das Payload enthält `group_id`, `lat`, `lon`, `ts` und `actor`. +### Anzeige in den Clients + +Nach der Zustellung müssen die Clients ihren lokalen Zustand und ihre Oberfläche +aktualisieren. Der aktuelle Stand: + +- **Mobile Clients**: Im Kopf der Gruppen- und Dispatcher-Mobil-Ansicht zeigt + ein Statusfeld den WebSocket-Zustand (`verbinde`, `verbunden`, `getrennt`, + `Fehler`). Die Anzeige wird bei Verbindungsaufbau, Code-0-Bestätigung, + Heartbeat, Trennung und Tokenfehler aktualisiert. +- **Dispatcher und Beobachter** (`dispatcher.js`): Code 100 aktualisiert den + Straßenzustand, färbt die Karte neu und synchronisiert ein offenes + Straßenfenster sowie die Straßenliste einer offenen Gruppe. Code 200 + aktualisiert Status-Badge und Statusauswahl der Gruppe sowie die + Gruppensteuerung. Code 300 verschiebt den Gruppenmarker und aktualisiert + Positionsalter, Fortschrittsanzeige und Navigationsbutton. +- **Dispatcher Mobil** (`mobile.js`, `mobile_dispatcher`): Code 100 + aktualisiert die Straßenliste, die aktuell gezeichnete Straße und ein + offenes Bearbeitungsfenster. Neu zugewiesene Straßen werden aufgenommen, + abgegebene Straßen entfernt. Code 200 aktualisiert den Gruppenstatus und den + Statustext im Gruppenauswahlfeld. Code 300 zeichnet alle Gruppenpositionen + neu und aktualisiert den Navigationsbutton. +- **Gruppen-View** (`mobile.js`, `mobile_group`): Code 100 aktualisiert die + ToDo-Liste und die Karte der eigenen Straßen. Code 200 aktualisiert den + Gruppenstatus im lokalen Zustand. Code 300 aktualisiert die Gruppendaten; + die eigene Position wird in dieser Ansicht weiterhin durch den lokalen + GPS-Marker dargestellt, deshalb wird kein zusätzlicher Gruppenmarker + gezeichnet. +- **Chat**: Eingehende Chat-Nachrichten werden im Chat-Verlauf ergänzt und + lösen Ton bzw. Benachrichtigung aus. Sie wechseln nicht mehr automatisch in + den Chat-Tab, damit die Kartenansicht während der Arbeit sichtbar bleibt. +- **Sequenzprüfung**: Mobile Clients, Dispatcher/Beobachter und der Admin- + Reload-Watcher vergleichen jede empfangene `seq` mit ihrer letzten Zählung. + Bei einer Lücke erscheint der Neulade-Dialog; die Nachricht wird trotzdem + verarbeitet. + ## 6. Chat-Nachrichten ab Code 1000 Alle Nachrichten ab Code 1000 werden in `ws_messages_store` persistiert. Sie @@ -336,13 +389,17 @@ Absenders sein; Nachrichten an eine fremde Gruppe werden abgewiesen. ```text connections[tenant_id][client_id] = { ws, account_id, client_id, role, group_id, - last_ping, connected_at, last_pong_at, send_lock + last_ping, connected_at, last_pong_at, send_lock, seq } ``` Eine Client-ID gehört genau zu einer Webview. Ein Account kann daher mehrere Clients parallel betreiben. Eine neue Verbindung mit derselben Client-ID ersetzt nur diese eine Verbindung; andere Clients desselben Accounts bleiben erhalten. +Die zuletzt zugestellte Sequenznummer wird zusätzlich in +`client_sequences[(tenant_id, client_id)]` geführt, damit sie einen Reconnect +überlebt. `client_sequence_locks[(tenant_id, client_id)]` serialisiert +Sequenzvergabe und Versand pro Client. `authenticated[tenant_id][client_id]` speichert den Authentifizierungsstatus. Ohne erfolgreichen Code-0-Handshake werden keine fachlichen Nachrichten @@ -352,7 +409,8 @@ Zusätzlich hält der Broker: - `client_accounts[(tenant_id, client_id)] = account_id`, - `account_clients[(tenant_id, account_id)] = {client_id, ...}`, -- `disconnected_clients[(tenant_id, client_id)] = Zeitpunkt`. +- `disconnected_clients[(tenant_id, client_id)] = Zeitpunkt`, +- `client_sequences[(tenant_id, client_id)] = letzte Sequenznummer`. Diese Zuordnungen bleiben nach einem Verbindungsabbruch erhalten, damit kurzfristige Reconnects ihre Queue wiederfinden. Dauerhaft verlassene Webviews @@ -387,7 +445,10 @@ zuerst die Authentifizierung: Der direkte Versand erfolgt pro Verbindung über einen `send_lock`. Dadurch werden Heartbeat, Route-Thread und HTTP-ausgelöste Broadcasts nicht gleichzeitig -in denselben Socket schreiben. +in denselben Socket schreiben. Zusätzlich serialisiert ein pro Client-ID +geführtes `sequence_lock` die Sequenzvergabe und den Sendevorgang. Erst nach +erfolgreichem `send()` wird die Sequenznummer fortgeschrieben; schlägt der +Versand fehl, bleibt sie unverändert und die Nachricht wird gepuffert. ### Client-Queues