@joystick.js/db-canary 0.0.0-canary.2250 → 0.0.0-canary.2252

package/src/server/cluster/master.js

@@ -96,98 +96,149 @@ class ClusterMaster extends EventEmitter {
   }
   
   /**
-   * Starts the cluster master and spawns worker processes.
-   * @throws {Error} When startup fails
+   * Determines database path from settings or uses default.
+   * @returns {string} Database path
    */
-  async start() {
-    const start_time = Date.now();
-    
+  get_database_path() {
+    let database_path = './data';
     try {
-      this.settings = load_settings(this.settings_file);
-      this.log.info('Settings loaded successfully', { settings_file: this.settings_file });
-      
-      // NOTE: Initialize database and auth manager.
-      // NOTE: Initialize database with data_path from settings if available.
-      let database_path = './data'; // Default path
-      try {
-        const settings = get_settings();
-        if (settings?.data_path) {
-          database_path = settings.data_path;
-        }
-      } catch (error) {
-        // NOTE: Settings not available, use default path.
+      const settings = get_settings();
+      if (settings?.data_path) {
+        database_path = settings.data_path;
       }
+    } catch (error) {
+      // Settings not available, use default path
+    }
+    return database_path;
+  }
+
+  /**
+   * Initializes core database and authentication systems.
+   */
+  async initialize_core_systems() {
+    const database_path = this.get_database_path();
+    
+    initialize_database(database_path);
+    initialize_auth_manager();
+    await initialize_api_key_manager();
+    
+    this.log.info('Database and auth manager initialized');
+  }
+
+  /**
+   * Handles startup database restore if configured.
+   */
+  async handle_startup_restore() {
+    if (!this.settings?.restore_from) {
+      return;
+    }
+
+    try {
+      this.log.info('Startup restore requested', { backup_filename: this.settings.restore_from });
       
-      initialize_database(database_path);
-      initialize_auth_manager();
-      await initialize_api_key_manager();
-      this.log.info('Database and auth manager initialized');
+      const restore_result = await restore_backup(this.settings.restore_from);
       
-      // NOTE: Handle startup restore if configured.
-      if (this.settings?.restore_from) {
-        try {
-          this.log.info('Startup restore requested', { backup_filename: this.settings.restore_from });
-          
-          const restore_result = await restore_backup(this.settings.restore_from);
-          
-          this.log.info('Startup restore completed', {
-            backup_filename: this.settings.restore_from,
-            duration_ms: restore_result.duration_ms
-          });
-          
-          // NOTE: Remove restore_from from settings after successful restore.
-          const updated_settings = { ...this.settings };
-          delete updated_settings.restore_from;
-          
-          writeFileSync(this.settings_file, JSON.stringify(updated_settings, null, 2));
-          
-          // NOTE: Reload settings to reflect the change.
-          this.settings = load_settings(this.settings_file);
-          
-          this.log.info('Removed restore_from from settings after successful restore');
-        } catch (restore_error) {
-          this.log.error('Startup restore failed', {
-            backup_filename: this.settings.restore_from,
-            error: restore_error.message
-          });
-          
-          // NOTE: Continue with existing database if restore fails.
-          this.log.info('Continuing with existing database after restore failure');
-        }
-      }
+      this.log.info('Startup restore completed', {
+        backup_filename: this.settings.restore_from,
+        duration_ms: restore_result.duration_ms
+      });
       
-      // NOTE: Start backup scheduling if S3 is configured.
-      if (this.settings?.s3) {
-        try {
-          start_backup_schedule();
-          this.log.info('Backup scheduling started');
-        } catch (backup_schedule_error) {
-          this.log.warn('Failed to start backup scheduling', { error: backup_schedule_error.message });
-        }
-      }
+      this.remove_restore_from_settings();
       
-      // NOTE: Start HTTP server for setup if authentication is not configured.
-      if (is_setup_required()) {
-        try {
-          const { http_port } = get_port_configuration();
-          const http_server_instance = await start_http_server(http_port);
-          if (http_server_instance) {
-            this.log.info('HTTP setup server started', { http_port });
-          }
-        } catch (http_error) {
-          this.log.warn('Failed to start HTTP setup server', { error: http_error.message });
-        }
-      }
+    } catch (restore_error) {
+      this.log.error('Startup restore failed', {
+        backup_filename: this.settings.restore_from,
+        error: restore_error.message
+      });
       
-      for (let i = 0; i < this.worker_count; i++) {
-        this.spawn_worker();
+      this.log.info('Continuing with existing database after restore failure');
+    }
+  }
+
+  /**
+   * Removes restore_from setting after successful restore.
+   */
+  remove_restore_from_settings() {
+    const updated_settings = { ...this.settings };
+    delete updated_settings.restore_from;
+    
+    writeFileSync(this.settings_file, JSON.stringify(updated_settings, null, 2));
+    this.settings = load_settings(this.settings_file);
+    
+    this.log.info('Removed restore_from from settings after successful restore');
+  }
+
+  /**
+   * Starts backup scheduling if S3 is configured.
+   */
+  start_backup_scheduling() {
+    if (!this.settings?.s3) {
+      return;
+    }
+
+    try {
+      start_backup_schedule();
+      this.log.info('Backup scheduling started');
+    } catch (backup_schedule_error) {
+      this.log.warn('Failed to start backup scheduling', { error: backup_schedule_error.message });
+    }
+  }
+
+  /**
+   * Starts HTTP setup server if authentication is not configured.
+   */
+  async start_setup_server() {
+    if (!is_setup_required()) {
+      return;
+    }
+
+    try {
+      const { http_port } = get_port_configuration();
+      const http_server_instance = await start_http_server(http_port);
+      if (http_server_instance) {
+        this.log.info('HTTP setup server started', { http_port });
       }
+    } catch (http_error) {
+      this.log.warn('Failed to start HTTP setup server', { error: http_error.message });
+    }
+  }
+
+  /**
+   * Spawns all worker processes.
+   */
+  spawn_all_workers() {
+    for (let i = 0; i < this.worker_count; i++) {
+      this.spawn_worker();
+    }
+  }
+
+  /**
+   * Displays development mode startup message if applicable.
+   */
+  display_development_message() {
+    if (is_development_mode()) {
+      const { tcp_port, http_port } = get_port_configuration();
+      display_development_startup_message(tcp_port, http_port);
+    }
+  }
+
+  /**
+   * Starts the cluster master and spawns worker processes.
+   * @throws {Error} When startup fails
+   */
+  async start() {
+    const start_time = Date.now();
+    
+    try {
+      this.settings = load_settings(this.settings_file);
+      this.log.info('Settings loaded successfully', { settings_file: this.settings_file });
       
-      // NOTE: Display development mode startup message if in development.
-      if (is_development_mode()) {
-        const { tcp_port, http_port } = get_port_configuration();
-        display_development_startup_message(tcp_port, http_port);
-      }
+      await this.initialize_core_systems();
+      await this.handle_startup_restore();
+      this.start_backup_scheduling();
+      await this.start_setup_server();
+      this.spawn_all_workers();
+      this.display_development_message();
       
       const duration_ms = Date.now() - start_time;
       this.log.info('Master process started successfully', {
@@ -657,30 +708,33 @@ await client.ping();
   }
   
   /**
-   * Performs graceful shutdown of the cluster master and all workers.
+   * Stops HTTP server gracefully.
    */
-  async shutdown() {
-    const shutdown_start = Date.now();
-    this.log.info('Initiating graceful shutdown');
-    this.shutting_down = true;
-    
-    // NOTE: Stop HTTP server.
+  async stop_http_server_gracefully() {
     try {
       await stop_http_server();
       this.log.info('HTTP server stopped');
     } catch (http_stop_error) {
       this.log.warn('Failed to stop HTTP server', { error: http_stop_error.message });
     }
-    
-    // NOTE: Stop backup scheduling.
+  }
+
+  /**
+   * Stops backup scheduling gracefully.
+   */
+  stop_backup_scheduling_gracefully() {
     try {
       stop_backup_schedule();
       this.log.info('Backup scheduling stopped');
     } catch (backup_stop_error) {
       this.log.warn('Failed to stop backup scheduling', { error: backup_stop_error.message });
     }
-    
-    // NOTE: Send shutdown signal to all workers.
+  }
+
+  /**
+   * Sends shutdown signal to all workers.
+   */
+  send_shutdown_signals() {
     for (const [worker_id, worker_info] of this.workers) {
       try {
         worker_info.worker.send({ type: 'shutdown' });
@@ -688,28 +742,37 @@ await client.ping();
         this.log.warn('Error sending shutdown signal to worker', { worker_id, error: error.message });
       }
     }
-    
-    // NOTE: Wait for pending writes to complete.
-    if (this.write_queue.length > 0) {
-      this.log.info('Waiting for pending writes to complete', { 
-        pending_writes: this.write_queue.length 
-      });
-      await new Promise((resolve) => {
-        const timeout = setTimeout(() => {
-          this.log.warn('Timeout waiting for writes to complete, proceeding with shutdown');
-          resolve();
-        }, process.env.NODE_ENV === 'test' ? 1000 : 5000);
-        
-        this.once('writes_completed', () => {
-          clearTimeout(timeout);
-          resolve();
-        });
-      });
+  }
+
+  /**
+   * Waits for pending writes to complete with timeout.
+   */
+  async wait_for_pending_writes() {
+    if (this.write_queue.length === 0) {
+      return;
     }
-    
-    this.log.info('All writes completed, disconnecting workers');
-    
-    // NOTE: Disconnect all workers.
+
+    this.log.info('Waiting for pending writes to complete', { 
+      pending_writes: this.write_queue.length 
+    });
+
+    await new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        this.log.warn('Timeout waiting for writes to complete, proceeding with shutdown');
+        resolve();
+      }, process.env.NODE_ENV === 'test' ? 1000 : 5000);
+      
+      this.once('writes_completed', () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+    });
+  }
+
+  /**
+   * Disconnects all workers gracefully.
+   */
+  disconnect_all_workers() {
     for (const [worker_id, worker_info] of this.workers) {
       try {
         worker_info.worker.disconnect();
@@ -717,22 +780,32 @@ await client.ping();
         this.log.warn('Error disconnecting worker', { worker_id, error: error.message });
       }
     }
-    
-    // NOTE: Wait for workers to exit gracefully, but with a timeout for forced termination.
+  }
+
+  /**
+   * Force kills remaining workers after timeout.
+   */
+  force_kill_remaining_workers() {
+    for (const [worker_id, worker_info] of this.workers) {
+      this.log.warn('Force killing worker after timeout', { worker_id });
+      try {
+        worker_info.worker.kill('SIGKILL');
+      } catch (error) {
+        this.log.warn('Error force killing worker', { worker_id, error: error.message });
+      }
+    }
+    this.workers.clear();
+  }
+
+  /**
+   * Waits for workers to exit gracefully with timeout.
+   */
+  async wait_for_workers_to_exit() {
     const graceful_timeout = process.env.NODE_ENV === 'test' ? 500 : 3000;
     
     await new Promise((resolve) => {
       const timeout = setTimeout(() => {
-        // NOTE: Force kill any remaining workers.
-        for (const [worker_id, worker_info] of this.workers) {
-          this.log.warn('Force killing worker after timeout', { worker_id });
-          try {
-            worker_info.worker.kill('SIGKILL');
-          } catch (error) {
-            this.log.warn('Error force killing worker', { worker_id, error: error.message });
-          }
-        }
-        this.workers.clear();
+        this.force_kill_remaining_workers();
         resolve();
       }, graceful_timeout);
       
@@ -746,49 +819,85 @@ await client.ping();
       };
       check_workers();
     });
-    
-    // NOTE: Clean up database connections in master process.
+  }
+
+  /**
+   * Cleans up database connections.
+   */
+  cleanup_database_connections() {
     try {
       cleanup_database();
       this.log.info('Database cleanup completed');
     } catch (cleanup_error) {
       this.log.warn('Error during database cleanup', { error: cleanup_error.message });
     }
-    
-    // NOTE: Clear all internal state.
+  }
+
+  /**
+   * Clears all internal state.
+   */
+  clear_internal_state() {
     this.authenticated_sessions.clear();
     this.write_queue.length = 0;
     this.pending_writes.clear();
-    
-    // NOTE: In test environment, aggressively clean up cluster state to prevent worker reuse.
-    if (process.env.NODE_ENV === 'test') {
-      try {
-        // Force kill any remaining workers in the global cluster state
-        for (const worker_id in cluster.workers) {
-          const worker = cluster.workers[worker_id];
-          if (worker && !worker.isDead()) {
-            this.log.info('Force killing remaining cluster worker', { worker_id, worker_pid: worker.process.pid });
-            try {
-              worker.kill('SIGKILL');
-            } catch (kill_error) {
-              this.log.warn('Error force killing remaining worker', { worker_id, error: kill_error.message });
-            }
+  }
+
+  /**
+   * Performs aggressive cleanup for test environment.
+   */
+  perform_test_environment_cleanup() {
+    if (process.env.NODE_ENV !== 'test') {
+      return;
+    }
+
+    try {
+      // Force kill any remaining workers in the global cluster state
+      for (const worker_id in cluster.workers) {
+        const worker = cluster.workers[worker_id];
+        if (worker && !worker.isDead()) {
+          this.log.info('Force killing remaining cluster worker', { worker_id, worker_pid: worker.process.pid });
+          try {
+            worker.kill('SIGKILL');
+          } catch (kill_error) {
+            this.log.warn('Error force killing remaining worker', { worker_id, error: kill_error.message });
           }
         }
-        
-        // Clear the global cluster workers registry
-        for (const worker_id in cluster.workers) {
-          delete cluster.workers[worker_id];
-        }
-        
-        // Remove all cluster event listeners to prevent memory leaks
-        cluster.removeAllListeners();
-        
-        this.log.info('Aggressive cluster cleanup completed for test environment');
-      } catch (cleanup_error) {
-        this.log.warn('Error during aggressive cluster cleanup', { error: cleanup_error.message });
       }
+      
+      // Clear the global cluster workers registry
+      for (const worker_id in cluster.workers) {
+        delete cluster.workers[worker_id];
+      }
+      
+      // Remove all cluster event listeners to prevent memory leaks
+      cluster.removeAllListeners();
+      
+      this.log.info('Aggressive cluster cleanup completed for test environment');
+    } catch (cleanup_error) {
+      this.log.warn('Error during aggressive cluster cleanup', { error: cleanup_error.message });
     }
+  }
+
+  /**
+   * Performs graceful shutdown of the cluster master and all workers.
+   */
+  async shutdown() {
+    const shutdown_start = Date.now();
+    this.log.info('Initiating graceful shutdown');
+    this.shutting_down = true;
+    
+    await this.stop_http_server_gracefully();
+    this.stop_backup_scheduling_gracefully();
+    this.send_shutdown_signals();
+    await this.wait_for_pending_writes();
+    
+    this.log.info('All writes completed, disconnecting workers');
+    this.disconnect_all_workers();
+    await this.wait_for_workers_to_exit();
+    
+    this.cleanup_database_connections();
+    this.clear_internal_state();
+    this.perform_test_environment_cleanup();
     
     const shutdown_duration = Date.now() - shutdown_start;
     this.log.info('Shutdown complete', { shutdown_duration_ms: shutdown_duration });

package/src/server/cluster/worker.js

@@ -196,29 +196,37 @@ class ClusterWorker {
     });
   }
   
+  /**
+   * Validates and processes a single parsed message.
+   * @param {Object} socket - Socket connection
+   * @param {Object} parsed_data - Parsed message data
+   * @returns {boolean} True if message was processed successfully
+   */
+  process_single_message(socket, parsed_data) {
+    const op_type = parsed_data?.op || null;
+    
+    if (!op_type) {
+      send_error(socket, { message: 'Missing operation type' });
+      return false;
+    }
+    
+    const is_valid_op_type = this.check_op_type(op_type);
+    
+    if (!is_valid_op_type) {
+      send_error(socket, { message: 'Invalid operation type' });
+      return false;
+    }
+    
+    this.route_operation(socket, op_type, parsed_data?.data || {});
+    return true;
+  }
+
   handle_socket_data(socket, raw_data) {
     try {
-      // NOTE: Use the message parser to handle length-prefixed MessagePack messages.
       const messages = socket.message_parser.parse_messages(raw_data);
       
       for (const message of messages) {
-        // NOTE: Message is already decoded from MessagePack by the message parser.
-        const parsed_data = message;
-        const op_type = parsed_data?.op || null;
-        
-        if (!op_type) {
-          send_error(socket, { message: 'Missing operation type' });
-          continue;
-        }
-        
-        const is_valid_op_type = this.check_op_type(op_type);
-        
-        if (!is_valid_op_type) {
-          send_error(socket, { message: 'Invalid operation type' });
-          continue;
-        }
-        
-        this.route_operation(socket, op_type, parsed_data?.data || {});
+        this.process_single_message(socket, message);
       }
       
     } catch (error) {