torsten/yourpart3
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor: Entfernen des Daemon WebSocket und Umstellung auf Socket.io für Event-Verarbeitung

Browse Source 
Änderungen:
- Der Daemon WebSocket wurde aus der Anwendung entfernt, um die Komplexität zu reduzieren und die Stabilität zu erhöhen.
- Die Event-Verarbeitung in StatusBar.vue und BranchView.vue wurde aktualisiert, um Socket.io für die Registrierung und Verarbeitung von Live-Events zu verwenden.
- Protokollausgaben wurden hinzugefügt, um den Empfang und die Verarbeitung von Events zu dokumentieren.

Diese Anpassungen verbessern die Nachvollziehbarkeit der Event-Verarbeitung und vereinfachen die Codebasis.
This commit is contained in:
Torsten Schulz (local)
2025-09-08 17:02:14 +02:00
parent 0c9f4bb952
commit 6bb4cd3478
5 changed files with 118 additions and 403 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
backend/server.js
View File

@@ -4,7 +4,6 @@ import http from 'http';
import app from './app.js'; import app from './app.js';
import { setupWebSocket } from './utils/socket.js'; import { setupWebSocket } from './utils/socket.js';
import { syncDatabase } from './utils/syncDatabase.js'; import { syncDatabase } from './utils/syncDatabase.js';
import daemonBridge from './services/daemonWebSocketBridge.js';
const server = http.createServer(app); const server = http.createServer(app);
@@ -14,10 +13,6 @@ syncDatabase().then(() => {
const port = process.env.PORT || 3001; const port = process.env.PORT || 3001;
server.listen(port, () => { server.listen(port, () => {
console.log('Server is running on port', port); console.log('Server is running on port', port);
// Starte Daemon WebSocket Bridge
console.log('🔌 Starte Daemon WebSocket Bridge...');
daemonBridge.connect();
}); });
}).catch(err => { }).catch(err => {
console.error('Failed to sync database:', err); console.error('Failed to sync database:', err);

233
backend/services/daemonWebSocketBridge.js
View File

@@ -1,233 +0,0 @@
// services/daemonWebSocketBridge.js
import WebSocket from 'ws';
import { getIo } from '../utils/socket.js';
class DaemonWebSocketBridge {
constructor() {
this.daemonSocket = null;
this.reconnectInterval = 5000;
this.maxReconnectAttempts = 10;
this.reconnectAttempts = 0;
this.isConnected = false;
}
connect() {
if (this.daemonSocket && this.daemonSocket.readyState === WebSocket.OPEN) {
console.log('🔌 Daemon WebSocket bereits verbunden');
return;
}
const daemonUrl = process.env.DAEMON_WS_URL || 'wss://www.your-part.de:4551';
console.log('🔌 Verbinde mit Daemon WebSocket:', daemonUrl);
try {
this.daemonSocket = new WebSocket(daemonUrl);
this.daemonSocket.on('open', () => {
console.log('✅ Daemon WebSocket verbunden');
console.log('🔍 Daemon URL:', daemonUrl);
console.log('🔍 ReadyState:', this.daemonSocket.readyState);
console.log('🔍 Protocol:', this.daemonSocket.protocol);
console.log('🔍 Extensions:', this.daemonSocket.extensions);
this.isConnected = true;
this.reconnectAttempts = 0;
// Registriere uns beim Daemon
console.log('📤 Registriere Backend beim Daemon...');
this.send({
event: 'register_backend',
data: { type: 'backend_bridge' }
});
});
this.daemonSocket.on('message', (data) => {
const rawMessage = data.toString();
console.log('='.repeat(80));
console.log('📨 DAEMON → BACKEND');
console.log('📨 Raw Message:', rawMessage);
console.log('📨 Länge:', rawMessage.length);
console.log('📨 Zeitstempel:', new Date().toISOString());
// Ignoriere ping/pong-Nachrichten
if (rawMessage === 'ping' || rawMessage === 'pong') {
console.log('🏓 Ping/Pong-Nachricht ignoriert');
console.log('='.repeat(80));
return;
}
try {
const message = JSON.parse(rawMessage);
console.log('✅ JSON erfolgreich geparst');
console.log('📨 Parsed Message:', JSON.stringify(message, null, 2));
this.handleDaemonMessage(message);
} catch (error) {
console.error('❌ JSON Parse Fehler:');
console.error('❌ Error:', error.message);
console.error('❌ Raw data:', rawMessage);
console.error('❌ Hex:', Buffer.from(rawMessage, 'utf8').toString('hex'));
console.log('='.repeat(80));
}
});
this.daemonSocket.on('close', (code, reason) => {
console.log('❌ Daemon WebSocket getrennt:', code, reason.toString());
this.isConnected = false;
this.scheduleReconnect();
});
this.daemonSocket.on('error', (error) => {
console.error('❌ Daemon WebSocket Fehler:', error.message);
this.isConnected = false;
});
} catch (error) {
console.error('❌ Fehler beim Erstellen der Daemon WebSocket-Verbindung:', error);
this.scheduleReconnect();
}
}
handleDaemonMessage(message) {
console.log('🔍 BACKEND VERARBEITUNG');
console.log('🔍 Message Type:', typeof message);
console.log('🔍 Message Keys:', Object.keys(message || {}));
// Prüfe verschiedene Nachrichtenformate
let eventName = null;
let eventData = {};
if (message.event) {
// Standard-Format: { event: 'eventName', data: {...} }
console.log('🔍 Format: Standard (event)');
eventName = message.event;
eventData = message.data || {};
} else if (message.type) {
// Alternative Format: { type: 'eventName', ... }
console.log('🔍 Format: Alternative (type)');
eventName = message.type;
eventData = { ...message };
delete eventData.type;
} else if (typeof message === 'string') {
// String-Format: 'eventName'
console.log('🔍 Format: String');
eventName = message;
} else if (Array.isArray(message)) {
// Array-Format: ['eventName', {...}]
console.log('🔍 Format: Array');
eventName = message[0];
eventData = message[1] || {};
} else {
console.log('⚠️ Format: Unbekannt');
eventName = 'unknown_event';
eventData = message;
}
console.log('🔍 Extracted Event:', eventName);
console.log('🔍 Extracted Data:', eventData);
// Leite spezifische Events an Socket.io weiter
if (eventName) {
const io = getIo();
console.log('📤 BACKEND → FRONTEND');
console.log('📤 Socket.io verfügbar:', !!io);
console.log('📤 Event Name:', eventName);
console.log('📤 Event Data:', eventData);
switch (eventName) {
case 'production_ready':
case 'stock_change':
case 'price_update':
case 'director_death':
case 'production_started':
case 'selled_items':
case 'falukantUpdateStatus':
case 'falukantBranchUpdate':
case 'knowledge_update':
case 'familychanged':
// Broadcast an alle verbundenen Clients
console.log(`📤 Sende Event "${eventName}" an alle Socket.io Clients...`);
if (io) {
io.emit(eventName, eventData);
console.log(`✅ Event "${eventName}" erfolgreich an Socket.io gesendet`);
console.log(`✅ Data:`, JSON.stringify(eventData, null, 2));
} else {
console.error('❌ Socket.io nicht verfügbar!');
}
break;
case 'workerStatus':
// Spezielle Behandlung für Worker-Status
console.log(`📤 Sende Worker-Status Event an alle Socket.io Clients...`);
if (io) {
io.emit('daemon_worker_status', eventData);
console.log(`✅ Worker-Status erfolgreich an Socket.io gesendet`);
console.log(`✅ Data:`, JSON.stringify(eventData, null, 2));
} else {
console.error('❌ Socket.io nicht verfügbar!');
}
break;
default:
console.log('⚠️ Unbekanntes Daemon-Event:', eventName);
console.log('⚠️ Event wird nicht weitergeleitet');
}
} else {
console.log('⚠️ Kein Event-Name extrahiert - keine Weiterleitung');
}
console.log('='.repeat(80));
}
send(data) {
console.log('📤 BACKEND → DAEMON');
console.log('📤 Data:', JSON.stringify(data, null, 2));
console.log('📤 WebSocket Status:', this.daemonSocket ? this.daemonSocket.readyState : 'CLOSED');
if (this.daemonSocket && this.daemonSocket.readyState === WebSocket.OPEN) {
const message = JSON.stringify(data);
console.log('📤 Sende an Daemon:', message);
this.daemonSocket.send(message);
console.log('✅ Nachricht erfolgreich an Daemon gesendet');
} else {
console.warn('⚠️ Daemon WebSocket nicht verbunden - kann Nachricht nicht senden');
console.warn('⚠️ ReadyState:', this.daemonSocket ? this.daemonSocket.readyState : 'CLOSED');
}
console.log('='.repeat(80));
}
scheduleReconnect() {
if (this.reconnectAttempts >= this.maxReconnectAttempts) {
console.error('❌ Maximale Wiederverbindungsversuche erreicht');
return;
}
this.reconnectAttempts++;
const delay = Math.min(this.reconnectInterval * this.reconnectAttempts, 30000);
console.log(`🔄 Wiederverbindung in ${delay}ms (Versuch ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
setTimeout(() => {
this.connect();
}, delay);
}
disconnect() {
if (this.daemonSocket) {
this.daemonSocket.close();
this.daemonSocket = null;
this.isConnected = false;
}
}
getStatus() {
return {
connected: this.isConnected,
reconnectAttempts: this.reconnectAttempts,
readyState: this.daemonSocket ? this.daemonSocket.readyState : 'CLOSED'
};
}
}
// Singleton-Instanz
const daemonBridge = new DaemonWebSocketBridge();
export default daemonBridge;

44
frontend/src/components/falukant/StatusBar.vue
View File

@@ -56,14 +56,25 @@ export default {
}, },
async mounted() { async mounted() {
await this.fetchStatus(); await this.fetchStatus();
this.setupSocketEvents();
// Live-Socket-Events
["falukantUpdateStatus", "stock_change", "familychanged"].forEach(eventName => {
if (this.daemonSocket) {
this.daemonSocket.addEventListener('message', (event) => {
try {
const data = JSON.parse(event.data);
if (data.event === eventName) {
this.handleEvent(data);
}
} catch (error) {
// Ignore non-JSON messages like ping/pong
}
});
}
});
}, },
beforeUnmount() { beforeUnmount() {
if (this.socket) { // Daemon WebSocket wird automatisch beim Logout geschlossen
this.socket.off("falukantUpdateStatus");
this.socket.off("stock_change");
this.socket.off("familychanged");
}
}, },
methods: { methods: {
async fetchStatus() { async fetchStatus() {
@@ -106,27 +117,6 @@ export default {
console.error("Error fetching status:", error); console.error("Error fetching status:", error);
} }
}, },
// Daemon WebSocket deaktiviert - verwende Socket.io Events
setupSocketEvents() {
if (this.socket) {
this.socket.on('falukantUpdateStatus', (data) => {
console.log('📨 StatusBar: falukantUpdateStatus empfangen:', data);
this.handleEvent({ event: 'falukantUpdateStatus', ...data });
});
this.socket.on('stock_change', (data) => {
console.log('📨 StatusBar: stock_change empfangen:', data);
this.handleEvent({ event: 'stock_change', ...data });
});
this.socket.on('familychanged', (data) => {
console.log('📨 StatusBar: familychanged empfangen:', data);
this.handleEvent({ event: 'familychanged', ...data });
});
console.log('✅ StatusBar: Socket.io Events registriert');
} else {
console.log('⚠️ StatusBar: Socket.io noch nicht verfügbar');
setTimeout(() => this.setupSocketEvents(), 1000);
}
},
handleEvent(eventData) { handleEvent(eventData) {
console.log('🔄 StatusBar: handleEvent aufgerufen mit:', eventData); console.log('🔄 StatusBar: handleEvent aufgerufen mit:', eventData);
console.log('🔄 StatusBar: Event-Typ:', eventData.event); console.log('🔄 StatusBar: Event-Typ:', eventData.event);

179
frontend/src/store/index.js
View File

@@ -122,102 +122,91 @@ const store = createStore({
} }
}, },
initializeDaemonSocket({ commit, state }) { initializeDaemonSocket({ commit, state }) {
// Daemon WebSocket temporär deaktiviert aufgrund von CORS/Protokoll-Problemen if (!state.isLoggedIn || !state.user) {
// Socket.io wird für alle Events verwendet console.log("User is not logged in or user data is not available for Daemon WebSocket.");
console.log('🔌 Daemon WebSocket deaktiviert - verwende Socket.io für alle Events'); return;
return;
if (state.isLoggedIn && state.user) {
let currentDaemonSocket = state.daemonSocket;
const connectDaemonSocket = () => {
if (currentDaemonSocket) {
currentDaemonSocket.disconnect();
}
const daemonUrl = import.meta.env.VITE_DAEMON_SOCKET || 'wss://www.your-part.de:4551';
console.log('🔌 Initializing Daemon WebSocket connection to:', daemonUrl);
console.log('🔌 Protocol:', 'yourpart-protocol');
try {
// Versuche zuerst ohne Protokoll, da der Server es möglicherweise nicht unterstützt
let daemonSocket;
try {
console.log('🔌 Trying WebSocket connection without protocol...');
daemonSocket = new WebSocket(daemonUrl);
} catch (error) {
console.error('❌ Failed to create WebSocket:', error);
throw error;
}
daemonSocket.onopen = () => {
console.log('✅ Daemon WebSocket connected successfully');
retryCount = 0; // Reset retry counter on successful connection
const payload = JSON.stringify({
user_id: state.user.id,
event: 'setUserId',
data: { userId: state.user.id }
});
daemonSocket.send(payload);
};
daemonSocket.onclose = (event) => {
console.warn('❌ Daemon WebSocket disconnected:', event.reason);
console.warn('❌ Close details:', {
code: event.code,
reason: event.reason,
wasClean: event.wasClean,
readyState: daemonSocket.readyState
});
retryConnection(connectDaemonSocket);
};
daemonSocket.onerror = (error) => {
console.error('❌ Daemon WebSocket error:', error);
console.error('❌ Error details:', {
type: error.type,
target: error.target,
readyState: daemonSocket.readyState,
url: daemonSocket.url,
protocol: daemonSocket.protocol
});
retryConnection(connectDaemonSocket);
};
daemonSocket.addEventListener('message', (event) => {
const message = event.data;
if (message === "ping") {
daemonSocket.send("pong");
} else {
try {
const data = JSON.parse(message);
} catch (error) {
console.error("Error parsing message:", error);
}
}
});
commit('setDaemonSocket', daemonSocket);
} catch (error) {
console.error('❌ Failed to create Daemon WebSocket:', error);
console.error('❌ URL attempted:', import.meta.env.VITE_DAEMON_SOCKET);
retryConnection(connectDaemonSocket);
}
};
let retryCount = 0;
const maxRetries = 5;
const retryConnection = (reconnectFn) => {
if (retryCount >= maxRetries) {
console.error('❌ Max retry attempts reached for Daemon WebSocket');
return;
}
retryCount++;
const delay = Math.min(1000 * Math.pow(2, retryCount - 1), 10000); // Exponential backoff, max 10s
console.log(`🔄 Retrying Daemon WebSocket connection in ${delay}ms (attempt ${retryCount}/${maxRetries})`);
setTimeout(() => {
reconnectFn();
}, delay);
};
connectDaemonSocket();
} }
const daemonUrl = import.meta.env.VITE_DAEMON_SOCKET || 'wss://www.your-part.de:4551';
console.log('🔌 Initializing Daemon WebSocket connection to:', daemonUrl);
const connectDaemonSocket = () => {
try {
const daemonSocket = new WebSocket(daemonUrl, 'yourpart-protocol');
console.log('🔌 Protocol: yourpart-protocol');
daemonSocket.onopen = () => {
console.log('✅ Daemon WebSocket connected successfully');
retryCount = 0; // Reset retry counter on successful connection
const payload = JSON.stringify({
user_id: state.user.id,
event: 'setUserId',
data: { userId: state.user.id }
});
daemonSocket.send(payload);
};
daemonSocket.onclose = (event) => {
console.warn('❌ Daemon WebSocket disconnected:', event.reason);
console.warn('❌ Close details:', {
code: event.code,
reason: event.reason,
wasClean: event.wasClean,
readyState: daemonSocket.readyState
});
retryConnection(connectDaemonSocket);
};
daemonSocket.onerror = (error) => {
console.error('❌ Daemon WebSocket error:', error);
console.error('❌ Error details:', {
type: error.type,
target: error.target,
readyState: daemonSocket.readyState,
url: daemonSocket.url,
protocol: daemonSocket.protocol
});
retryConnection(connectDaemonSocket);
};
daemonSocket.addEventListener('message', (event) => {
const message = event.data;
if (message === "ping") {
daemonSocket.send("pong");
} else {
try {
const data = JSON.parse(message);
// Handle daemon messages here
console.log('📨 Daemon message received:', data);
} catch (error) {
console.error("Error parsing daemon message:", error);
}
}
});
commit('setDaemonSocket', daemonSocket);
} catch (error) {
console.error('❌ Failed to create Daemon WebSocket:', error);
console.error('❌ URL attempted:', import.meta.env.VITE_DAEMON_SOCKET);
retryConnection(connectDaemonSocket);
}
};
let retryCount = 0;
const maxRetries = 5;
const retryConnection = (reconnectFn) => {
if (retryCount >= maxRetries) {
console.error('❌ Max retry attempts reached for Daemon WebSocket');
return;
}
retryCount++;
const delay = Math.min(1000 * Math.pow(2, retryCount - 1), 10000); // Exponential backoff, max 10s
console.log(`🔄 Retrying Daemon WebSocket connection in ${delay}ms (attempt ${retryCount}/${maxRetries})`);
setTimeout(() => {
reconnectFn();
}, delay);
};
connectDaemonSocket();
}, },
setLanguage({ commit }, language) { setLanguage({ commit }, language) {
commit('setLanguage', language); commit('setLanguage', language);

60
frontend/src/views/falukant/BranchView.vue
View File

@@ -55,7 +55,7 @@ export default {
}, },
computed: { computed: {
...mapState(['socket', 'daemonSocket']), ...mapState(['daemonSocket']),
}, },
async mounted() { async mounted() {
@@ -72,58 +72,32 @@ export default {
this.selectMainBranch(); this.selectMainBranch();
} }
// Daemon WebSocket deaktiviert - verwende Socket.io // Live-Socket-Events
this.setupSocketEvents();
// Live-Socket-Events - nur für Events ohne spezielle Behandlung
[ [
"production_ready", "production_ready", "stock_change", "price_update",
"stock_change", "director_death", "production_started", "selled_items",
"price_update", "knowledge_update", "falukantUpdateStatus", "falukantBranchUpdate"
"director_death",
"production_started",
"selled_items",
"knowledge_update"
].forEach(eventName => { ].forEach(eventName => {
if (this.socket) { if (this.daemonSocket) {
this.socket.on(eventName, data => this.handleEvent({ event: eventName, ...data })); this.daemonSocket.addEventListener('message', (event) => {
try {
const data = JSON.parse(event.data);
if (data.event === eventName) {
this.handleEvent(data);
}
} catch (error) {
// Ignore non-JSON messages like ping/pong
}
});
} }
}); });
}, },
beforeUnmount() { beforeUnmount() {
if (this.socket) { // Daemon WebSocket wird automatisch beim Logout geschlossen
// Entferne spezielle Event-Listener
this.socket.off("falukantBranchUpdate");
this.socket.off("falukantUpdateStatus");
// Entferne allgemeine Event-Listener
this.socket.off("production_ready");
this.socket.off("stock_change");
this.socket.off("price_update");
this.socket.off("director_death");
this.socket.off("production_started");
this.socket.off("selled_items");
this.socket.off("knowledge_update");
}
}, },
methods: { methods: {
setupSocketEvents() {
if (this.socket) {
this.socket.on('falukantBranchUpdate', (data) => {
console.log('📨 BranchView: falukantBranchUpdate empfangen:', data);
this.handleEvent({ event: 'falukantBranchUpdate', ...data });
});
this.socket.on('falukantUpdateStatus', (data) => {
console.log('📨 BranchView: falukantUpdateStatus empfangen:', data);
this.handleEvent({ event: 'falukantUpdateStatus', ...data });
});
console.log('✅ BranchView: Socket.io Events registriert');
} else {
console.log('⚠️ BranchView: Socket.io noch nicht verfügbar');
setTimeout(() => this.setupSocketEvents(), 1000);
}
},
async loadBranches() { async loadBranches() {
try { try {
const result = await apiClient.get('/api/falukant/branches'); const result = await apiClient.get('/api/falukant/branches');