@joystick.js/db-canary 0.0.0-canary.2275 → 0.0.0-canary.2276

package/src/server/lib/sync_receiver.js

@@ -0,0 +1,461 @@
+/**
+ * @fileoverview Sync receiver for secondary nodes in JoystickDB.
+ * Receives and processes sync messages from primary nodes with API_KEY authentication.
+ * Secondary nodes are read-only except for authenticated sync operations.
+ */
+
+import net from 'net';
+import fs from 'fs/promises';
+import { get_settings } from './load_settings.js';
+import { create_message_parser, encode_message } from './tcp_protocol.js';
+import create_logger from './logger.js';
+import insert_one from './operations/insert_one.js';
+import update_one from './operations/update_one.js';
+import delete_one from './operations/delete_one.js';
+import delete_many from './operations/delete_many.js';
+import bulk_write from './operations/bulk_write.js';
+import create_index_operation from './operations/create_index.js';
+import drop_index_operation from './operations/drop_index.js';
+
+const { create_context_logger } = create_logger('sync_receiver');
+
+/**
+ * Sync receiver that processes authenticated sync messages from primary nodes.
+ * Validates API_KEY and applies operations to local database.
+ */
+class SyncReceiver {
+  /**
+   * Creates a new SyncReceiver instance.
+   */
+  constructor() {
+    /** @type {boolean} Whether this node is configured as secondary */
+    this.is_secondary = false;
+    
+    /** @type {string|null} API_KEY loaded from file for authentication */
+    this.api_key = null;
+    
+    /** @type {string|null} Path to API_KEY file */
+    this.api_key_file_path = null;
+    
+    /** @type {net.Server|null} TCP server for receiving sync messages */
+    this.server = null;
+    
+    /** @type {number} TCP port for sync operations */
+    this.sync_port = 1985;
+    
+    /** @type {Object} Logger instance */
+    this.log = create_context_logger();
+    
+    /** @type {Object} Sync statistics */
+    this.stats = {
+      total_received: 0,
+      successful_syncs: 0,
+      failed_syncs: 0,
+      auth_failures: 0,
+      operations_applied: 0
+    };
+  }
+
+  /**
+   * Initializes the sync receiver with settings configuration.
+   */
+  async initialize() {
+    try {
+      const settings = get_settings();
+      
+      if (settings.primary === true) {
+        this.log.info('Node configured as primary - sync receiver disabled');
+        return;
+      }
+      
+      if (settings.primary === false) {
+        this.is_secondary = true;
+        this.api_key_file_path = settings.secondary_sync_key;
+        this.sync_port = settings.sync_port || 1985;
+        
+        if (!this.api_key_file_path) {
+          this.log.error('Secondary node missing secondary_sync_key configuration');
+          return;
+        }
+        
+        await this.load_api_key();
+        
+        if (!this.api_key) {
+          this.log.error('Failed to load API_KEY - sync receiver disabled');
+          return;
+        }
+        
+        this.log.info('Initializing sync receiver for secondary node', {
+          api_key_file: this.api_key_file_path,
+          sync_port: this.sync_port
+        });
+        
+        this.start_server();
+      }
+      
+    } catch (error) {
+      this.log.warn('Could not initialize sync receiver - settings not loaded', {
+        error: error.message
+      });
+    }
+  }
+
+  /**
+   * Loads API_KEY from configured file path.
+   */
+  async load_api_key() {
+    try {
+      const key_content = await fs.readFile(this.api_key_file_path, 'utf8');
+      this.api_key = key_content.trim();
+      
+      this.log.info('API_KEY loaded successfully', {
+        file_path: this.api_key_file_path,
+        key_length: this.api_key.length
+      });
+      
+    } catch (error) {
+      this.log.error('Failed to load API_KEY from file', {
+        file_path: this.api_key_file_path,
+        error: error.message
+      });
+    }
+  }
+
+  /**
+   * Starts the TCP server to receive sync messages.
+   */
+  start_server() {
+    try {
+      this.server = net.createServer((socket) => {
+        this.log.debug('Sync connection established', {
+          remote_address: socket.remoteAddress,
+          remote_port: socket.remotePort
+        });
+        
+        const message_parser = create_message_parser();
+        
+        socket.on('data', (data) => {
+          try {
+            const messages = message_parser.parse_messages(data);
+            for (const message of messages) {
+              this.handle_sync_message(socket, message).catch((error) => {
+                this.log.error('Failed to handle sync message', {
+                  error: error.message,
+                  remote_address: socket.remoteAddress
+                });
+              });
+            }
+          } catch (error) {
+            this.log.error('Failed to parse sync message', {
+              error: error.message,
+              remote_address: socket.remoteAddress
+            });
+          }
+        });
+        
+        socket.on('error', (error) => {
+          this.log.error('Sync connection error', {
+            error: error.message,
+            remote_address: socket.remoteAddress
+          });
+        });
+        
+        socket.on('close', () => {
+          this.log.debug('Sync connection closed', {
+            remote_address: socket.remoteAddress
+          });
+        });
+      });
+      
+      this.server.listen(this.sync_port, () => {
+        this.log.info('Sync receiver server started', {
+          port: this.sync_port
+        });
+      });
+      
+      this.server.on('error', (error) => {
+        this.log.error('Sync receiver server error', {
+          error: error.message,
+          port: this.sync_port
+        });
+      });
+    } catch (error) {
+      this.log.error('Failed to start sync receiver server', {
+        error: error.message,
+        port: this.sync_port
+      });
+    }
+  }
+
+  /**
+   * Handles incoming sync message from primary node.
+   * @param {net.Socket} socket - Connection socket
+   * @param {Object|string} raw_message - Raw sync message
+   */
+  async handle_sync_message(socket, raw_message) {
+    this.stats.total_received++;
+    
+    let message;
+    try {
+      message = typeof raw_message === 'string' ? JSON.parse(raw_message) : raw_message;
+    } catch (error) {
+      this.send_sync_response(socket, null, 'error', 'Invalid JSON message');
+      return;
+    }
+    
+    const { type, api_key, sequence, operation, collection, data } = message;
+    
+    if (type !== 'operation_sync') {
+      this.send_sync_response(socket, sequence, 'error', 'Invalid message type');
+      return;
+    }
+    
+    // Validate API_KEY
+    if (!this.validate_api_key(api_key)) {
+      this.stats.auth_failures++;
+      this.log.error('Sync authentication failed', {
+        sequence,
+        operation,
+        remote_address: socket.remoteAddress
+      });
+      this.send_sync_response(socket, sequence, 'auth_failed', 'Invalid API_KEY');
+      return;
+    }
+    
+    // Apply operation to local database
+    try {
+      await this.apply_sync_operation(operation, collection, data);
+      this.stats.successful_syncs++;
+      this.stats.operations_applied++;
+      
+      this.log.debug('Sync operation applied successfully', {
+        sequence,
+        operation,
+        collection
+      });
+      
+      this.send_sync_response(socket, sequence, 'success', null);
+      
+    } catch (error) {
+      this.stats.failed_syncs++;
+      
+      this.log.error('Failed to apply sync operation', {
+        sequence,
+        operation,
+        collection,
+        error: error.message
+      });
+      
+      this.send_sync_response(socket, sequence, 'error', error.message);
+    }
+  }
+
+  /**
+   * Validates API_KEY from sync message.
+   * @param {string} provided_key - API_KEY from sync message
+   * @returns {boolean} True if key is valid
+   */
+  validate_api_key(provided_key) {
+    if (!provided_key || !this.api_key) {
+      return false;
+    }
+    
+    return provided_key === this.api_key;
+  }
+
+  /**
+   * Applies sync operation to local database.
+   * @param {string} operation - Operation type
+   * @param {string} collection - Collection name
+   * @param {Object} data - Operation data
+   */
+  async apply_sync_operation(operation, collection, data) {
+    const database_name = data.database || 'default';
+    
+    switch (operation) {
+      case 'insert_one':
+        return await insert_one(database_name, collection, data.document, data.options);
+        
+      case 'update_one':
+        return await update_one(database_name, collection, data.filter, data.update, data.options);
+        
+      case 'delete_one':
+        return await delete_one(database_name, collection, data.filter, data.options);
+        
+      case 'delete_many':
+        return await delete_many(database_name, collection, data.filter, data.options);
+        
+      case 'bulk_write':
+        return await bulk_write(database_name, collection, data.operations, data.options);
+        
+      case 'create_index':
+        return await create_index_operation(database_name, collection, data.field, data.options);
+        
+      case 'drop_index':
+        return await drop_index_operation(database_name, collection, data.field);
+        
+      default:
+        throw new Error(`Unsupported sync operation: ${operation}`);
+    }
+  }
+
+  /**
+   * Sends sync response back to primary node.
+   * @param {net.Socket} socket - Connection socket
+   * @param {number|null} sequence - Sequence number
+   * @param {string} status - Response status
+   * @param {string|null} error - Error message if any
+   */
+  send_sync_response(socket, sequence, status, error) {
+    const response = {
+      type: 'sync_acknowledged',
+      sequence,
+      status,
+      timestamp: Date.now()
+    };
+    
+    if (error) {
+      response.error = error;
+    }
+    
+    try {
+      const encoded_response = encode_message(response);
+      socket.write(encoded_response);
+    } catch (write_error) {
+      this.log.error('Failed to send sync response', {
+        sequence,
+        status,
+        error: write_error.message
+      });
+    }
+  }
+
+  /**
+   * Checks if a client operation should be blocked on secondary.
+   * @param {string} operation_type - Type of operation
+   * @returns {boolean} True if operation should be blocked
+   */
+  should_block_client_operation(operation_type) {
+    if (!this.is_secondary) {
+      return false;
+    }
+    
+    // Allow read operations on secondary
+    const read_operations = ['find', 'find_one', 'count_documents', 'get_indexes'];
+    
+    if (read_operations.includes(operation_type)) {
+      return false;
+    }
+    
+    // Block all write operations for direct clients
+    return true;
+  }
+
+  /**
+   * Gets current sync receiver status and statistics.
+   * @returns {Object} Sync receiver status
+   */
+  get_sync_status() {
+    return {
+      is_secondary: this.is_secondary,
+      api_key_loaded: !!this.api_key,
+      api_key_file: this.api_key_file_path,
+      server_running: !!this.server && this.server.listening,
+      sync_port: this.sync_port,
+      stats: this.stats
+    };
+  }
+
+  /**
+   * Reloads API_KEY from file (for key rotation).
+   */
+  async reload_api_key() {
+    if (!this.api_key_file_path) {
+      throw new Error('No API_KEY file path configured');
+    }
+    
+    const old_key_length = this.api_key ? this.api_key.length : 0;
+    await this.load_api_key();
+    
+    this.log.info('API_KEY reloaded', {
+      old_key_length,
+      new_key_length: this.api_key ? this.api_key.length : 0
+    });
+  }
+
+  /**
+   * Promotes secondary to primary (manual failover support).
+   */
+  promote_to_primary() {
+    if (!this.is_secondary) {
+      throw new Error('Node is not configured as secondary');
+    }
+    
+    this.log.info('Promoting secondary to primary');
+    
+    // Stop sync receiver server
+    if (this.server) {
+      this.server.close(() => {
+        this.log.info('Sync receiver server stopped for primary promotion');
+      });
+      this.server = null;
+    }
+    
+    this.is_secondary = false;
+    
+    this.log.info('Node promoted to primary - sync receiver disabled');
+  }
+
+  /**
+   * Shuts down the sync receiver and closes server.
+   * @returns {Promise<void>}
+   */
+  async shutdown() {
+    this.log.info('Shutting down sync receiver');
+    
+    if (this.server) {
+      return new Promise((resolve) => {
+        this.server.close(() => {
+          this.log.info('Sync receiver server closed');
+          resolve();
+        });
+      });
+    }
+    
+    this.log.info('Sync receiver shutdown complete');
+  }
+}
+
+/** @type {SyncReceiver|null} Singleton instance */
+let sync_receiver_instance = null;
+
+/**
+ * Gets the sync receiver singleton instance.
+ * @returns {SyncReceiver} Sync receiver instance
+ */
+export const get_sync_receiver = () => {
+  if (!sync_receiver_instance) {
+    sync_receiver_instance = new SyncReceiver();
+  }
+  return sync_receiver_instance;
+};
+
+/**
+ * Initializes the sync receiver singleton.
+ * @returns {Promise<void>}
+ */
+export const initialize_sync_receiver = async () => {
+  const receiver = get_sync_receiver();
+  await receiver.initialize();
+};
+
+/**
+ * Shuts down the sync receiver singleton.
+ * @returns {Promise<void>}
+ */
+export const shutdown_sync_receiver = async () => {
+  if (sync_receiver_instance) {
+    await sync_receiver_instance.shutdown();
+    sync_receiver_instance = null;
+  }
+};

package/tests/server/lib/simple_sync_system.test.js

@@ -0,0 +1,124 @@
+/**
+ * @fileoverview Basic tests for the simplified primary/secondary sync system.
+ * Tests API_KEY authentication, sync operations, and basic functionality.
+ */
+
+import test from 'ava';
+import { get_simple_sync_manager } from '../../../src/server/lib/simple_sync_manager.js';
+import { get_sync_receiver } from '../../../src/server/lib/sync_receiver.js';
+
+test('simple sync manager should initialize correctly', t => {
+  const sync_manager = get_simple_sync_manager();
+  
+  t.truthy(sync_manager);
+  t.is(typeof sync_manager.initialize, 'function');
+  t.is(typeof sync_manager.queue_sync, 'function');
+  t.is(typeof sync_manager.get_sync_status, 'function');
+  t.is(typeof sync_manager.shutdown, 'function');
+});
+
+test('sync receiver should initialize correctly', t => {
+  const sync_receiver = get_sync_receiver();
+  
+  t.truthy(sync_receiver);
+  t.is(typeof sync_receiver.initialize, 'function');
+  t.is(typeof sync_receiver.should_block_client_operation, 'function');
+  t.is(typeof sync_receiver.get_sync_status, 'function');
+  t.is(typeof sync_receiver.shutdown, 'function');
+});
+
+test('sync receiver should block write operations on secondary nodes', t => {
+  const sync_receiver = get_sync_receiver();
+  
+  // Mock secondary mode
+  sync_receiver.is_secondary = true;
+  
+  // Should block write operations
+  t.true(sync_receiver.should_block_client_operation('insert_one'));
+  t.true(sync_receiver.should_block_client_operation('update_one'));
+  t.true(sync_receiver.should_block_client_operation('delete_one'));
+  t.true(sync_receiver.should_block_client_operation('bulk_write'));
+  
+  // Should allow read operations
+  t.false(sync_receiver.should_block_client_operation('find'));
+  t.false(sync_receiver.should_block_client_operation('find_one'));
+  t.false(sync_receiver.should_block_client_operation('count_documents'));
+  t.false(sync_receiver.should_block_client_operation('get_indexes'));
+  
+  // Reset
+  sync_receiver.is_secondary = false;
+});
+
+test('sync receiver should not block operations on primary nodes', t => {
+  const sync_receiver = get_sync_receiver();
+  
+  // Mock primary mode (default)
+  sync_receiver.is_secondary = false;
+  
+  // Should not block any operations on primary
+  t.false(sync_receiver.should_block_client_operation('insert_one'));
+  t.false(sync_receiver.should_block_client_operation('update_one'));
+  t.false(sync_receiver.should_block_client_operation('find'));
+  t.false(sync_receiver.should_block_client_operation('find_one'));
+});
+
+test('simple sync manager should provide status information', t => {
+  const sync_manager = get_simple_sync_manager();
+  const status = sync_manager.get_sync_status();
+  
+  t.is(typeof status, 'object');
+  t.is(typeof status.is_primary, 'boolean');
+  t.is(typeof status.secondary_count, 'number');
+  t.is(typeof status.stats, 'object');
+  t.is(typeof status.secondaries, 'object');
+});
+
+test('sync receiver should provide status information', t => {
+  const sync_receiver = get_sync_receiver();
+  const status = sync_receiver.get_sync_status();
+  
+  t.is(typeof status, 'object');
+  t.is(typeof status.is_secondary, 'boolean');
+  t.is(typeof status.api_key_loaded, 'boolean');
+  t.is(typeof status.server_running, 'boolean');
+  t.is(typeof status.sync_port, 'number');
+  t.is(typeof status.stats, 'object');
+});
+
+test('sync manager should handle empty secondary nodes list', t => {
+  const sync_manager = get_simple_sync_manager();
+  
+  // Should not throw when updating with empty list
+  t.notThrows(() => {
+    sync_manager.update_secondary_nodes([]);
+  });
+});
+
+test('sync receiver should handle manual promotion to primary', t => {
+  const sync_receiver = get_sync_receiver();
+  
+  // Mock secondary mode
+  sync_receiver.is_secondary = true;
+  sync_receiver.server = { close: () => {} }; // Mock server
+  
+  // Should be able to promote to primary
+  t.notThrows(() => {
+    sync_receiver.promote_to_primary();
+  });
+  
+  // Should now be in primary mode
+  t.false(sync_receiver.is_secondary);
+});
+
+test.after.always(async t => {
+  // Clean up any resources
+  try {
+    const sync_manager = get_simple_sync_manager();
+    const sync_receiver = get_sync_receiver();
+    
+    await sync_manager.shutdown();
+    await sync_receiver.shutdown();
+  } catch (error) {
+    // Ignore cleanup errors in tests
+  }
+});

package/dist/server/lib/replication_manager.js

@@ -1 +0,0 @@
-import p from"net";import u from"crypto";import{get_settings as g}from"./load_settings.js";import{encode_message as d,create_message_parser as m}from"./tcp_protocol.js";import y from"./logger.js";const{create_context_logger:f}=y("replication");class w{constructor(){this.secondary_connections=new Map,this.replication_queue=[],this.processing_replication=!1,this.sequence_number=0,this.enabled=!1,this.mode="async",this.timeout_ms=5e3,this.retry_attempts=3,this.batch_size=100,this.log=f(),this.stats={total_operations_replicated:0,successful_replications:0,failed_replications:0,connected_secondaries:0,avg_replication_latency_ms:0,total_replication_time_ms:0}}initialize(){try{const e=g().replication;if(!e||!e.enabled){this.log.info("Replication disabled in settings");return}this.enabled=e.enabled,this.mode=e.mode||"async",this.timeout_ms=e.timeout_ms||5e3,this.retry_attempts=e.retry_attempts||3,this.batch_size=e.batch_size||100;const n=e.secondaries||[];this.log.info("Initializing replication manager",{enabled:this.enabled,mode:this.mode,secondary_count:n.length,timeout_ms:this.timeout_ms,batch_size:this.batch_size});for(const s of n)s.enabled&&this.connect_to_secondary(s);this.start_replication_processing()}catch(t){this.log.warn("Could not initialize replication - settings not loaded",{error:t.message})}}async connect_to_secondary(t){const{id:e,ip:n,port:s,private_key:i}=t;this.log.info("Connecting to secondary node",{id:e,ip:n,port:s});try{const o=new p.Socket,l=m();o.connect(s,n,()=>{this.log.info("Connected to secondary node",{id:e,ip:n,port:s}),this.authenticate_with_secondary(o,e,i)}),o.on("data",a=>{try{const c=l.parse_messages(a);for(const _ of c)this.handle_secondary_response(e,_)}catch(c){this.log.error("Failed to parse secondary response",{secondary_id:e,error:c.message})}}),o.on("error",a=>{this.log.error("Secondary connection error",{secondary_id:e,error:a.message}),this.secondary_connections.delete(e),this.stats.connected_secondaries=this.secondary_connections.size,setTimeout(()=>{this.connect_to_secondary(t)},5e3)}),o.on("close",()=>{this.log.warn("Secondary connection closed",{secondary_id:e}),this.secondary_connections.delete(e),this.stats.connected_secondaries=this.secondary_connections.size,setTimeout(()=>{this.connect_to_secondary(t)},5e3)}),this.secondary_connections.set(e,{socket:o,id:e,ip:n,port:s,authenticated:!1,last_ping:Date.now(),pending_operations:new Map}),this.stats.connected_secondaries=this.secondary_connections.size}catch(o){this.log.error("Failed to connect to secondary",{secondary_id:e,ip:n,port:s,error:o.message})}}authenticate_with_secondary(t,e,n){try{const s=Date.now(),i=`${e}:${s}`,o=u.createHmac("sha256",Buffer.from(n,"base64")).update(i).digest("base64"),a=d({type:"replication_auth",node_id:e,timestamp:s,signature:o});t.write(a),this.log.debug("Sent authentication to secondary",{secondary_id:e})}catch(s){this.log.error("Failed to authenticate with secondary",{secondary_id:e,error:s.message})}}handle_secondary_response(t,e){const n=this.secondary_connections.get(t);if(n)try{const s=typeof e=="string"?JSON.parse(e):e;switch(s.type){case"auth_success":n.authenticated=!0,this.log.info("Secondary authentication successful",{secondary_id:t});break;case"auth_failed":this.log.error("Secondary authentication failed",{secondary_id:t}),n.socket.end();break;case"replication_ack":this.handle_replication_acknowledgment(t,s);break;case"ping_response":n.last_ping=Date.now();break;default:this.log.debug("Unknown message from secondary",{secondary_id:t,type:s.type})}}catch(s){this.log.error("Failed to handle secondary response",{secondary_id:t,error:s.message})}}handle_replication_acknowledgment(t,e){const n=this.secondary_connections.get(t);if(!n)return;const{sequence_number:s,status:i,error:o}=e,l=n.pending_operations.get(s);if(l){const a=Date.now()-l.sent_at;this.stats.total_replication_time_ms+=a,i==="success"?(this.stats.successful_replications++,this.log.debug("Replication acknowledged",{secondary_id:t,sequence_number:s,latency_ms:a})):(this.stats.failed_replications++,this.log.error("Replication failed on secondary",{secondary_id:t,sequence_number:s,error:o,latency_ms:a})),n.pending_operations.delete(s);const c=this.stats.successful_replications+this.stats.failed_replications;this.stats.avg_replication_latency_ms=c>0?Math.round(this.stats.total_replication_time_ms/c):0}}queue_replication(t,e,n,s=null){if(!this.enabled||this.secondary_connections.size===0)return;const i={operation:t,collection:e,data:n,transaction_id:s,timestamp:Date.now(),sequence_number:++this.sequence_number};this.replication_queue.push(i),this.stats.total_operations_replicated++,this.log.debug("Queued operation for replication",{operation:t,collection:e,sequence_number:i.sequence_number,queue_length:this.replication_queue.length}),this.processing_replication||setImmediate(()=>this.process_replication_queue())}start_replication_processing(){this.processing_replication||(this.processing_replication=!0,this.process_replication_queue())}async process_replication_queue(){for(;this.replication_queue.length>0&&this.enabled;){const t=this.replication_queue.splice(0,this.batch_size);if(t.length===0)break;await this.replicate_batch(t),this.replication_queue.length>0&&await new Promise(e=>setTimeout(e,10))}this.replication_queue.length>0&&setImmediate(()=>this.process_replication_queue())}async replicate_batch(t){const e={type:"replication",timestamp:Date.now(),sequence_number:t[0].sequence_number,operations:t},n=d(e),s=Array.from(this.secondary_connections.values()).filter(i=>i.authenticated);if(s.length===0){this.log.warn("No authenticated secondaries available for replication");return}this.log.debug("Replicating batch to secondaries",{batch_size:t.length,secondary_count:s.length,sequence_number:t[0].sequence_number});for(const i of s)try{i.socket.write(n);for(const o of t)i.pending_operations.set(o.sequence_number,{operation:o,sent_at:Date.now()})}catch(o){this.log.error("Failed to send replication to secondary",{secondary_id:i.id,error:o.message})}}async add_secondary(t){const{id:e}=t;if(this.secondary_connections.has(e))throw new Error(`Secondary node ${e} already exists`);return this.log.info("Adding new secondary node",{id:e}),await this.connect_to_secondary(t),{success:!0,message:`Secondary node ${e} added successfully`,secondary_id:e}}remove_secondary(t){const e=this.secondary_connections.get(t);if(!e)throw new Error(`Secondary node ${t} not found`);return this.log.info("Removing secondary node",{secondary_id:t}),e.socket.end(),this.secondary_connections.delete(t),this.stats.connected_secondaries=this.secondary_connections.size,{success:!0,message:`Secondary node ${t} removed successfully`,secondary_id:t}}async sync_secondaries(){if(!this.enabled)throw new Error("Replication is not enabled");this.log.info("Forcing secondary synchronization"),await this.process_replication_queue();const t={type:"ping",timestamp:Date.now()},e=d(t),n=[];for(const[s,i]of this.secondary_connections)try{i.authenticated?(i.socket.write(e),n.push({secondary_id:s,status:"ping_sent"})):n.push({secondary_id:s,status:"not_authenticated"})}catch(o){n.push({secondary_id:s,status:"error",error:o.message})}return{success:!0,message:"Secondary synchronization initiated",results:n}}get_replication_status(){const t=[];for(const[e,n]of this.secondary_connections)t.push({id:e,ip:n.ip,port:n.port,authenticated:n.authenticated,last_ping:n.last_ping,pending_operations:n.pending_operations.size,connected:!n.socket.destroyed});return{enabled:this.enabled,mode:this.mode,connected_secondaries:this.stats.connected_secondaries,queue_length:this.replication_queue.length,processing:this.processing_replication,stats:this.stats,secondaries:t}}get_secondary_health(){const t=[],e=Date.now();for(const[n,s]of this.secondary_connections){const i=e-s.last_ping,o=s.authenticated&&!s.socket.destroyed&&i<3e4;t.push({id:n,ip:s.ip,port:s.port,healthy:o,authenticated:s.authenticated,connected:!s.socket.destroyed,last_ping_age_ms:i,pending_operations:s.pending_operations.size})}return{total_secondaries:t.length,healthy_secondaries:t.filter(n=>n.healthy).length,secondaries:t}}async shutdown(){this.log.info("Shutting down replication manager"),this.enabled=!1,this.processing_replication=!1;for(const[t,e]of this.secondary_connections)try{e.socket.end()}catch(n){this.log.warn("Error closing secondary connection",{secondary_id:t,error:n.message})}this.secondary_connections.clear(),this.replication_queue=[],this.stats.connected_secondaries=0,this.log.info("Replication manager shutdown complete")}}let r=null;const b=()=>(r||(r=new w),r),v=()=>{b().initialize()},R=async()=>{r&&(await r.shutdown(),r=null)};export{b as get_replication_manager,v as initialize_replication_manager,R as shutdown_replication_manager};

package/dist/server/lib/write_forwarder.js

@@ -1 +0,0 @@
-import h from"net";import m from"crypto";import{get_settings as p}from"./load_settings.js";import{encode_message as a,create_message_parser as l}from"./tcp_protocol.js";import f from"./logger.js";const{create_context_logger:w}=f("write_forwarder");class g{constructor(){this.primary_connection=null,this.is_secondary_mode=!1,this.primary_config=null,this.pending_forwards=new Map,this.forward_timeout_ms=1e4,this.reconnect_delay_ms=5e3,this.log=w(),this.stats={total_forwards:0,successful_forwards:0,failed_forwards:0,avg_forward_latency_ms:0,total_forward_time_ms:0,connection_attempts:0,last_connection_attempt:null}}initialize(){try{const r=p();if(r.mode!=="secondary"||!r.primary){this.log.info("Node not configured as secondary - write forwarding disabled");return}this.is_secondary_mode=!0,this.primary_config=r.primary,this.forward_timeout_ms=r.replication?.timeout_ms||1e4,this.log.info("Initializing write forwarder for secondary mode",{primary_ip:this.primary_config.ip,primary_port:this.primary_config.port,timeout_ms:this.forward_timeout_ms}),this.connect_to_primary()}catch(r){this.log.warn("Could not initialize write forwarder - settings not loaded",{error:r.message})}}async connect_to_primary(){if(!this.is_secondary_mode||!this.primary_config)return;const{ip:r,port:t,public_key:o}=this.primary_config;this.log.info("Connecting to primary node",{ip:r,port:t}),this.stats.connection_attempts++,this.stats.last_connection_attempt=Date.now();try{const e=new h.Socket,n=l();e.connect(t,r,()=>{this.log.info("Connected to primary node",{ip:r,port:t}),this.authenticate_with_primary(e,o)}),e.on("data",i=>{try{const s=n.parse_messages(i);for(const d of s)this.handle_primary_response(d)}catch(s){this.log.error("Failed to parse primary response",{error:s.message})}}),e.on("error",i=>{this.log.error("Primary connection error",{error:i.message}),this.primary_connection=null,this.fail_pending_forwards("Primary connection error"),setTimeout(()=>{this.connect_to_primary()},this.reconnect_delay_ms)}),e.on("close",()=>{this.log.warn("Primary connection closed"),this.primary_connection=null,this.fail_pending_forwards("Primary connection closed"),setTimeout(()=>{this.connect_to_primary()},this.reconnect_delay_ms)}),this.primary_connection={socket:e,authenticated:!1,last_ping:Date.now()}}catch(e){this.log.error("Failed to connect to primary",{ip:r,port:t,error:e.message}),setTimeout(()=>{this.connect_to_primary()},this.reconnect_delay_ms)}}authenticate_with_primary(r,t){try{const o=Date.now(),e=`secondary-${process.pid}`,n=`${e}:${o}`,s={op:"authentication",data:{password:m.createHmac("sha256",Buffer.from(t,"base64")).update(n).digest("base64"),node_type:"secondary",node_id:e}},d=a(s);r.write(d),this.log.debug("Sent authentication to primary")}catch(o){this.log.error("Failed to authenticate with primary",{error:o.message})}}handle_primary_response(r){if(this.primary_connection)try{const t=typeof r=="string"?JSON.parse(r):r;if(t.ok===1&&t.message==="Authentication successful"){this.primary_connection.authenticated=!0,this.log.info("Primary authentication successful");return}if(t.forward_id){this.handle_forward_response(t);return}if(t.ok===1&&!t.forward_id){this.primary_connection.last_ping=Date.now();return}this.log.debug("Unhandled primary response",{type:typeof t,keys:Object.keys(t)})}catch(t){this.log.error("Failed to handle primary response",{error:t.message})}}handle_forward_response(r){const{forward_id:t}=r,o=this.pending_forwards.get(t);if(!o){this.log.warn("Received response for unknown forward",{forward_id:t});return}const e=Date.now()-o.sent_at;this.stats.total_forward_time_ms+=e,clearTimeout(o.timeout),this.pending_forwards.delete(t);const n={...r};delete n.forward_id,r.ok===1||r.ok===!0?(this.stats.successful_forwards++,this.log.debug("Forward operation successful",{forward_id:t,latency_ms:e,operation:o.operation})):(this.stats.failed_forwards++,this.log.error("Forward operation failed",{forward_id:t,latency_ms:e,operation:o.operation,error:r.error}));const i=this.stats.successful_forwards+this.stats.failed_forwards;this.stats.avg_forward_latency_ms=i>0?Math.round(this.stats.total_forward_time_ms/i):0;try{const s=a(n);o.client_socket.write(s)}catch(s){this.log.error("Failed to send response to client",{forward_id:t,error:s.message})}}should_forward_operation(r){return this.is_secondary_mode?["insert_one","update_one","delete_one","bulk_write","create_index","drop_index"].includes(r):!1}async forward_operation(r,t,o){if(!this.is_secondary_mode||!this.should_forward_operation(t))return!1;if(!this.primary_connection||!this.primary_connection.authenticated){this.log.error("Cannot forward operation - not connected to primary",{operation:t,connected:!!this.primary_connection,authenticated:this.primary_connection?.authenticated||!1});const s=a({ok:0,error:"Secondary node not connected to primary"});return r.write(s),!0}const e=this.generate_forward_id();this.log.debug("Forwarding operation to primary",{forward_id:e,operation:t,client_id:r.id});const n={op:t,data:o,forward_id:e,forwarded_by:`secondary-${process.pid}`,original_client_id:r.id,timestamp:Date.now()};try{const i=a(n);this.primary_connection.socket.write(i);const s=setTimeout(()=>{this.handle_forward_timeout(e)},this.forward_timeout_ms);return this.pending_forwards.set(e,{client_socket:r,operation:t,data:o,sent_at:Date.now(),timeout:s}),this.stats.total_forwards++,!0}catch(i){this.log.error("Failed to forward operation",{forward_id:e,operation:t,error:i.message});const s={ok:0,error:`Failed to forward operation: ${i.message}`},d=a(s);return r.write(d),!0}}handle_forward_timeout(r){const t=this.pending_forwards.get(r);if(!t)return;this.log.error("Forward operation timed out",{forward_id:r,operation:t.operation,timeout_ms:this.forward_timeout_ms}),this.pending_forwards.delete(r),this.stats.failed_forwards++;const o=Date.now()-t.sent_at;this.stats.total_forward_time_ms+=o;const e=this.stats.successful_forwards+this.stats.failed_forwards;this.stats.avg_forward_latency_ms=e>0?Math.round(this.stats.total_forward_time_ms/e):0;try{const i=a({ok:0,error:"Operation forwarding timed out"});t.client_socket.write(i)}catch(n){this.log.error("Failed to send timeout error to client",{forward_id:r,error:n.message})}}fail_pending_forwards(r){for(const[t,o]of this.pending_forwards){clearTimeout(o.timeout),this.log.error("Failing pending forward operation",{forward_id:t,operation:o.operation,reason:r});try{const e={ok:0,error:`Forward operation failed: ${r}`},n=a(e);o.client_socket.write(n)}catch(e){this.log.error("Failed to send error to client",{forward_id:t,error:e.message})}}this.stats.failed_forwards+=this.pending_forwards.size,this.pending_forwards.clear()}generate_forward_id(){return`fwd_${Date.now()}_${Math.random().toString(36).substr(2,9)}`}get_forwarder_status(){return{enabled:this.is_secondary_mode,connected_to_primary:!!this.primary_connection&&this.primary_connection.authenticated,primary_config:this.primary_config?{ip:this.primary_config.ip,port:this.primary_config.port}:null,pending_forwards:this.pending_forwards.size,stats:this.stats}}async shutdown(){if(this.log.info("Shutting down write forwarder"),this.fail_pending_forwards("Server shutting down"),this.primary_connection){try{this.primary_connection.socket.end()}catch(r){this.log.warn("Error closing primary connection",{error:r.message})}this.primary_connection=null}this.is_secondary_mode=!1,this.log.info("Write forwarder shutdown complete")}}let c=null;const u=()=>(c||(c=new g),c),$=()=>{u().initialize()},z=async()=>{c&&(await c.shutdown(),c=null)};export{u as get_write_forwarder,$ as initialize_write_forwarder,z as shutdown_write_forwarder};