rubydb 0.1.4 → 0.1.5

data/lib/rubydb/protocol/protocol.rb

@@ -1,277 +1,276 @@
-# frozen_string_literal: true
-
-require "socket"
-require "timeout"
-require "monitor"
-require_relative "message"
-require_relative "encoder"
-require_relative "decoder"
-require_relative "version"
-require_relative "capabilities"
-require_relative "handshake"
-
-module RubyDB
-  module Protocol
-    class Protocol
-      attr_reader :encoder, :decoder, :handshake, :capabilities, :stats
-
-      def initialize(options = {})
-        @options = options
-        @encoder = Encoder.new(options[:format] || Encoder::FORMAT_JSON, options)
-        @decoder = Decoder.new(options)
-        @handshake = Handshake.new(options[:server_info])
-        @capabilities = Capabilities.default_server
-        @buffer = ""
-        @chunk_size = options[:chunk_size] || 4096
-        @socket = nil
-        @connected = false
-        @authenticated = false
-        @stats = {
-          messages_sent: 0,
-          messages_received: 0,
-          bytes_sent: 0,
-          bytes_received: 0,
-          errors: 0,
-          reconnects: 0,
-          connection_time: 0
-        }
-        @lock = Monitor.new
-        @read_timeout = options[:read_timeout] || 30
-        @write_timeout = options[:write_timeout] || 30
-      end
-
-      def connect(host, port)
-        @lock.synchronize do
-          start_time = Time.now
-
-          begin
-            @socket = TCPSocket.new(host, port)
-            @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-
-            if @read_timeout
-              @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, [@read_timeout, 0].pack("l_2"))
-            end
-
-            if @write_timeout
-              @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, [@write_timeout, 0].pack("l_2"))
-            end
-
-            @connected = true
-            @stats[:connection_time] = (Time.now - start_time) * 1000
-
-            # Perform handshake
-            perform_handshake
-
-            true
-
-          rescue => e
-            @stats[:errors] += 1
-            @connected = false
-            raise ProtocolError, "Connection failed: #{e.message}"
-          end
-        end
-      end
-
-      def disconnect
-        @lock.synchronize do
-          if @socket
-            begin
-              send_message(Message.new(Message::TYPE_TERMINATE))
-            rescue
-              # Ignore errors on disconnect
-            end
-            @socket.close
-          end
-
-          @socket = nil
-          @connected = false
-          @authenticated = false
-          true
-        end
-      end
-
-      def send_message(message)
-        @lock.synchronize do
-          raise ProtocolError, "Not connected" unless @connected
-
-          begin
-            data = @encoder.encode(message)
-            @socket.write(data)
-            @socket.flush
-
-            @stats[:messages_sent] += 1
-            @stats[:bytes_sent] += data.bytesize
-
-            true
-          rescue => e
-            @stats[:errors] += 1
-            raise ProtocolError, "Send failed: #{e.message}"
-          end
-        end
-      end
-
-      def receive_message(timeout = @read_timeout)
-        @lock.synchronize do
-          raise ProtocolError, "Not connected" unless @connected
-
-          begin
-            Timeout.timeout(timeout) do
-              data = read_data
-              @stats[:bytes_received] += data.bytesize
-              @stats[:messages_received] += 1
-
-              @decoder.decode(data, @encoder.format)
-            end
-          rescue Timeout::Error
-            @stats[:errors] += 1
-            raise ProtocolError, "Receive timeout"
-          rescue => e
-            @stats[:errors] += 1
-            raise ProtocolError, "Receive failed: #{e.message}"
-          end
-        end
-      end
-
-      def query(sql, params = [])
-        message = Message.new(Message::TYPE_QUERY, { sql: sql, params: params })
-        send_message(message)
-        receive_message
-      end
-
-      def prepare(sql)
-        message = Message.new(Message::TYPE_PREPARE, { sql: sql })
-        send_message(message)
-        receive_message
-      end
-
-      def execute(statement_id, params = [])
-        message = Message.new(Message::TYPE_EXECUTE, { statement_id: statement_id, params: params })
-        send_message(message)
-        receive_message
-      end
-
-      def close_statement(statement_id)
-        message = Message.new(Message::TYPE_CLOSE, { statement_id: statement_id })
-        send_message(message)
-        receive_message
-      end
-
-      def begin_transaction
-        message = Message.new(Message::TYPE_BEGIN)
-        send_message(message)
-        receive_message
-      end
-
-      def commit
-        message = Message.new(Message::TYPE_COMMIT)
-        send_message(message)
-        receive_message
-      end
-
-      def rollback
-        message = Message.new(Message::TYPE_ROLLBACK)
-        send_message(message)
-        receive_message
-      end
-
-      def ping
-        message = Message.new(Message::TYPE_PING)
-        send_message(message)
-        receive_message
-      end
-
-      def connected?
-        @connected && @socket && !@socket.closed?
-      end
-
-      def authenticated?
-        @authenticated
-      end
-
-      def reconnect(host, port)
-        @lock.synchronize do
-          disconnect
-          connect(host, port)
-          @stats[:reconnects] += 1
-          true
-        end
-      end
-
-      def stats
-        @lock.synchronize do
-          @stats.merge({
-            connected: @connected,
-            authenticated: @authenticated,
-            handshake_state: @handshake.state,
-            buffer_size: @buffer.bytesize,
-            socket_info: @socket ? "#{@socket.peeraddr[2]}:#{@socket.peeraddr[1]}" : nil
-          })
-        end
-      end
-
-      private
-
-      def read_data
-        @socket.gets || ""
-      end
-
-      def perform_handshake
-        # Send handshake request
-        handshake_msg = Message.new(
-          Message::TYPE_HANDSHAKE,
-          {
-            protocol_version: ProtocolVersion.current,
-            client_name: "RubyDB Client",
-            client_version: RubyDB::VERSION
-          }
-        )
-
-        send_message(handshake_msg)
-        response = receive_message
-
-        if response.type == Message::TYPE_HANDSHAKE_RESPONSE
-          handshake_data = response.payload
-
-          if handshake_data[:success]
-            # Send authentication response
-            auth_msg = Message.new(
-              Message::TYPE_AUTHENTICATION_RESPONSE,
-              {
-                username: @options[:username] || "rubydb",
-                password: @options[:password] || "",
-                auth_method: @options[:auth_method] || "none"
-              }
-            )
-
-            send_message(auth_msg)
-            auth_response = receive_message
-
-            if auth_response.type == Message::TYPE_AUTHENTICATION
-              @authenticated = true
-              @handshake.state = Handshake::STATE_AUTHENTICATED
-
-              # Negotiate capabilities
-              caps_msg = Message.new(
-                Message::TYPE_SYNCHRONIZE,
-                {
-                  capabilities: Capabilities.default_client.to_hash
-                }
-              )
-
-              send_message(caps_msg)
-              caps_response = receive_message
-
-              if caps_response.type == Message::TYPE_READY_FOR_QUERY
-                @handshake.state = Handshake::STATE_COMPLETE
-                @capabilities.negotiate(caps_response.payload[:capabilities] || 0)
-                @authenticated = true
-              end
-            end
-          else
-            raise ProtocolError, "Handshake failed: #{handshake_data[:error]}"
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "socket"
+require "timeout"
+require "monitor"
+require_relative "message"
+require_relative "encoder"
+require_relative "decoder"
+require_relative "version"
+require_relative "capabilities"
+require_relative "handshake"
+
+module RubyDB
+  module Protocol
+    class Protocol
+      attr_reader :encoder, :decoder, :handshake, :capabilities, :stats
+
+      def initialize(options = {})
+        @options = options
+        @encoder = Encoder.new(options[:format] || Encoder::FORMAT_JSON, options)
+        @decoder = Decoder.new(options)
+        @handshake = Handshake.new(options[:server_info])
+        @capabilities = Capabilities.default_server
+        @buffer = ""
+        @chunk_size = options[:chunk_size] || 4096
+        @socket = nil
+        @connected = false
+        @authenticated = false
+        @stats = {
+          messages_sent: 0,
+          messages_received: 0,
+          bytes_sent: 0,
+          bytes_received: 0,
+          errors: 0,
+          reconnects: 0,
+          connection_time: 0
+        }
+        @lock = Monitor.new
+        @read_timeout = options[:read_timeout] || 30
+        @write_timeout = options[:write_timeout] || 30
+      end
+
+      def connect(host, port)
+        @lock.synchronize do
+          start_time = Time.now
+
+          begin
+            @socket = TCPSocket.new(host, port)
+            @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+
+            if @read_timeout
+              @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, [@read_timeout, 0].pack("l_2"))
+            end
+
+            if @write_timeout
+              @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, [@write_timeout, 0].pack("l_2"))
+            end
+
+            @connected = true
+            @stats[:connection_time] = (Time.now - start_time) * 1000
+
+            # Perform handshake
+            perform_handshake
+
+            true
+          rescue => e
+            @stats[:errors] += 1
+            @connected = false
+            raise ProtocolError, "Connection failed: #{e.message}"
+          end
+        end
+      end
+
+      def disconnect
+        @lock.synchronize do
+          if @socket
+            begin
+              send_message(Message.new(Message::TYPE_TERMINATE))
+            rescue
+              # Ignore errors on disconnect
+            end
+            @socket.close
+          end
+
+          @socket = nil
+          @connected = false
+          @authenticated = false
+          true
+        end
+      end
+
+      def send_message(message)
+        @lock.synchronize do
+          raise ProtocolError, "Not connected" unless @connected
+
+          begin
+            data = @encoder.encode(message)
+            @socket.write(data)
+            @socket.flush
+
+            @stats[:messages_sent] += 1
+            @stats[:bytes_sent] += data.bytesize
+
+            true
+          rescue => e
+            @stats[:errors] += 1
+            raise ProtocolError, "Send failed: #{e.message}"
+          end
+        end
+      end
+
+      def receive_message(timeout = @read_timeout)
+        @lock.synchronize do
+          raise ProtocolError, "Not connected" unless @connected
+
+          begin
+            Timeout.timeout(timeout) do
+              data = read_data
+              @stats[:bytes_received] += data.bytesize
+              @stats[:messages_received] += 1
+
+              @decoder.decode(data, @encoder.format)
+            end
+          rescue Timeout::Error
+            @stats[:errors] += 1
+            raise ProtocolError, "Receive timeout"
+          rescue => e
+            @stats[:errors] += 1
+            raise ProtocolError, "Receive failed: #{e.message}"
+          end
+        end
+      end
+
+      def query(sql, params = [])
+        message = Message.new(Message::TYPE_QUERY, {sql: sql, params: params})
+        send_message(message)
+        receive_message
+      end
+
+      def prepare(sql)
+        message = Message.new(Message::TYPE_PREPARE, {sql: sql})
+        send_message(message)
+        receive_message
+      end
+
+      def execute(statement_id, params = [])
+        message = Message.new(Message::TYPE_EXECUTE, {statement_id: statement_id, params: params})
+        send_message(message)
+        receive_message
+      end
+
+      def close_statement(statement_id)
+        message = Message.new(Message::TYPE_CLOSE, {statement_id: statement_id})
+        send_message(message)
+        receive_message
+      end
+
+      def begin_transaction
+        message = Message.new(Message::TYPE_BEGIN)
+        send_message(message)
+        receive_message
+      end
+
+      def commit
+        message = Message.new(Message::TYPE_COMMIT)
+        send_message(message)
+        receive_message
+      end
+
+      def rollback
+        message = Message.new(Message::TYPE_ROLLBACK)
+        send_message(message)
+        receive_message
+      end
+
+      def ping
+        message = Message.new(Message::TYPE_PING)
+        send_message(message)
+        receive_message
+      end
+
+      def connected?
+        @connected && @socket && !@socket.closed?
+      end
+
+      def authenticated?
+        @authenticated
+      end
+
+      def reconnect(host, port)
+        @lock.synchronize do
+          disconnect
+          connect(host, port)
+          @stats[:reconnects] += 1
+          true
+        end
+      end
+
+      def stats
+        @lock.synchronize do
+          @stats.merge({
+            connected: @connected,
+            authenticated: @authenticated,
+            handshake_state: @handshake.state,
+            buffer_size: @buffer.bytesize,
+            socket_info: @socket ? "#{@socket.peeraddr[2]}:#{@socket.peeraddr[1]}" : nil
+          })
+        end
+      end
+
+      private
+
+      def read_data
+        @socket.gets || ""
+      end
+
+      def perform_handshake
+        # Send handshake request
+        handshake_msg = Message.new(
+          Message::TYPE_HANDSHAKE,
+          {
+            protocol_version: ProtocolVersion.current,
+            client_name: "RubyDB Client",
+            client_version: RubyDB::VERSION
+          }
+        )
+
+        send_message(handshake_msg)
+        response = receive_message
+
+        if response.type == Message::TYPE_HANDSHAKE_RESPONSE
+          handshake_data = response.payload
+
+          if handshake_data[:success]
+            # Send authentication response
+            auth_msg = Message.new(
+              Message::TYPE_AUTHENTICATION_RESPONSE,
+              {
+                username: @options[:username] || "rubydb",
+                password: @options[:password] || "",
+                auth_method: @options[:auth_method] || "none"
+              }
+            )
+
+            send_message(auth_msg)
+            auth_response = receive_message
+
+            if auth_response.type == Message::TYPE_AUTHENTICATION
+              @authenticated = true
+              @handshake.state = Handshake::STATE_AUTHENTICATED
+
+              # Negotiate capabilities
+              caps_msg = Message.new(
+                Message::TYPE_SYNCHRONIZE,
+                {
+                  capabilities: Capabilities.default_client.to_hash
+                }
+              )
+
+              send_message(caps_msg)
+              caps_response = receive_message
+
+              if caps_response.type == Message::TYPE_READY_FOR_QUERY
+                @handshake.state = Handshake::STATE_COMPLETE
+                @capabilities.negotiate(caps_response.payload[:capabilities] || 0)
+                @authenticated = true
+              end
+            end
+          else
+            raise ProtocolError, "Handshake failed: #{handshake_data[:error]}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubydb/protocol/version.rb

@@ -1,54 +1,54 @@
-# frozen_string_literal: true
-
-module RubyDB
-  module Protocol
-    # ProtocolVersion - Defines protocol versions and compatibility
-    class ProtocolVersion
-      MAJOR = 1
-      MINOR = 0
-      PATCH = 0
-
-      VERSION_STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
-      VERSION_INT = (MAJOR << 16) | (MINOR << 8) | PATCH
-
-      # Supported protocol versions
-      SUPPORTED_VERSIONS = {
-        0x010000 => "1.0.0",
-        0x010001 => "1.0.1"
-      }
-
-      def self.current
-        VERSION_INT
-      end
-
-      def self.current_string
-        VERSION_STRING
-      end
-
-      def self.supported?(version)
-        SUPPORTED_VERSIONS.key?(version)
-      end
-
-      def self.parse(version_string)
-        parts = version_string.split(".").map(&:to_i)
-        return nil if parts.size != 3
-        (parts[0] << 16) | (parts[1] << 8) | parts[2]
-      end
-
-      def self.to_string(version_int)
-        major = (version_int >> 16) & 0xFF
-        minor = (version_int >> 8) & 0xFF
-        patch = version_int & 0xFF
-        "#{major}.#{minor}.#{patch}"
-      end
-
-      def self.compatible?(client_version, server_version)
-        # Major version must match
-        return false if (client_version >> 16) != (server_version >> 16)
-        # Minor version: server must support client's minor version
-        return false if (client_version & 0xFF00) > (server_version & 0xFF00)
-        true
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RubyDB
+  module Protocol
+    # ProtocolVersion - Defines protocol versions and compatibility
+    class ProtocolVersion
+      MAJOR = 1
+      MINOR = 0
+      PATCH = 0
+
+      VERSION_STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
+      VERSION_INT = (MAJOR << 16) | (MINOR << 8) | PATCH
+
+      # Supported protocol versions
+      SUPPORTED_VERSIONS = {
+        0x010000 => "1.0.0",
+        0x010001 => "1.0.1"
+      }
+
+      def self.current
+        VERSION_INT
+      end
+
+      def self.current_string
+        VERSION_STRING
+      end
+
+      def self.supported?(version)
+        SUPPORTED_VERSIONS.key?(version)
+      end
+
+      def self.parse(version_string)
+        parts = version_string.split(".").map(&:to_i)
+        return nil if parts.size != 3
+        (parts[0] << 16) | (parts[1] << 8) | parts[2]
+      end
+
+      def self.to_string(version_int)
+        major = (version_int >> 16) & 0xFF
+        minor = (version_int >> 8) & 0xFF
+        patch = version_int & 0xFF
+        "#{major}.#{minor}.#{patch}"
+      end
+
+      def self.compatible?(client_version, server_version)
+        # Major version must match
+        return false if (client_version >> 16) != (server_version >> 16)
+        # Minor version: server must support client's minor version
+        return false if (client_version & 0xFF00) > (server_version & 0xFF00)
+        true
+      end
+    end
+  end
+end