rubydb 0.1.0

data/lib/rubydb/server/lifecycle.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require "time"
+
+module RubyDB
+  module Server
+    # Lifecycle - Manages server lifecycle events
+    class Lifecycle
+      attr_reader :state, :stats
+
+      # Lifecycle states
+      STATE_INIT = :init
+      STATE_STARTING = :starting
+      STATE_RUNNING = :running
+      STATE_STOPPING = :stopping
+      STATE_STOPPED = :stopped
+      STATE_FAILED = :failed
+      STATE_RESTARTING = :restarting
+
+      def initialize(server, config = {})
+        @server = server
+        @config = config
+        @state = STATE_INIT
+        @health_check_interval = config[:health_check_interval] || 30
+        @graceful_timeout = config[:graceful_timeout] || 30
+        @max_restart_attempts = config[:max_restart_attempts] || 3
+        @restart_attempts = 0
+        @stats = {
+          state_changes: 0,
+          start_count: 0,
+          stop_count: 0,
+          restart_count: 0,
+          failure_count: 0,
+          uptime_seconds: 0,
+          last_state_change: nil,
+          health_checks: 0,
+          health_check_failures: 0
+        }
+        @lock = Mutex.new
+        @health_thread = nil
+        @running = false
+        @shutdown = false
+        @started_at = nil
+
+        # Register signal handlers
+        register_signal_handlers
+      end
+
+      def start
+        @lock.synchronize do
+          return if @state == STATE_RUNNING
+
+          change_state(STATE_STARTING)
+          @started_at = Time.now
+
+          begin
+            # Start the server
+            @server.start
+            change_state(STATE_RUNNING)
+            @stats[:start_count] += 1
+            @restart_attempts = 0
+
+            # Start health check
+            start_health_check
+
+            true
+          rescue => e
+            change_state(STATE_FAILED)
+            @stats[:failure_count] += 1
+            raise
+          end
+        end
+      end
+
+      def stop(graceful = true)
+        @lock.synchronize do
+          return if @state == STATE_STOPPED
+
+          change_state(STATE_STOPPING)
+
+          begin
+            if graceful
+              # Graceful shutdown
+              @server.stop
+            else
+              # Force shutdown
+              @server.stop
+            end
+
+            change_state(STATE_STOPPED)
+            @stats[:stop_count] += 1
+            @running = false
+
+            true
+          rescue => e
+            change_state(STATE_FAILED)
+            @stats[:failure_count] += 1
+            raise
+          end
+        end
+      end
+
+      def restart(graceful = true)
+        @lock.synchronize do
+          change_state(STATE_RESTARTING)
+          @stats[:restart_count] += 1
+
+          begin
+            stop(graceful)
+            start
+            true
+          rescue => e
+            change_state(STATE_FAILED)
+            @stats[:failure_count] += 1
+            false
+          end
+        end
+      end
+
+      def health_check
+        @lock.synchronize do
+          @stats[:health_checks] += 1
+
+          begin
+            # Check if server is running
+            unless @server.running?
+              @stats[:health_check_failures] += 1
+              return false
+            end
+
+            # Check connection pool
+            pool = @server.connection_pool
+            if pool && pool.total_connections > 0
+              if pool.respond_to?(:healthy?) && !pool.healthy?
+                @stats[:health_check_failures] += 1
+                return false
+              end
+            end
+
+            true
+          rescue => e
+            @stats[:health_check_failures] += 1
+            false
+          end
+        end
+      end
+
+      def running?
+        @state == STATE_RUNNING
+      end
+
+      def stats
+        @lock.synchronize do
+          elapsed = @started_at ? (Time.now - @started_at).to_i : 0
+          @stats[:uptime_seconds] = elapsed
+
+          @stats.merge({
+            state: @state,
+            running: running?,
+            started_at: @started_at&.iso8601,
+            restart_attempts: @restart_attempts,
+            max_restart_attempts: @max_restart_attempts,
+            graceful_timeout: @graceful_timeout
+          })
+        end
+      end
+
+      private
+
+      def change_state(new_state)
+        @state = new_state
+        @stats[:state_changes] += 1
+        @stats[:last_state_change] = Time.now
+      end
+
+      def start_health_check
+        return if @health_thread
+
+        @running = true
+        @health_thread = Thread.new do
+          while @running && !@shutdown
+            sleep(@health_check_interval)
+
+            unless health_check
+              # Health check failed
+              @stats[:health_check_failures] += 1
+
+              if @restart_attempts < @max_restart_attempts
+                @restart_attempts += 1
+                restart
+              else
+                change_state(STATE_FAILED)
+                @running = false
+              end
+            end
+          end
+        end
+      end
+
+      def register_signal_handlers
+        # SIGINT - Graceful shutdown
+        trap("INT") do
+          puts "\nReceived SIGINT, shutting down gracefully..."
+          @shutdown = true
+          stop(true)
+        end
+
+        # SIGTERM - Graceful shutdown
+        trap("TERM") do
+          puts "Received SIGTERM, shutting down gracefully..."
+          @shutdown = true
+          stop(true)
+        end
+
+        # SIGHUP - Restart
+        begin
+          trap("HUP") do
+            puts "Received SIGHUP, restarting..."
+            restart
+          end
+        rescue ArgumentError
+          # Windows does not expose SIGHUP; restart remains available via
+          # the explicit server API.
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/server/listener.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "socket"
+require "openssl"
+
+module RubyDB
+  module Server
+    # Listener - Accepts incoming connections
+    class Listener
+      attr_reader :stats
+
+      def initialize(config, connection_pool, worker_pool)
+        @config = config
+        @connection_pool = connection_pool
+        @worker_pool = worker_pool
+        @socket = nil
+        @running = false
+        @accept_thread = nil
+        @ssl_enabled = false
+        @stats = {
+          connections_accepted: 0,
+          connections_rejected: 0,
+          accept_errors: 0,
+          total_accept_time_ms: 0,
+          avg_accept_time_ms: 0
+        }
+        @lock = Mutex.new
+      end
+
+      def start
+        @lock.synchronize do
+          return if @running
+
+          begin
+            tcp_socket = TCPServer.new(@config[:host], @config[:port])
+            tcp_socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true)
+
+            ssl = @config[:ssl] || {}
+            if ssl == true || ssl[:enabled] || ssl["enabled"]
+              ssl = {} if ssl == true
+              context = OpenSSL::SSL::SSLContext.new
+              context.cert = OpenSSL::X509::Certificate.new(File.binread(ssl[:cert_file] || ssl["cert_file"]))
+              context.key = OpenSSL::PKey.read(File.binread(ssl[:key_file] || ssl["key_file"]))
+              context.ca_file = ssl[:ca_file] || ssl["ca_file"] if ssl[:ca_file] || ssl["ca_file"]
+              context.verify_mode = (ssl[:verify_peer] || ssl["verify_peer"]) ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+              context.min_version = (ssl[:min_version] || ssl["min_version"] || :TLS1_2)
+              context.max_version = (ssl[:max_version] || ssl["max_version"]) if ssl[:max_version] || ssl["max_version"]
+              @socket = OpenSSL::SSL::SSLServer.new(tcp_socket, context)
+              @ssl_enabled = true
+            else
+              @socket = tcp_socket
+            end
+
+            @running = true
+            @accept_thread = Thread.new { accept_loop }
+
+            true
+          rescue => e
+            raise ServerError, "Failed to start listener: #{e.message}"
+          end
+        end
+      end
+
+      def stop
+        @lock.synchronize do
+          return unless @running
+
+          @running = false
+
+          if @accept_thread
+            @accept_thread.kill
+            @accept_thread = nil
+          end
+
+          if @socket
+            @socket.close rescue nil
+            @socket = nil
+          end
+          @ssl_enabled = false
+
+          true
+        end
+      end
+
+      def running?
+        @running
+      end
+
+      private
+
+      def accept_loop
+        while @running
+          begin
+            start_time = Time.now
+
+            # SSLServer performs the TLS handshake while accepting. Keep that
+            # operation blocking so a non-blocking handshake is not discarded
+            # and left waiting forever on the client.
+            client = if @ssl_enabled
+              @socket.accept
+            else
+              candidate = @socket.accept_nonblock(exception: false)
+              candidate.is_a?(IO) ? candidate : nil
+            end
+
+            if client
+              # Check if we have capacity
+              if @connection_pool.can_accept?
+                @connection_pool.add_connection(client)
+                @stats[:connections_accepted] += 1
+              else
+                client.close
+                @stats[:connections_rejected] += 1
+              end
+
+              elapsed_ms = (Time.now - start_time) * 1000
+              @stats[:total_accept_time_ms] += elapsed_ms
+              @stats[:avg_accept_time_ms] = @stats[:total_accept_time_ms] / @stats[:connections_accepted] if @stats[:connections_accepted] > 0
+            end
+
+            # Small sleep to prevent CPU spinning
+            sleep(0.01)
+
+          rescue IO::WaitReadable, Errno::EAGAIN, Errno::EWOULDBLOCK
+            next if @ssl_enabled
+            # No connection ready, continue
+            sleep(0.01)
+          rescue => e
+            @stats[:accept_errors] += 1
+            sleep(0.1) # Back off on error
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/server/request_handler.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module RubyDB
+  module Server
+    # RequestHandler - Handles and routes requests
+    class RequestHandler
+      attr_reader :stats
+
+      def initialize(engine, transaction_manager, config = {})
+        @engine = engine
+        @transaction_manager = transaction_manager
+        @config = config
+        @stats = {
+          requests_processed: 0,
+          requests_failed: 0,
+          query_requests: 0,
+          prepare_requests: 0,
+          execute_requests: 0,
+          transaction_requests: 0,
+          other_requests: 0,
+          total_processing_time_ms: 0,
+          avg_processing_time_ms: 0
+        }
+        @lock = Monitor.new
+        @handlers = {}
+        @middleware = []
+        @query_handlers = {}
+        @prepared_statements = {}
+        @statement_counter = 0
+        @health = config[:health] || RubyDB::Monitoring::Health.new(engine, auto_check: false)
+        @metrics = config[:metrics] || RubyDB::Monitoring::Metrics.new(auto_flush: false)
+
+        # Register default handlers
+        register_default_handlers
+      end
+
+      def handle(request)
+        @lock.synchronize do
+          start_time = Time.now
+
+          begin
+            # Apply middleware
+            request = apply_middleware(request)
+
+            # Route request
+            result = route_request(request)
+
+            @stats[:requests_processed] += 1
+
+            elapsed_ms = (Time.now - start_time) * 1000
+            @stats[:total_processing_time_ms] += elapsed_ms
+            @stats[:avg_processing_time_ms] = @stats[:total_processing_time_ms] / @stats[:requests_processed] if @stats[:requests_processed] > 0
+
+            result
+
+          rescue => e
+            @stats[:requests_failed] += 1
+            error_response(e.message)
+          end
+        end
+      end
+
+      def register_handler(type, handler = nil, &block)
+        @handlers[type] = handler || block
+      end
+
+      def register_middleware(middleware)
+        @middleware << middleware
+      end
+
+      def register_query_handler(pattern, handler)
+        @query_handlers[pattern] = handler
+      end
+
+      def prepare_statement(sql)
+        @lock.synchronize do
+          stmt_id = "stmt_#{Time.now.to_i}_#{@statement_counter}"
+          @statement_counter += 1
+
+          @prepared_statements[stmt_id] = {
+            sql: sql,
+            created_at: Time.now,
+            params: extract_params(sql)
+          }
+
+          stmt_id
+        end
+      end
+
+      def execute_statement(stmt_id, params = [])
+        @lock.synchronize do
+          stmt = @prepared_statements[stmt_id]
+          return error_response("Statement not found") unless stmt
+
+          # Execute the prepared statement
+          execute_sql(stmt[:sql], params)
+        end
+      end
+
+      def close_statement(stmt_id)
+        @lock.synchronize do
+          @prepared_statements.delete(stmt_id)
+          success_response({ closed: true })
+        end
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            prepared_statements: @prepared_statements.size,
+            middleware_count: @middleware.size,
+            handler_count: @handlers.size
+          })
+        end
+      end
+
+      private
+
+      def register_default_handlers
+        # Query handler
+        register_handler(:query) do |request|
+          handle_query(request)
+        end
+
+        # Prepare handler
+        register_handler(:prepare) do |request|
+          handle_prepare(request)
+        end
+
+        # Execute handler
+        register_handler(:execute) do |request|
+          handle_execute(request)
+        end
+
+        # Transaction handlers
+        register_handler(:begin) do |request|
+          handle_begin(request)
+        end
+
+        register_handler(:commit) do |request|
+          handle_commit(request)
+        end
+
+        register_handler(:rollback) do |request|
+          handle_rollback(request)
+        end
+
+        # Ping handler
+        register_handler(:ping) do |request|
+          handle_ping(request)
+        end
+
+        register_handler(:liveness) { |_request| success_response(@health.liveness) }
+        register_handler(:readiness) { |_request| success_response(@health.readiness) }
+        register_handler(:health) { |_request| success_response(@health.check) }
+        register_handler(:metrics) { |_request| success_response({ format: "prometheus", body: @metrics.to_prometheus }) }
+      end
+
+      def route_request(request)
+        type = request[:type]
+
+        handler = @handlers[type]
+        if handler
+          handler.call(request)
+        else
+          error_response("No handler for request type: #{type}")
+        end
+      end
+
+      def apply_middleware(request)
+        @middleware.each do |mw|
+          request = mw.call(request)
+          break if request.nil?
+        end
+        request
+      end
+
+      def handle_query(request)
+        @stats[:query_requests] += 1
+        sql = request[:sql]
+        params = request[:params] || []
+
+        # Check for prepared statement pattern
+        @query_handlers.each do |pattern, handler|
+          if sql.match?(pattern)
+            return handler.call(sql, params)
+          end
+        end
+
+        # Execute SQL
+        execute_sql(sql, params, deadline_at: request[:deadline_at])
+      end
+
+      def handle_prepare(request)
+        @stats[:prepare_requests] += 1
+        sql = request[:sql]
+        stmt_id = prepare_statement(sql)
+
+        success_response({
+          statement_id: stmt_id,
+          sql: sql,
+          params: @prepared_statements[stmt_id][:params]
+        })
+      end
+
+      def handle_execute(request)
+        @stats[:execute_requests] += 1
+        stmt_id = request[:statement_id]
+        params = request[:params] || []
+
+        execute_statement(stmt_id, params)
+      end
+
+      def handle_begin(request)
+        @stats[:transaction_requests] += 1
+        @transaction_manager.begin_transaction
+
+        success_response({
+          transaction_id: @transaction_manager.current_transaction&.id
+        })
+      end
+
+      def handle_commit(request)
+        @stats[:transaction_requests] += 1
+        @transaction_manager.commit_transaction
+
+        success_response({ committed: true })
+      end
+
+      def handle_rollback(request)
+        @stats[:transaction_requests] += 1
+        @transaction_manager.rollback_transaction
+
+        success_response({ rolled_back: true })
+      end
+
+      def handle_ping(request)
+        @stats[:other_requests] += 1
+        success_response({ pong: true, timestamp: Time.now.iso8601 })
+      end
+
+      def execute_sql(sql, params, deadline_at: nil)
+        tokens = RubyDB::SQL::Lexer.new(sql).tokenize
+        statements = RubyDB::SQL::Parser.new(tokens).parse
+        results = statements.map do |statement|
+          plan = RubyDB::Execution::Planner.new(@engine).plan(statement)
+          RubyDB::Execution::Executor.new(@engine, deadline_at: deadline_at).execute(plan)
+        end
+        results.size == 1 ? results.first : results
+      end
+
+      def extract_params(sql)
+        # Extract parameter placeholders from SQL
+        sql.scan(/\$(\d+)/).flatten.map(&:to_i).uniq.sort
+      end
+
+      def success_response(data)
+        {
+          success: true,
+          data: data,
+          timestamp: Time.now.iso8601
+        }
+      end
+
+      def error_response(message)
+        {
+          success: false,
+          error: message,
+          timestamp: Time.now.iso8601
+        }
+      end
+    end
+  end
+end