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

package/src/server/lib/simple_sync_manager.js

@@ -0,0 +1,444 @@
+/**
+ * @fileoverview Simple sync manager for primary nodes in JoystickDB.
+ * Provides basic TCP synchronization of write operations to secondary nodes
+ * with API_KEY authentication and simple retry logic.
+ */
+
+import net from 'net';
+import { get_settings } from './load_settings.js';
+import { encode_message } from './tcp_protocol.js';
+import create_logger from './logger.js';
+
+const { create_context_logger } = create_logger('simple_sync');
+
+/**
+ * Simple sync manager that syncs write operations to secondary nodes.
+ * Uses API_KEY authentication and basic TCP connections with retry logic.
+ */
+class SimpleSyncManager {
+  /**
+   * Creates a new SimpleSyncManager instance.
+   */
+  constructor() {
+    /** @type {boolean} Whether this node is configured as primary */
+    this.is_primary = false;
+    
+    /** @type {Array<Object>} List of secondary nodes to sync to */
+    this.secondary_nodes = [];
+    
+    /** @type {Map<string, Object>} Active connections to secondary nodes */
+    this.connections = new Map();
+    
+    /** @type {number} TCP port for sync operations */
+    this.sync_port = 1985;
+    
+    /** @type {number} Timeout for sync operations in milliseconds */
+    this.sync_timeout_ms = 5000;
+    
+    /** @type {number} Number of retry attempts */
+    this.sync_retries = 2;
+    
+    /** @type {number} Sequence number for operations */
+    this.sequence_number = 0;
+    
+    /** @type {Object} Logger instance */
+    this.log = create_context_logger();
+    
+    /** @type {Object} Sync statistics */
+    this.stats = {
+      total_synced: 0,
+      successful_syncs: 0,
+      failed_syncs: 0,
+      auth_failures: 0
+    };
+  }
+
+  /**
+   * Initializes the sync manager with settings configuration.
+   */
+  initialize() {
+    try {
+      const settings = get_settings();
+      
+      if (!settings.primary) {
+        this.log.info('Node not configured as primary - sync disabled');
+        return;
+      }
+      
+      this.is_primary = settings.primary;
+      this.secondary_nodes = settings.secondary_nodes || [];
+      this.sync_port = settings.sync_port || 1985;
+      this.sync_timeout_ms = settings.sync_timeout_ms || 5000;
+      this.sync_retries = settings.sync_retries || 2;
+      
+      this.log.info('Initializing simple sync manager', {
+        is_primary: this.is_primary,
+        secondary_count: this.secondary_nodes.length,
+        sync_port: this.sync_port,
+        timeout_ms: this.sync_timeout_ms,
+        retries: this.sync_retries
+      });
+      
+      this.connect_to_secondaries();
+      
+    } catch (error) {
+      this.log.warn('Could not initialize sync manager - settings not loaded', {
+        error: error.message
+      });
+    }
+  }
+
+  /**
+   * Establishes connections to all secondary nodes.
+   */
+  connect_to_secondaries() {
+    for (const secondary of this.secondary_nodes) {
+      this.connect_to_secondary(secondary);
+    }
+  }
+
+  /**
+   * Connects to a single secondary node.
+   * @param {Object} secondary - Secondary node configuration
+   */
+  connect_to_secondary(secondary) {
+    const { ip } = secondary;
+    const connection_id = `${ip}:${this.sync_port}`;
+    
+    if (this.connections.has(connection_id)) {
+      return;
+    }
+    
+    this.log.info('Connecting to secondary node', { ip, port: this.sync_port });
+    
+    try {
+      const socket = new net.Socket();
+      
+      socket.connect(this.sync_port, ip, () => {
+        this.log.info('Connected to secondary node', { ip, port: this.sync_port });
+      });
+      
+      socket.on('error', (error) => {
+        this.log.error('Secondary connection error', {
+          ip,
+          error: error.message
+        });
+        
+        this.connections.delete(connection_id);
+        
+        // Retry connection after delay
+        setTimeout(() => {
+          try {
+            this.connect_to_secondary(secondary);
+          } catch (retry_error) {
+            this.log.error('Failed to retry secondary connection', {
+              ip,
+              error: retry_error.message
+            });
+          }
+        }, 5000);
+      });
+      
+      socket.on('close', () => {
+        this.log.warn('Secondary connection closed', { ip });
+        this.connections.delete(connection_id);
+        
+        // Retry connection after delay
+        setTimeout(() => {
+          try {
+            this.connect_to_secondary(secondary);
+          } catch (retry_error) {
+            this.log.error('Failed to retry secondary connection', {
+              ip,
+              error: retry_error.message
+            });
+          }
+        }, 5000);
+      });
+      
+      socket.on('data', (data) => {
+        try {
+          const message = JSON.parse(data.toString());
+          this.handle_sync_response(connection_id, message);
+        } catch (error) {
+          this.log.error('Failed to parse sync response', {
+            connection_id,
+            error: error.message
+          });
+        }
+      });
+      
+      this.connections.set(connection_id, {
+        socket,
+        ip,
+        connected: true,
+        last_sync: null
+      });
+      
+    } catch (error) {
+      this.log.error('Failed to connect to secondary', {
+        ip,
+        error: error.message
+      });
+    }
+  }
+
+  /**
+   * Handles sync response from secondary node.
+   * @param {string} connection_id - Connection identifier
+   * @param {Object} message - Response message from secondary
+   */
+  handle_sync_response(connection_id, message) {
+    const { type, status, sequence, error } = message;
+    
+    if (type !== 'sync_acknowledged') {
+      return;
+    }
+    
+    if (status === 'success') {
+      this.stats.successful_syncs++;
+      this.log.debug('Sync acknowledged', { connection_id, sequence });
+    } else if (status === 'auth_failed') {
+      this.stats.auth_failures++;
+      this.log.error('Sync authentication failed', { connection_id, sequence, error });
+    } else {
+      this.stats.failed_syncs++;
+      this.log.error('Sync failed', { connection_id, sequence, error });
+    }
+  }
+
+  /**
+   * Queues an operation for sync to secondary nodes.
+   * @param {string} operation - Operation type
+   * @param {string} collection - Collection name
+   * @param {Object} data - Operation data
+   */
+  queue_sync(operation, collection, data) {
+    if (!this.is_primary || this.connections.size === 0) {
+      return;
+    }
+    
+    const sequence = ++this.sequence_number;
+    
+    this.log.debug('Queuing sync operation', {
+      operation,
+      collection,
+      sequence,
+      secondary_count: this.connections.size
+    });
+    
+    this.stats.total_synced++;
+    
+    // Send immediately to all connected secondaries
+    this.send_sync_to_secondaries(operation, collection, data, sequence);
+  }
+
+  /**
+   * Sends sync message to all connected secondary nodes.
+   * @param {string} operation - Operation type
+   * @param {string} collection - Collection name
+   * @param {Object} data - Operation data
+   * @param {number} sequence - Sequence number
+   */
+  send_sync_to_secondaries(operation, collection, data, sequence) {
+    try {
+      const settings = get_settings();
+      
+      if (!settings.api_key) {
+        this.log.error('No API_KEY configured for sync operations');
+        return;
+      }
+      
+      const sync_message = {
+        type: 'operation_sync',
+        api_key: settings.api_key,
+        sequence,
+        timestamp: Date.now(),
+        operation,
+        collection,
+        data
+      };
+      
+      const encoded_message = encode_message(sync_message);
+      
+      for (const [connection_id, connection] of this.connections) {
+        if (!connection.connected || !connection.socket) {
+          continue;
+        }
+        
+        try {
+          connection.socket.write(encoded_message);
+          connection.last_sync = Date.now();
+          
+          this.log.debug('Sent sync to secondary', {
+            connection_id,
+            operation,
+            sequence
+          });
+          
+        } catch (error) {
+          this.log.error('Failed to send sync to secondary', {
+            connection_id,
+            error: error.message
+          });
+        }
+      }
+    } catch (error) {
+      this.log.error('Failed to send sync to secondaries', {
+        operation,
+        sequence,
+        error: error.message
+      });
+    }
+  }
+
+  /**
+   * Updates the secondary nodes configuration at runtime.
+   * @param {Array<Object>} new_secondary_nodes - New secondary nodes list
+   */
+  update_secondary_nodes(new_secondary_nodes) {
+    this.log.info('Updating secondary nodes configuration', {
+      old_count: this.secondary_nodes.length,
+      new_count: new_secondary_nodes.length
+    });
+    
+    // Close existing connections
+    for (const [connection_id, connection] of this.connections) {
+      try {
+        connection.socket.end();
+      } catch (error) {
+        this.log.warn('Error closing secondary connection', {
+          connection_id,
+          error: error.message
+        });
+      }
+    }
+    
+    this.connections.clear();
+    this.secondary_nodes = new_secondary_nodes;
+    
+    // Establish new connections
+    this.connect_to_secondaries();
+  }
+
+  /**
+   * Forces sync of all connected secondaries (health check).
+   * @returns {Promise<Object>} Sync status for each secondary
+   */
+  async force_sync() {
+    if (!this.is_primary) {
+      throw new Error('Node is not configured as primary');
+    }
+    
+    const results = [];
+    
+    for (const [connection_id, connection] of this.connections) {
+      try {
+        if (connection.connected) {
+          results.push({
+            connection_id,
+            status: 'sync_initiated'
+          });
+        } else {
+          results.push({
+            connection_id,
+            status: 'not_connected'
+          });
+        }
+      } catch (error) {
+        results.push({
+          connection_id,
+          status: 'error',
+          error: error.message
+        });
+      }
+    }
+    
+    return {
+      success: true,
+      message: 'Force sync initiated',
+      results
+    };
+  }
+
+  /**
+   * Gets current sync status and statistics.
+   * @returns {Object} Sync status information
+   */
+  get_sync_status() {
+    const secondary_status = [];
+    
+    for (const [connection_id, connection] of this.connections) {
+      secondary_status.push({
+        connection_id,
+        ip: connection.ip,
+        connected: connection.connected,
+        last_sync: connection.last_sync
+      });
+    }
+    
+    return {
+      is_primary: this.is_primary,
+      secondary_count: this.connections.size,
+      stats: this.stats,
+      secondaries: secondary_status
+    };
+  }
+
+  /**
+   * Shuts down the sync manager and closes all connections.
+   * @returns {Promise<void>}
+   */
+  async shutdown() {
+    this.log.info('Shutting down simple sync manager');
+    
+    for (const [connection_id, connection] of this.connections) {
+      try {
+        connection.socket.end();
+      } catch (error) {
+        this.log.warn('Error closing secondary connection during shutdown', {
+          connection_id,
+          error: error.message
+        });
+      }
+    }
+    
+    this.connections.clear();
+    this.is_primary = false;
+    
+    this.log.info('Simple sync manager shutdown complete');
+  }
+}
+
+/** @type {SimpleSyncManager|null} Singleton instance */
+let sync_manager_instance = null;
+
+/**
+ * Gets the sync manager singleton instance.
+ * @returns {SimpleSyncManager} Sync manager instance
+ */
+export const get_simple_sync_manager = () => {
+  if (!sync_manager_instance) {
+    sync_manager_instance = new SimpleSyncManager();
+  }
+  return sync_manager_instance;
+};
+
+/**
+ * Initializes the sync manager singleton.
+ */
+export const initialize_simple_sync_manager = () => {
+  const manager = get_simple_sync_manager();
+  manager.initialize();
+};
+
+/**
+ * Shuts down the sync manager singleton.
+ * @returns {Promise<void>}
+ */
+export const shutdown_simple_sync_manager = async () => {
+  if (sync_manager_instance) {
+    await sync_manager_instance.shutdown();
+    sync_manager_instance = null;
+  }
+};