fix: remove node_modules

test/demo-discovery.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+
+/**
+ * Demo script for UDP discovery functionality
+ * Monitors the discovery endpoints to show how nodes are discovered
+ */
+
+const http = require('http');
+
+const BASE_URL = 'http://localhost:3001';
+
+function makeRequest(path, method = 'GET') {
+  return new Promise((resolve, reject) => {
+    const options = {
+      hostname: 'localhost',
+      port: 3001,
+      path: path,
+      method: method,
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    };
+
+    const req = http.request(options, (res) => {
+      let data = '';
+      
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+      
+      res.on('end', () => {
+        try {
+          const jsonData = JSON.parse(data);
+          resolve({ status: res.statusCode, data: jsonData });
+        } catch (error) {
+          resolve({ status: res.statusCode, data: data });
+        }
+      });
+    });
+
+    req.on('error', (error) => {
+      reject(error);
+    });
+
+    req.end();
+  });
+}
+
+async function checkHealth() {
+  try {
+    const response = await makeRequest('/api/health');
+    console.log('\n=== Health Check ===');
+    console.log(`Status: ${response.data.status}`);
+    console.log(`HTTP Service: ${response.data.services.http}`);
+    console.log(`UDP Service: ${response.data.services.udp}`);
+    console.log(`SPORE Client: ${response.data.services.sporeClient}`);
+    console.log(`Total Nodes: ${response.data.discovery.totalNodes}`);
+    console.log(`Primary Node: ${response.data.discovery.primaryNode || 'None'}`);
+    
+    if (response.data.message) {
+      console.log(`Message: ${response.data.message}`);
+    }
+  } catch (error) {
+    console.error('Health check failed:', error.message);
+  }
+}
+
+async function checkDiscovery() {
+  try {
+    const response = await makeRequest('/api/discovery/nodes');
+    console.log('\n=== Discovery Status ===');
+    console.log(`Primary Node: ${response.data.primaryNode || 'None'}`);
+    console.log(`Total Nodes: ${response.data.totalNodes}`);
+    console.log(`Client Initialized: ${response.data.clientInitialized}`);
+    
+    if (response.data.clientBaseUrl) {
+      console.log(`Client Base URL: ${response.data.clientBaseUrl}`);
+    }
+    
+    if (response.data.nodes.length > 0) {
+      console.log('\nDiscovered Nodes:');
+      response.data.nodes.forEach((node, index) => {
+        console.log(`  ${index + 1}. ${node.ip}:${node.port} (${node.isPrimary ? 'PRIMARY' : 'secondary'})`);
+        console.log(`     Discovered: ${node.discoveredAt}`);
+        console.log(`     Last Seen: ${node.lastSeen}`);
+      });
+    } else {
+      console.log('No nodes discovered yet.');
+    }
+  } catch (error) {
+    console.error('Discovery check failed:', error.message);
+  }
+}
+
+async function runDemo() {
+  console.log('🚀 SPORE UDP Discovery Demo');
+  console.log('============================');
+  console.log('This demo monitors the discovery endpoints to show how nodes are discovered.');
+  console.log('Start the backend server with: npm start');
+  console.log('Send discovery messages with: npm run test-discovery broadcast');
+  console.log('');
+  
+  // Initial check
+  await checkHealth();
+  await checkDiscovery();
+  
+  // Set up periodic monitoring
+  console.log('\n📡 Monitoring discovery endpoints every 5 seconds...');
+  console.log('Press Ctrl+C to stop\n');
+  
+  setInterval(async () => {
+    await checkHealth();
+    await checkDiscovery();
+  }, 5000);
+}
+
+// Handle graceful shutdown
+process.on('SIGINT', () => {
+  console.log('\n\n👋 Demo stopped. Goodbye!');
+  process.exit(0);
+});
+
+// Run the demo
+runDemo().catch(console.error); 

test/test-discovery.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+/**
+ * Test script for UDP discovery
+ * Sends CLUSTER_DISCOVERY messages to test the backend discovery functionality
+ */
+
+const dgram = require('dgram');
+const client = dgram.createSocket('udp4');
+
+const DISCOVERY_MESSAGE = 'CLUSTER_DISCOVERY';
+const TARGET_PORT = 4210;
+const BROADCAST_ADDRESS = '255.255.255.255';
+
+// Enable broadcast
+client.setBroadcast(true);
+
+function sendDiscoveryMessage() {
+  const message = Buffer.from(DISCOVERY_MESSAGE);
+  
+  client.send(message, 0, message.length, TARGET_PORT, BROADCAST_ADDRESS, (err) => {
+    if (err) {
+      console.error('Error sending discovery message:', err);
+    } else {
+      console.log(`Sent CLUSTER_DISCOVERY message to ${BROADCAST_ADDRESS}:${TARGET_PORT}`);
+    }
+  });
+}
+
+function sendDiscoveryToSpecificIP(ip) {
+  const message = Buffer.from(DISCOVERY_MESSAGE);
+  
+  client.send(message, 0, message.length, TARGET_PORT, ip, (err) => {
+    if (err) {
+      console.error(`Error sending discovery message to ${ip}:`, err);
+    } else {
+      console.log(`Sent CLUSTER_DISCOVERY message to ${ip}:${TARGET_PORT}`);
+    }
+  });
+}
+
+// Main execution
+const args = process.argv.slice(2);
+
+if (args.length === 0) {
+  console.log('Usage: node test-discovery.js [broadcast|ip] [count]');
+  console.log('  broadcast: Send to broadcast address (default)');
+  console.log('  ip: Send to specific IP address');
+  console.log('  count: Number of messages to send (default: 1)');
+  process.exit(1);
+}
+
+const target = args[0];
+const count = parseInt(args[1]) || 1;
+
+console.log(`Sending ${count} discovery message(s) to ${target === 'broadcast' ? 'broadcast' : target}`);
+
+if (target === 'broadcast') {
+  for (let i = 0; i < count; i++) {
+    setTimeout(() => {
+      sendDiscoveryMessage();
+    }, i * 1000); // Send one message per second
+  }
+} else {
+  // Assume it's an IP address
+  for (let i = 0; i < count; i++) {
+    setTimeout(() => {
+      sendDiscoveryToSpecificIP(target);
+    }, i * 1000); // Send one message per second
+  }
+}
+
+// Close the client after sending all messages
+setTimeout(() => {
+  client.close();
+  console.log('Test completed');
+}, (count + 1) * 1000);