queen-mq 0.1.0

package/examples/multi-server-test.js

@@ -0,0 +1,305 @@
+#!/usr/bin/env node
+
+/**
+ * Multi-Server Load Balancing Test
+ * 
+ * This script tests the Queen client with multiple servers using different
+ * load balancing strategies (ROUND_ROBIN and SESSION).
+ * 
+ * Usage:
+ * 1. Start two Queen servers on different ports:
+ *    PORT=6632 node src/server.js
+ *    PORT=6633 node src/server.js
+ * 
+ * 2. Run this test:
+ *    node examples/multi-server-test.js
+ */
+
+import { createQueenClient, LoadBalancingStrategy } from '../src/client/index.js';
+
+const servers = [
+  'http://localhost:6632',
+  'http://localhost:6633'
+];
+
+// Test configuration
+const TEST_QUEUE = 'multi-server-test';
+const TEST_NAMESPACE = 'load-balancing';
+
+// Helper to log with timestamp
+const log = (message, type = 'info') => {
+  const timestamp = new Date().toISOString();
+  const prefix = type === 'error' ? '❌' : type === 'success' ? '✅' : 'ℹ️';
+  console.log(`[${timestamp}] ${prefix} ${message}`);
+};
+
+// Test Round Robin strategy
+async function testRoundRobinStrategy() {
+  log('Testing ROUND_ROBIN load balancing strategy', 'info');
+  
+  const client = createQueenClient({
+    baseUrls: servers,
+    loadBalancingStrategy: LoadBalancingStrategy.ROUND_ROBIN,
+    enableFailover: true
+  });
+  
+  // Configure the queue
+  await client.configure({
+    queue: TEST_QUEUE,
+    namespace: TEST_NAMESPACE,
+    task: 'round-robin-test',
+    options: {
+      maxRetries: 3,
+      retryDelay: 1000
+    }
+  });
+  
+  // Push multiple messages to see round-robin distribution
+  const messages = [];
+  for (let i = 1; i <= 10; i++) {
+    messages.push({
+      queue: TEST_QUEUE,
+      partition: 'Default',
+      payload: { 
+        id: i, 
+        strategy: 'round-robin',
+        timestamp: Date.now() 
+      }
+    });
+  }
+  
+  log(`Pushing ${messages.length} messages with ROUND_ROBIN strategy`);
+  const pushResult = await client.push({ items: messages });
+  log(`Pushed messages: ${JSON.stringify(pushResult)}`, 'success');
+  
+  // Get load balancer stats
+  const stats = client.getLoadBalancerStats();
+  log(`Load balancer stats: ${JSON.stringify(stats, null, 2)}`);
+  
+  // Pop messages to verify they were stored
+  log('Popping messages to verify...');
+  const popResult = await client.pop({
+    queue: TEST_QUEUE,
+    batch: 5,
+    wait: false
+  });
+  
+  if (popResult.messages && popResult.messages.length > 0) {
+    log(`Retrieved ${popResult.messages.length} messages`, 'success');
+    
+    // Acknowledge messages
+    for (const msg of popResult.messages) {
+      await client.ack(msg.transactionId, 'completed');
+    }
+    log('Messages acknowledged', 'success');
+  } else {
+    log('No messages retrieved', 'warning');
+  }
+  
+  return client;
+}
+
+// Test Session affinity strategy
+async function testSessionStrategy() {
+  log('\nTesting SESSION load balancing strategy', 'info');
+  
+  const client = createQueenClient({
+    baseUrls: servers,
+    loadBalancingStrategy: LoadBalancingStrategy.SESSION,
+    enableFailover: true
+  });
+  
+  // Configure the queue
+  await client.configure({
+    queue: TEST_QUEUE,
+    namespace: TEST_NAMESPACE,
+    task: 'session-test',
+    options: {
+      maxRetries: 3,
+      retryDelay: 1000
+    }
+  });
+  
+  // Push multiple messages - should all go to the same server
+  const messages = [];
+  for (let i = 1; i <= 10; i++) {
+    messages.push({
+      queue: TEST_QUEUE,
+      partition: 'Session',
+      payload: { 
+        id: i, 
+        strategy: 'session',
+        timestamp: Date.now() 
+      }
+    });
+  }
+  
+  log(`Pushing ${messages.length} messages with SESSION strategy`);
+  const pushResult = await client.push({ items: messages });
+  log(`Pushed messages: ${JSON.stringify(pushResult)}`, 'success');
+  
+  // Get load balancer stats
+  const stats = client.getLoadBalancerStats();
+  log(`Load balancer stats: ${JSON.stringify(stats, null, 2)}`);
+  
+  // Pop messages to verify they were stored
+  log('Popping messages to verify...');
+  const popResult = await client.pop({
+    queue: TEST_QUEUE,
+    partition: 'Session',
+    batch: 5,
+    wait: false
+  });
+  
+  if (popResult.messages && popResult.messages.length > 0) {
+    log(`Retrieved ${popResult.messages.length} messages from session-affinity server`, 'success');
+    
+    // Acknowledge messages
+    for (const msg of popResult.messages) {
+      await client.ack(msg.transactionId, 'completed');
+    }
+    log('Messages acknowledged', 'success');
+  } else {
+    log('No messages retrieved', 'warning');
+  }
+  
+  return client;
+}
+
+// Test failover behavior
+async function testFailover() {
+  log('\nTesting failover behavior (requires one server to be down)', 'info');
+  
+  const client = createQueenClient({
+    baseUrls: [
+      'http://localhost:9999', // Non-existent server
+      'http://localhost:6632'  // Working server
+    ],
+    loadBalancingStrategy: LoadBalancingStrategy.ROUND_ROBIN,
+    enableFailover: true,
+    timeout: 5000 // Shorter timeout for testing
+  });
+  
+  try {
+    // Try to push a message - should failover to working server
+    log('Attempting to push message with one server down...');
+    const result = await client.push({
+      items: [{
+        queue: TEST_QUEUE,
+        partition: 'Failover',
+        payload: { test: 'failover', timestamp: Date.now() }
+      }]
+    });
+    
+    log('Message pushed successfully via failover!', 'success');
+    log(`Result: ${JSON.stringify(result)}`);
+    
+    // Get stats to see which server was used
+    const stats = client.getLoadBalancerStats();
+    log(`Load balancer stats after failover: ${JSON.stringify(stats, null, 2)}`);
+    
+  } catch (error) {
+    log(`Failover test failed: ${error.message}`, 'error');
+  }
+  
+  return client;
+}
+
+// Test WebSocket connections with multiple servers
+async function testWebSocketConnections() {
+  log('\nTesting WebSocket connections with multiple servers', 'info');
+  
+  const client = createQueenClient({
+    baseUrls: servers,
+    loadBalancingStrategy: LoadBalancingStrategy.ROUND_ROBIN
+  });
+  
+  // Create WebSocket connections to different servers
+  log('Creating WebSocket connections...');
+  
+  const ws1 = client.createWebSocketConnection('/ws/dashboard');
+  log(`WebSocket 1 connected to: ${ws1.serverUrl}`);
+  
+  const ws2 = client.createWebSocketConnection('/ws/dashboard');
+  log(`WebSocket 2 connected to: ${ws2.serverUrl}`);
+  
+  // Set up message handlers
+  ws1.onMessage((data) => {
+    log(`WS1 received: ${JSON.stringify(data)}`);
+  });
+  
+  ws2.onMessage((data) => {
+    log(`WS2 received: ${JSON.stringify(data)}`);
+  });
+  
+  // Keep connections open for a bit
+  await new Promise(resolve => setTimeout(resolve, 2000));
+  
+  // Close connections
+  ws1.close();
+  ws2.close();
+  log('WebSocket connections closed', 'success');
+  
+  return client;
+}
+
+// Test single server backward compatibility
+async function testBackwardCompatibility() {
+  log('\nTesting backward compatibility with single baseUrl', 'info');
+  
+  // Old style - single baseUrl
+  const client = createQueenClient({
+    baseUrl: 'http://localhost:6632',
+    timeout: 30000
+  });
+  
+  try {
+    const result = await client.push({
+      items: [{
+        queue: TEST_QUEUE,
+        partition: 'Compatibility',
+        payload: { test: 'backward-compatibility', timestamp: Date.now() }
+      }]
+    });
+    
+    log('Backward compatibility test passed!', 'success');
+    log(`Result: ${JSON.stringify(result)}`);
+    
+    // This should return null for single-server mode
+    const stats = client.getLoadBalancerStats();
+    log(`Load balancer stats (should be null): ${stats}`);
+    
+  } catch (error) {
+    log(`Backward compatibility test failed: ${error.message}`, 'error');
+  }
+  
+  return client;
+}
+
+// Main test runner
+async function runTests() {
+  console.log('=' .repeat(80));
+  console.log('Queen Multi-Server Load Balancing Test Suite');
+  console.log('=' .repeat(80));
+  
+  try {
+    // Test different strategies
+    await testRoundRobinStrategy();
+    await testSessionStrategy();
+    await testFailover();
+    await testWebSocketConnections();
+    await testBackwardCompatibility();
+    
+    console.log('\n' + '=' .repeat(80));
+    log('All tests completed!', 'success');
+    console.log('=' .repeat(80));
+    
+  } catch (error) {
+    log(`Test suite failed: ${error.message}`, 'error');
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// Run the tests
+runTests().catch(console.error);

package/examples/single.js

@@ -0,0 +1,64 @@
+import { createQueenClient } from '../src/client/index.js';
+
+const client = createQueenClient({
+    baseUrl: process.env.QUEEN_URL || 'http://localhost:6632',
+    timeout: 10000  // 10 second timeout for operations
+});
+
+// V2: Using queue and partition structure
+const queue = 'smartchat-agent';
+const partition = 'id-1';  // Can use partition to separate different agents
+
+async function consumer () {
+  // Start consuming messages from the specific partition
+  const stop = client.consume({
+    queue: queue,
+    partition: partition,  // Optional: remove to consume from any partition
+    handler: async (message) => {
+      console.log(`Consumed message from ${message.partition}: ${message.data.data}`);
+    },
+    options: {
+      wait: true,
+      timeout: 10000
+    }
+  });
+  
+  // Return stop function for cleanup if needed
+  return stop;
+}
+
+let count = 0;
+async function producer () {
+  const messages = [{
+    queue: queue,
+    partition: partition,  // Optional: defaults to "Default"
+    payload: {
+      id: count,
+      data: `Hello, world! ${count++}`,
+      timestamp: new Date().toISOString()
+    }
+  }];
+
+  const result = await client.push({
+    items: messages
+  });
+  console.log(`Pushed ${result.messages.length} messages to ${queue}/${partition}`);
+}
+
+// Start consumer
+consumer().then(stop => {
+  // Handle graceful shutdown
+  process.on('SIGINT', () => {
+    console.log('\nStopping consumer...');
+    stop();
+    process.exit(0);
+  });
+});
+
+// Start producer loop
+(async () => {
+  while (true) {
+    await producer();
+    await new Promise(resolve => setTimeout(resolve, 10000));
+  }
+})();

package/examples/smartchat-dealyed.js

@@ -0,0 +1,42 @@
+// Create client
+import fs from 'fs';
+import { createQueenClient } from '../src/client/index.js';
+
+const client = createQueenClient({
+    baseUrl: 'http://localhost:6632'
+});
+
+// Configure a queue with delayed processing
+await client.configure({
+    queue: 'htmls-delayed-02',
+    // partition parameter removed - all config is queue-level now
+    options: {
+      windowBuffer: 10,
+      //delayedProcessing: 10,  // Don't process messages until 60 seconds old
+      leaseTime: 300,
+      retryLimit: 3
+    }
+  })
+
+for (let i = 0; i < 10; i++) {
+await client.push({
+    items: [{
+        queue: 'htmls-delayed-02',
+        partition: 'html-02',  // Use 'Default' instead of 0
+        payload: { to: 'user-' + i + '@example.com' },
+    }]
+})
+}
+
+const stop = await client.consume({
+    queue: 'htmls-delayed-02',
+    partition: 'html-02',  // Use 'Default' instead of 0
+    handler: async (message) => {
+        console.log(message)
+    },
+    options: {
+        wait: true,
+        timeout: 30000,
+        batch: 5
+    }
+})

package/examples/smartchat.js

@@ -0,0 +1,52 @@
+// Create client
+import fs from 'fs';
+import { createQueenClient } from '../src/client/index.js';
+
+const client = createQueenClient({
+    baseUrl: 'http://localhost:6632'
+});
+
+const numberOfConsumers = 10
+
+async function producer () {
+    let count = 0;
+    while (true) {
+        const partition = count % 2;
+        console.log('Producing to partition:', partition);
+        const items = [];
+        for (let i = 0; i < 100; i++) {
+            items.push({ queue: 'htmls', partition: partition, payload: { to: 'user@example.com-' + count++ } });
+        }
+        await client.push({
+            items: items
+        })
+        await new Promise(resolve => setTimeout(resolve, 50));
+    }
+}
+
+async function consumer (i) {
+    const stop = client.consume({
+        queue: 'htmls',
+        consumerGroup: 'smartchat-' + i,
+        handler: async (message) => {
+          console.log(i, 'Processing:', message.data);
+          //fs.appendFileSync('consumed_items ' + message.partition + '.json', JSON.stringify(message.data) + '\n');
+        },
+        options: {
+            batch: 100,  // Process up to 10 messages at a time
+            wait: true,  // Wait for messages if queue is empty
+            timeout: 30000  // Timeout for long polling
+        }
+    });
+
+    return stop;
+}
+
+
+if (process.argv[2] === 'producer') {
+    producer(); 
+} else {
+    for (let i = 0; i < numberOfConsumers; i++) {
+        consumer(i);
+    }
+}

package/examples/test-cache-invalidation.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+/**
+ * Example: Cache Invalidation with System Events
+ * 
+ * This example demonstrates how the system event propagation
+ * ensures cache consistency across multiple server instances.
+ */
+
+import { createQueenClient } from '../src/client/queenClient.js';
+
+// Simulate two different server instances
+const server1 = createQueenClient({ baseUrl: 'http://localhost:6632' });
+const server2 = createQueenClient({ baseUrl: 'http://localhost:6633' }); // Would be a different port in production
+
+async function demonstrateCacheInvalidation() {
+  console.log('📊 Demonstrating Cache Invalidation with System Events\n');
+  console.log('=' .repeat(60));
+  
+  const queueName = 'cache-test-queue';
+  
+  try {
+    // Step 1: Server 1 creates a queue
+    console.log('\n1️⃣ Server 1 creates a queue with initial configuration:');
+    await server1.configure({
+      queue: queueName,
+      options: {
+        ttl: 300,
+        retryLimit: 3,
+        priority: 5
+      }
+    });
+    console.log('   ✅ Queue created with TTL=300, retryLimit=3, priority=5');
+    
+    // Step 2: Both servers use the queue
+    console.log('\n2️⃣ Both servers push messages to the queue:');
+    
+    await server1.push({
+      queue: queueName,
+      messages: [{ id: 'msg-from-server1', payload: { source: 'server1' } }]
+    });
+    console.log('   ✅ Server 1 pushed a message (uses cached config)');
+    
+    // In a real multi-server setup, server2 would have its own cache
+    // For this demo, we're using the same server but the principle applies
+    await server2.push({
+      queue: queueName,
+      messages: [{ id: 'msg-from-server2', payload: { source: 'server2' } }]
+    });
+    console.log('   ✅ Server 2 pushed a message (fetches and caches config)');
+    
+    // Step 3: Server 1 updates the queue configuration
+    console.log('\n3️⃣ Server 1 updates queue configuration:');
+    await server1.configure({
+      queue: queueName,
+      options: {
+        ttl: 600,      // Changed from 300
+        retryLimit: 5, // Changed from 3
+        priority: 10   // Changed from 5
+      }
+    });
+    console.log('   ✅ Configuration updated: TTL=600, retryLimit=5, priority=10');
+    console.log('   📨 System event emitted to propagate changes');
+    
+    // Step 4: Wait a moment for event propagation
+    console.log('\n4️⃣ Waiting for system event propagation...');
+    await new Promise(resolve => setTimeout(resolve, 100));
+    
+    // Step 5: Both servers use the queue again
+    console.log('\n5️⃣ Both servers push messages again:');
+    
+    await server1.push({
+      queue: queueName,
+      messages: [{ id: 'msg2-from-server1', payload: { after: 'update' } }]
+    });
+    console.log('   ✅ Server 1 uses new config (immediate local update)');
+    
+    await server2.push({
+      queue: queueName,
+      messages: [{ id: 'msg2-from-server2', payload: { after: 'update' } }]
+    });
+    console.log('   ✅ Server 2 uses new config (cache invalidated by event)');
+    
+    // Step 6: Verify the queue stats
+    console.log('\n6️⃣ Verifying queue statistics:');
+    const stats = await server1.getQueueStats(queueName);
+    console.log(`   📊 Total messages: ${stats.total}`);
+    console.log(`   📊 Pending: ${stats.pending}`);
+    
+    // Step 7: Check system events queue
+    console.log('\n7️⃣ Checking system events queue:');
+    try {
+      const systemStats = await server1.getQueueStats('__system_events__');
+      console.log(`   📊 System events processed: ${systemStats.completed || 0}`);
+      console.log(`   📊 System events pending: ${systemStats.pending || 0}`);
+    } catch (error) {
+      console.log('   ℹ️ System queue may not have stats if events were already consumed');
+    }
+    
+    console.log('\n' + '=' .repeat(60));
+    console.log('✨ Cache invalidation demonstration completed!');
+    console.log('\n💡 Key Points:');
+    console.log('   • Configuration changes trigger system events');
+    console.log('   • Events are propagated to all server instances');
+    console.log('   • Each server invalidates its cache upon receiving events');
+    console.log('   • This ensures consistency across the cluster');
+    
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    process.exit(1);
+  }
+}
+
+// Run the demonstration
+demonstrateCacheInvalidation().then(() => {
+  process.exit(0);
+}).catch(error => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});