bigbasealpha/src/replication/index.js

Professional Grade Custom Database System - A sophisticated, dependency-free database with encryption, caching, indexing, and web dashboard

import { EventEmitter } from 'events';
import http from 'http';
import https from 'https';
import crypto from 'crypto';

/**
 * Data Replication Engine for BigBaseAlpha
 * Handles master-slave replication, failover, and data consistency
 */
export class ReplicationEngine extends EventEmitter {
  constructor(config) {
    super();
    
    this.config = {
      enabled: config.replication?.enabled || false,
      mode: config.replication?.mode || 'master-slave', // 'master-slave', 'master-master', 'cluster'
      port: config.replication?.port || 8082,
      nodes: config.replication?.nodes || [],
      syncInterval: config.replication?.syncInterval || 5000,
      heartbeatInterval: config.replication?.heartbeatInterval || 3000,
      maxRetries: config.replication?.maxRetries || 3,
      compressionEnabled: config.replication?.compression || true,
      encryptionEnabled: config.replication?.encryption || true,
      ...config.replication
    };

    this.database = null;
    this.nodes = new Map();
    this.connections = new Map();
    this.server = null;
    this.role = 'master'; // 'master', 'slave', 'candidate'
    this.masterId = null;
    this.isInitialized = false;
    
    // Replication state
    this.state = {
      isActive: false,
      lastSync: null,
      syncInProgress: false,
      operationsQueue: [],
      conflictLog: [],
      networkPartitions: new Set(),
      electionInProgress: false
    };

    // Performance metrics
    this.metrics = {
      operationsReplicated: 0,
      syncOperations: 0,
      conflicts: 0,
      networkErrors: 0,
      avgSyncTime: 0,
      lastHeartbeat: null,
      uptime: Date.now()
    };

    this.timers = new Map();
  }

  async init() {
    if (this.isInitialized) return;

    console.log('🔄 Initializing Data Replication Engine...');

    if (!this.config.enabled) {
      console.log('⚠️ Replication is disabled in configuration');
      return;
    }

    try {
      // Initialize replication server
      await this._initializeServer();

      // Connect to configured nodes
      await this._connectToNodes();

      // Start background processes
      this._startHeartbeat();
      this._startSyncProcess();

      this.state.isActive = true;
      this.isInitialized = true;

      this.emit('replicationStarted', {
        role: this.role,
        nodes: this.nodes.size,
        mode: this.config.mode
      });

      console.log(`✅ Data Replication Engine initialized (Role: ${this.role})`);
    } catch (error) {
      console.error('❌ Failed to initialize replication:', error.message);
      throw error;
    }
  }

  setDatabase(database) {
    this.database = database;
    
    // Bind to database events for real-time replication
    this.database.on('dataChanged', (event) => {
      this._handleDataChange(event);
    });
  }

  async _initializeServer() {
    return new Promise((resolve, reject) => {
      console.log('🌐 HTTP-based replication server would be initialized here');
      console.log('ℹ️ WebSocket replication requires "ws" package');
      
      // Simulate server initialization
      setTimeout(() => {
        console.log(`🌐 Replication server simulated on port ${this.config.port}`);
        resolve();
      }, 100);
      
      // this.server = new WebSocketServer({
      //   port: this.config.port,
      //   perMessageDeflate: this.config.compressionEnabled
      // });
      //
      // this.server.on('connection', (ws, req) => {
      //   this._handleNewConnection(ws, req);
      // });
      //
      // this.server.on('listening', () => {
      //   console.log(`🌐 Replication server listening on port ${this.config.port}`);
      //   resolve();
      // });
      //
      // this.server.on('error', (error) => {
      //   console.error('❌ Replication server error:', error.message);
      //   reject(error);
      // });
    });
  }

  async _connectToNodes() {
    for (const nodeConfig of this.config.nodes) {
      try {
        await this._connectToNode(nodeConfig);
      } catch (error) {
        console.warn(`⚠️ Failed to connect to node ${nodeConfig.id}:`, error.message);
      }
    }
  }

  async _connectToNode(nodeConfig) {
    const nodeId = nodeConfig.id;
    const url = `http://${nodeConfig.host}:${nodeConfig.port}`;

    console.log(`🔗 Would connect to replication node: ${nodeId} at ${url}`);
    console.log('ℹ️ WebSocket connections require "ws" package');

    // Simulate connection
    const node = {
      id: nodeId,
      config: nodeConfig,
      connection: null,
      status: 'simulated',
      lastHeartbeat: Date.now(),
      role: nodeConfig.role || 'slave',
      priority: nodeConfig.priority || 1,
      lag: 0
    };

    this.nodes.set(nodeId, node);
    console.log(`✅ Simulated connection to replication node: ${nodeId}`);
    this.emit('nodeConnected', { nodeId, role: node.role });

    // const ws = new WebSocket(url);
    // const node = {
    //   id: nodeId,
    //   config: nodeConfig,
    //   connection: ws,
    //   status: 'connecting',
    //   lastHeartbeat: null,
    //   role: nodeConfig.role || 'slave',
    //   priority: nodeConfig.priority || 1,
    //   lag: 0
    // };
    //
    // ws.on('open', () => {
    //   node.status = 'connected';
    //   this.nodes.set(nodeId, node);
    //   
    //   // Send initial handshake
    //   this._sendMessage(ws, {
    //     type: 'handshake',
    //     nodeId: this.config.nodeId || 'local',
    //     role: this.role,
    //     timestamp: Date.now()
    //   });
    //
    //   console.log(`✅ Connected to replication node: ${nodeId}`);
    //   this.emit('nodeConnected', { nodeId, role: node.role });
    // });
    //
    // ws.on('message', (data) => {
    //   this._handleMessage(nodeId, data);
    // });
    //
    // ws.on('close', () => {
    //   node.status = 'disconnected';
    //   console.log(`🔌 Disconnected from replication node: ${nodeId}`);
    //   this.emit('nodeDisconnected', { nodeId });
    //   
    //   // Attempt reconnection
    //   this._scheduleReconnection(nodeConfig);
    // });
    //
    // ws.on('error', (error) => {
    //   console.error(`❌ Connection error with node ${nodeId}:`, error.message);
    //   this.metrics.networkErrors++;
    // });
  }

  _handleNewConnection(ws, req) {
    const connectionId = this._generateId();
    
    ws.on('message', (data) => {
      this._handleMessage(connectionId, data);
    });

    ws.on('close', () => {
      this.connections.delete(connectionId);
    });

    this.connections.set(connectionId, {
      id: connectionId,
      connection: ws,
      ip: req.socket.remoteAddress,
      connectedAt: Date.now(),
      authenticated: false
    });
  }

  _handleMessage(senderId, data) {
    try {
      const message = JSON.parse(data.toString());
      
      switch (message.type) {
        case 'handshake':
          this._handleHandshake(senderId, message);
          break;
        case 'heartbeat':
          this._handleHeartbeat(senderId, message);
          break;
        case 'sync_request':
          this._handleSyncRequest(senderId, message);
          break;
        case 'sync_data':
          this._handleSyncData(senderId, message);
          break;
        case 'operation':
          this._handleReplicatedOperation(senderId, message);
          break;
        case 'election':
          this._handleElection(senderId, message);
          break;
        case 'conflict':
          this._handleConflict(senderId, message);
          break;
        default:
          console.warn(`⚠️ Unknown message type: ${message.type}`);
      }
    } catch (error) {
      console.error('❌ Error handling replication message:', error.message);
    }
  }

  _handleDataChange(event) {
    if (!this.state.isActive || this.role !== 'master') return;

    // Queue operation for replication
    const operation = {
      id: this._generateId(),
      type: event.type,
      collection: event.collection,
      data: event.data,
      timestamp: Date.now(),
      source: 'local'
    };

    this.state.operationsQueue.push(operation);
    this._replicateOperation(operation);
  }

  async _replicateOperation(operation) {
    const message = {
      type: 'operation',
      operation: operation,
      checksum: this._calculateChecksum(operation)
    };

    // Send to all connected slaves
    for (const [nodeId, node] of this.nodes) {
      if (node.role === 'slave' && node.status === 'connected') {
        try {
          this._sendMessage(node.connection, message);
          this.metrics.operationsReplicated++;
        } catch (error) {
          console.error(`❌ Failed to replicate to node ${nodeId}:`, error.message);
        }
      }
    }
  }

  async _handleReplicatedOperation(senderId, message) {
    if (this.role !== 'slave') return;

    const { operation, checksum } = message;
    
    // Verify checksum
    if (this._calculateChecksum(operation) !== checksum) {
      console.error('❌ Checksum mismatch in replicated operation');
      this.metrics.conflicts++;
      return;
    }

    try {
      // Apply operation to local database
      await this._applyOperation(operation);
      
      // Send acknowledgment
      this._sendMessage(this.nodes.get(senderId)?.connection, {
        type: 'ack',
        operationId: operation.id,
        status: 'success'
      });
    } catch (error) {
      console.error('❌ Failed to apply replicated operation:', error.message);
      
      this._sendMessage(this.nodes.get(senderId)?.connection, {
        type: 'ack',
        operationId: operation.id,
        status: 'error',
        error: error.message
      });
    }
  }

  async _applyOperation(operation) {
    if (!this.database) return;

    const { type, collection, data } = operation;

    switch (type) {
      case 'insert':
        await this.database.insert(collection, data, { skipReplication: true });
        break;
      case 'update':
        await this.database.update(collection, data._id, data, { skipReplication: true });
        break;
      case 'delete':
        await this.database.delete(collection, data._id, { skipReplication: true });
        break;
      case 'createCollection':
        await this.database.createCollection(collection, data.schema, { skipReplication: true });
        break;
      default:
        throw new Error(`Unknown operation type: ${type}`);
    }
  }

  _startHeartbeat() {
    if (this.timers.has('heartbeat')) return;

    const heartbeatTimer = setInterval(() => {
      this._sendHeartbeat();
    }, this.config.heartbeatInterval);

    this.timers.set('heartbeat', heartbeatTimer);
  }

  _sendHeartbeat() {
    const heartbeat = {
      type: 'heartbeat',
      nodeId: this.config.nodeId || 'local',
      role: this.role,
      timestamp: Date.now(),
      health: this._getHealthStatus()
    };

    for (const [nodeId, node] of this.nodes) {
      if (node.status === 'connected') {
        this._sendMessage(node.connection, heartbeat);
      }
    }

    this.metrics.lastHeartbeat = Date.now();
  }

  _handleHeartbeat(senderId, message) {
    const node = this.nodes.get(senderId);
    if (node) {
      node.lastHeartbeat = Date.now();
      node.lag = Date.now() - message.timestamp;
    }
  }

  _startSyncProcess() {
    if (this.timers.has('sync')) return;

    const syncTimer = setInterval(() => {
      this._performSync();
    }, this.config.syncInterval);

    this.timers.set('sync', syncTimer);
  }

  async _performSync() {
    if (this.state.syncInProgress || this.role !== 'master') return;

    this.state.syncInProgress = true;
    const startTime = Date.now();

    try {
      // Sync with all slaves
      for (const [nodeId, node] of this.nodes) {
        if (node.role === 'slave' && node.status === 'connected') {
          await this._syncWithNode(nodeId);
        }
      }

      this.state.lastSync = Date.now();
      this.metrics.avgSyncTime = Date.now() - startTime;
      this.metrics.syncOperations++;
    } catch (error) {
      console.error('❌ Sync operation failed:', error.message);
    } finally {
      this.state.syncInProgress = false;
    }
  }

  async _syncWithNode(nodeId) {
    const node = this.nodes.get(nodeId);
    if (!node) return;

    // Request sync status from node
    this._sendMessage(node.connection, {
      type: 'sync_request',
      timestamp: Date.now()
    });
  }

  // Master Election (for failover)
  async _startElection() {
    if (this.state.electionInProgress) return;

    this.state.electionInProgress = true;
    console.log('🗳️ Starting master election...');

    const election = {
      type: 'election',
      candidateId: this.config.nodeId || 'local',
      priority: this.config.priority || 1,
      timestamp: Date.now()
    };

    // Send election message to all nodes
    for (const [nodeId, node] of this.nodes) {
      if (node.status === 'connected') {
        this._sendMessage(node.connection, election);
      }
    }

    // Wait for responses and determine winner
    setTimeout(() => {
      this._concludeElection();
    }, 5000);
  }

  _concludeElection() {
    // Simple priority-based election
    let highestPriority = this.config.priority || 1;
    let winner = this.config.nodeId || 'local';

    for (const [nodeId, node] of this.nodes) {
      if (node.config.priority > highestPriority) {
        highestPriority = node.config.priority;
        winner = nodeId;
      }
    }

    if (winner === (this.config.nodeId || 'local')) {
      this._becomeMaster();
    } else {
      this._becomeSlave(winner);
    }

    this.state.electionInProgress = false;
  }

  _becomeMaster() {
    this.role = 'master';
    this.masterId = this.config.nodeId || 'local';
    console.log('👑 Became replication master');
    this.emit('roleChanged', { role: 'master' });
  }

  _becomeSlave(masterId) {
    this.role = 'slave';
    this.masterId = masterId;
    console.log(`🔗 Became slave to master: ${masterId}`);
    this.emit('roleChanged', { role: 'slave', masterId });
  }

  _sendMessage(connection, message) {
    // Simulate message sending
    console.log('📤 Would send replication message:', message.type);
    
    // if (connection && connection.readyState === WebSocket.OPEN) {
    //   const data = JSON.stringify(message);
    //   connection.send(data);
    // }
  }

  _calculateChecksum(data) {
    return crypto.createHash('md5').update(JSON.stringify(data)).digest('hex');
  }

  _generateId() {
    return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
  }

  _getHealthStatus() {
    return {
      uptime: Date.now() - this.metrics.uptime,
      memoryUsage: process.memoryUsage(),
      operationsReplicated: this.metrics.operationsReplicated,
      conflicts: this.metrics.conflicts,
      nodes: this.nodes.size
    };
  }

  _scheduleReconnection(nodeConfig) {
    setTimeout(() => {
      this._connectToNode(nodeConfig);
    }, 5000);
  }

  // Public API methods
  getReplicationStatus() {
    return {
      enabled: this.config.enabled,
      role: this.role,
      masterId: this.masterId,
      nodes: Array.from(this.nodes.values()).map(node => ({
        id: node.id,
        status: node.status,
        role: node.role,
        lastHeartbeat: node.lastHeartbeat,
        lag: node.lag
      })),
      state: this.state,
      metrics: this.metrics
    };
  }

  getConnectedNodes() {
    return Array.from(this.nodes.values()).filter(node => node.status === 'connected');
  }

  async forceSync() {
    if (this.role === 'master') {
      await this._performSync();
      return { status: 'success', message: 'Sync completed' };
    } else {
      return { status: 'error', message: 'Only master can initiate sync' };
    }
  }

  async switchRole(newRole) {
    if (newRole === 'master') {
      this._becomeMaster();
    } else if (newRole === 'slave') {
      this._becomeSlave(null);
    }
    
    return { status: 'success', role: this.role };
  }

  getReplicationMetrics() {
    return {
      ...this.metrics,
      uptime: Date.now() - this.metrics.uptime,
      nodesCount: this.nodes.size,
      connectionsCount: this.connections.size,
      queueSize: this.state.operationsQueue.length
    };
  }

  async shutdown() {
    // Stop all timers
    for (const [name, timer] of this.timers) {
      clearInterval(timer);
    }
    this.timers.clear();

    // Close all connections
    for (const [nodeId, node] of this.nodes) {
      if (node.connection) {
        node.connection.close();
      }
    }

    // Close server
    if (this.server) {
      this.server.close();
    }

    this.state.isActive = false;
    console.log('🔄 Replication engine shutdown complete');
  }
}

export default ReplicationEngine;