queen-mq 0.6.3 → 0.7.4

package/client-js/benchmark/producer.js

@@ -1,80 +0,0 @@
-import { Queen } from '../client/client.js'; 
-import fs from 'fs';
-
-const TOTAL_MESSAGES = 1000000;
-const PARTITIONS = 10; 
-const MAX_BATCH_SIZE = 100;  // Reduced from 10000
-const PUSH_PARALLEL = 10;      // Reduced from 10 to avoid lock contention
-const QUEUE_NAME = 'benchmark-queue-001';
-
-const q = new Queen({
-  baseUrls: ['http://localhost:6632'],
-  timeout: 120000
-});
-
-
-try {
-  await q.queueDelete(QUEUE_NAME);
-  await q.queue(QUEUE_NAME, {
-  leaseTime: 10,
-  retryLimit: 3
-}, { namespace: 'benchmark' });
-} catch (e) {
-  console.error(e);
-}
-
-
-
-let batches = []
-const messagesPerPartition = Math.floor(TOTAL_MESSAGES / PARTITIONS);
-
-// Create batches for each partition
-const partitionBatches = [];
-for (let i = 0; i < PARTITIONS; i++) {
-  partitionBatches[i] = [];
-  let messages = [];
-  for (let j = 0; j < messagesPerPartition; j++) {
-    messages.push({
-      id: j,
-      //message: `Message ${globalMessageId}`,
-      //timestamp: new Date().toISOString()
-    });
-    if (messages.length >= MAX_BATCH_SIZE) {
-      console.log(`Pushing ${messages.length} messages for partition ${i}`);
-      partitionBatches[i].push({
-        partition: i,
-        messages: messages
-      });
-      messages = [];
-    }
-  }
-  // Only add the remaining batch if it has messages
-  if (messages.length > 0) {
-    console.log(`Pushing ${messages.length} messages for partition ${i}`);
-    partitionBatches[i].push({
-      partition: i,
-      messages: messages
-    });
-  }
-}
-
-// Interleave batches from different partitions to avoid lock contention
-// This ensures parallel pushes go to different partitions
-const maxBatchesPerPartition = Math.max(...partitionBatches.map(pb => pb.length));
-for (let batchIndex = 0; batchIndex < maxBatchesPerPartition; batchIndex++) {
-  for (let partition = 0; partition < PARTITIONS; partition++) {
-    if (partitionBatches[partition][batchIndex]) {
-      batches.push(partitionBatches[partition][batchIndex]);
-    }
-  }
-}
-
-const start = Date.now();
-console.log(`Total batches: ${batches.length}, pushing ${PUSH_PARALLEL} at a time`);
-for (let i = 0; i < batches.length; i += PUSH_PARALLEL) {
-  const batchGroup = batches.slice(i, i + PUSH_PARALLEL);
-  console.log(`Pushing batch group ${Math.floor(i/PUSH_PARALLEL) + 1}/${Math.ceil(batches.length/PUSH_PARALLEL)}: ${batchGroup.map(b => `partition ${b.partition} (${b.messages.length} msgs)`).join(', ')}`);
-  await Promise.all(batchGroup.map(batch => q.push(`${QUEUE_NAME}/${batch.partition}`, batch.messages)));
-}
-const end = Date.now();
-console.log(`Pushed ${TOTAL_MESSAGES} messages in ${(end - start) / 1000}s, ${(TOTAL_MESSAGES / ((end - start) / 1000)).toFixed(2)} msg/s`);

package/client-js/benchmark/producer_multi.js

@@ -1,115 +0,0 @@
-import { Queen } from '../client/client.js'; 
-import fs from 'fs';
-
-const TOTAL_MESSAGES = 100000;
-const NUM_QUEUES = 50;          // X: Number of queues
-const PARTITIONS_PER_QUEUE = 10; // Y: Partitions per queue
-const MAX_BATCH_SIZE = 10;  
-const PUSH_PARALLEL = 10;      
-
-const q = new Queen({
-  baseUrls: ['http://localhost:6632'],
-  timeout: 120000
-});
-
-// Create X queues, each with Y partitions, all in 'benchmark' namespace
-console.log(`Creating ${NUM_QUEUES} queues with ${PARTITIONS_PER_QUEUE} partitions each...`);
-for (let queueIdx = 0; queueIdx < NUM_QUEUES; queueIdx++) {
-  const queueName = `benchmark-queue-${String(queueIdx + 1).padStart(2, '0')}`;
-  try {
-    //await q.queueDelete(queueName);
-  } catch (e) {
-    // Queue might not exist
-  }
-  await q.queue(queueName, {
-    leaseTime: 10,
-    retryLimit: 3
-  }, { namespace: 'benchmark' });
-  console.log(`  Created queue: ${queueName}`);
-}
-
-
-// Calculate total partitions across all queues
-const TOTAL_PARTITIONS = NUM_QUEUES * PARTITIONS_PER_QUEUE;
-const messagesPerPartition = Math.floor(TOTAL_MESSAGES / TOTAL_PARTITIONS);
-
-console.log(`\nDistributing ${TOTAL_MESSAGES} messages across ${NUM_QUEUES} queues × ${PARTITIONS_PER_QUEUE} partitions = ${TOTAL_PARTITIONS} total partitions`);
-console.log(`Messages per partition: ${messagesPerPartition}\n`);
-
-// Create batches for each queue/partition combination
-const queuePartitionBatches = [];
-for (let queueIdx = 0; queueIdx < NUM_QUEUES; queueIdx++) {
-  for (let partitionIdx = 0; partitionIdx < PARTITIONS_PER_QUEUE; partitionIdx++) {
-    const key = `q${queueIdx}_p${partitionIdx}`;
-    queuePartitionBatches.push({ queueIdx, partitionIdx, batches: [] });
-    
-    let messages = [];
-    for (let msgIdx = 0; msgIdx < messagesPerPartition; msgIdx++) {
-      messages.push({
-        id: msgIdx,
-        queue: queueIdx,
-        partition: partitionIdx
-      });
-      
-      if (messages.length >= MAX_BATCH_SIZE) {
-        queuePartitionBatches[queuePartitionBatches.length - 1].batches.push([...messages]);
-        messages = [];
-      }
-    }
-    
-    // Add remaining messages
-    if (messages.length > 0) {
-      queuePartitionBatches[queuePartitionBatches.length - 1].batches.push([...messages]);
-    }
-  }
-}
-
-// Flatten and interleave batches to distribute load evenly
-let batches = [];
-const maxBatchesPerQueuePartition = Math.max(...queuePartitionBatches.map(qp => qp.batches.length));
-for (let batchIdx = 0; batchIdx < maxBatchesPerQueuePartition; batchIdx++) {
-  for (const qp of queuePartitionBatches) {
-    if (qp.batches[batchIdx]) {
-      batches.push({
-        queueIdx: qp.queueIdx,
-        partitionIdx: qp.partitionIdx,
-        messages: qp.batches[batchIdx]
-      });
-    }
-  }
-}
-
-const start = Date.now();
-console.log(`Total batches: ${batches.length}, pushing ${PUSH_PARALLEL} at a time\n`);
-
-for (let i = 0; i < batches.length; i += PUSH_PARALLEL) {
-  const batchGroup = batches.slice(i, i + PUSH_PARALLEL);
-  const batchGroupNum = Math.floor(i/PUSH_PARALLEL) + 1;
-  const totalBatchGroups = Math.ceil(batches.length/PUSH_PARALLEL);
-  
-  console.log(`[${batchGroupNum}/${totalBatchGroups}] Pushing: ${batchGroup.map(b => {
-    const queueName = `benchmark-queue-${String(b.queueIdx + 1).padStart(2, '0')}`;
-    return `${queueName}/p${b.partitionIdx} (${b.messages.length} msgs)`;
-  }).join(', ')}`);
-  
-  await Promise.all(batchGroup.map(batch => {
-    const queueName = `benchmark-queue-${String(batch.queueIdx + 1).padStart(2, '0')}`;
-    return q.push(`${queueName}/${batch.partitionIdx}`, batch.messages);
-  }));
-}
-
-const end = Date.now();
-const duration = (end - start) / 1000;
-const throughput = (TOTAL_MESSAGES / duration).toFixed(2);
-
-console.log('\n' + '='.repeat(80));
-console.log('📤 PRODUCER RESULTS');
-console.log('='.repeat(80));
-console.log(`Total Messages Pushed: ${TOTAL_MESSAGES.toLocaleString()}`);
-console.log(`Queues: ${NUM_QUEUES}`);
-console.log(`Partitions per Queue: ${PARTITIONS_PER_QUEUE}`);
-console.log(`Total Partitions: ${TOTAL_PARTITIONS}`);
-console.log(`Duration: ${duration.toFixed(2)}s`);
-console.log(`Throughput: ${throughput} msg/s`);
-console.log('='.repeat(80));
-

package/client-js/client-v2/http/LoadBalancer.js

@@ -1,50 +0,0 @@
-/**
- * Load balancer for distributing requests across multiple servers
- */
-
-export class LoadBalancer {
-  #urls
-  #strategy
-  #currentIndex = 0
-  #sessionMap = new Map()
-  #sessionId
-
-  constructor(urls, strategy = 'round-robin') {
-    this.#urls = urls.map(url => url.replace(/\/$/, '')) // Remove trailing slashes
-    this.#strategy = strategy
-    this.#sessionId = `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
-  }
-
-  getNextUrl(sessionKey = null) {
-    const key = sessionKey || this.#sessionId
-
-    if (this.#strategy === 'session') {
-      // Session affinity: stick to the same server per session
-      if (!this.#sessionMap.has(key)) {
-        const assignedIndex = this.#currentIndex
-        this.#sessionMap.set(key, assignedIndex)
-        this.#currentIndex = (this.#currentIndex + 1) % this.#urls.length
-      }
-      return this.#urls[this.#sessionMap.get(key)]
-    }
-
-    // Round robin: cycle through URLs
-    const url = this.#urls[this.#currentIndex]
-    this.#currentIndex = (this.#currentIndex + 1) % this.#urls.length
-    return url
-  }
-
-  getAllUrls() {
-    return [...this.#urls]
-  }
-
-  getStrategy() {
-    return this.#strategy
-  }
-
-  reset() {
-    this.#currentIndex = 0
-    this.#sessionMap.clear()
-  }
-}
-