cql-rb 1.1.3 → 1.2.0.pre0

data/lib/cql/client/void_result.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module Cql
+  module Client
+    class VoidResult
+      include Enumerable
+
+      INSTANCE = self.new
+
+      # @return [ResultMetadata]
+      attr_reader :metadata
+
+      # The ID of the query trace associated with the query, if any.
+      #
+      # @return [Cql::Uuid]
+      attr_reader :trace_id
+
+      # @private
+      def initialize(trace_id=nil)
+        @trace_id = trace_id
+        @metadata = EMPTY_METADATA
+      end
+
+      # Always returns true
+      def empty?
+        true
+      end
+
+      # No-op for API compatibility with {QueryResult}.
+      #
+      # @return [Enumerable]
+      def each(&block)
+        self
+      end
+      alias_method :each_row, :each
+
+      private
+
+      EMPTY_METADATA = ResultMetadata.new([])
+    end
+  end
+end

data/lib/cql/compression.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module Cql
+  module Compression
+    CompressionError = Class.new(CqlError)
+
+    # @note Compressors given to {Cql::Client.connect} as the `:compressor`
+    #   option don't need to be subclasses of this class, but need to
+    #   implement the same methods. This class exists only for documentation
+    #   purposes.
+    class Compressor
+      # @!method algorithm
+      #
+      # Returns the name of the algorithm this compressor supports,
+      # e.g. "snappy" or "lz4".
+      #
+      # @return [String]
+
+      # @!method compress?
+      #
+      # Before compressing a frame the compressor will be asked if it wants
+      # to compress it or not. One reason it could say no is if the frame is
+      # small enough that compression would be unlikely to decrease its size.
+      #
+      # If your operations consist mostly of small prepared statement
+      # executions it might not be useful to compress the frames being sent
+      # _to_ Cassandra, but enabling compression can still be useful on the
+      # frames coming _from_ Cassandra. Making this method always return
+      # false disables request compression, but will still make the client
+      # tell Cassandra that it supports compressed frames.
+      #
+      # The bytes given to {#compress?} are the same as to {#compress}
+      #
+      # @param [String] frame the bytes of the frame to be compressed
+      # @return [true, false]
+
+      # @!method compress
+      #
+      # Compresses the raw bytes of a frame.
+      #
+      # @param [String] frame the bytes of the frame to be compressed
+      # @return [String] the compressed frame
+
+      # @!method decompress
+      #
+      # Decompresses the raw bytes of a compressed frame.
+      #
+      # @param [String] compressed_frame the bytes of the compressed
+      #   frame to be uncompressed
+      # @return [String]
+    end
+  end
+end

data/lib/cql/compression/snappy_compressor.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+begin
+  require 'snappy'
+rescue LoadError => e
+  raise LoadError, %[Snappy support requires the "snappy" gem: #{e.message}], e.backtrace
+end
+
+module Cql
+  module Compression
+
+    # A compressor that uses the Snappy compression library.
+    #
+    # @note This compressor requires the [snappy](http://rubygems.org/gems/snappy)
+    #   gem (v0.0.10 or later for JRuby support).
+    class SnappyCompressor
+      # @return [String]
+      attr_reader :algorithm
+
+      # @param [Integer] min_size (64) Don't compress frames smaller than
+      #   this size (see {#compress?}).
+      def initialize(min_size=64)
+        @algorithm = 'snappy'.freeze
+        @min_size = min_size
+      end
+
+      # @return [true, false] will return false for frames smaller than the
+      #   `min_size` given to the constructor.
+      def compress?(str)
+        str.bytesize > @min_size
+      end
+
+      def compress(str)
+        Snappy.deflate(str)
+      end
+
+      def decompress(str)
+        Snappy.inflate(str)
+      end
+    end
+  end
+end

data/lib/cql/io/io_reactor.rb

@@ -83,12 +83,17 @@ module Cql
     class IoReactor
       # Initializes a new IO reactor.
       #
-      # @param protocol_handler_factory [Object] a class that will be used
-      #   create the protocol handler objects returned by {#connect}
+      # @param protocol_handler_factory [Proc, Class] a Proc or class that
+      #   will be used create the protocol handler objects returned by
+      #   {#connect}
       # @param options [Hash] only used to inject behaviour during tests
       #
       def initialize(protocol_handler_factory, options={})
-        @protocol_handler_factory = protocol_handler_factory
+        if protocol_handler_factory.respond_to?(:new)
+          @protocol_handler_factory = protocol_handler_factory.method(:new)
+        else
+          @protocol_handler_factory = protocol_handler_factory
+        end
         @clock = options[:clock] || Time
         @unblocker = Unblocker.new
         @io_loop = IoLoopBody.new(options)
@@ -184,7 +189,7 @@ module Cql
       def connect(host, port, timeout)
         connection = Connection.new(host, port, timeout, @unblocker, @clock)
         f = connection.connect
-        protocol_handler = @protocol_handler_factory.new(connection, self)
+        protocol_handler = @protocol_handler_factory.call(connection, self)
         @io_loop.add_socket(connection)
         @unblocker.unblock!
         f.map { protocol_handler }

data/lib/cql/protocol.rb

@@ -14,6 +14,7 @@ module Cql
     UnsupportedResultKindError = Class.new(ProtocolError)
     UnsupportedColumnTypeError = Class.new(ProtocolError)
     UnsupportedEventTypeError = Class.new(ProtocolError)
+    UnexpectedCompressionError = Class.new(ProtocolError)
 
     CONSISTENCIES = [:any, :one, :two, :three, :quorum, :all, :local_quorum, :each_quorum, nil, nil, nil, nil, nil, nil, nil, nil, :local_one].freeze
 
@@ -55,8 +56,8 @@ require 'cql/protocol/responses/prepared_result_response'
 require 'cql/protocol/responses/schema_change_result_response'
 require 'cql/protocol/responses/event_response'
 require 'cql/protocol/responses/schema_change_event_response'
-require 'cql/protocol/responses/status_change_event_result_response'
-require 'cql/protocol/responses/topology_change_event_result_response'
+require 'cql/protocol/responses/status_change_event_response'
+require 'cql/protocol/responses/topology_change_event_response'
 require 'cql/protocol/request'
 require 'cql/protocol/requests/startup_request'
 require 'cql/protocol/requests/credentials_request'
@@ -65,5 +66,6 @@ require 'cql/protocol/requests/register_request'
 require 'cql/protocol/requests/query_request'
 require 'cql/protocol/requests/prepare_request'
 require 'cql/protocol/requests/execute_request'
-require 'cql/protocol/response_frame'
+require 'cql/protocol/frame_encoder'
+require 'cql/protocol/frame_decoder'
 require 'cql/protocol/cql_protocol_handler'

data/lib/cql/protocol/cql_protocol_handler.rb

@@ -19,14 +19,17 @@ module Cql
       # @return [String] the current keyspace for the underlying connection
       attr_reader :keyspace
 
-      def initialize(connection, scheduler)
+      def initialize(connection, scheduler, compressor=nil)
         @connection = connection
         @scheduler = scheduler
+        @compressor = compressor
         @connection.on_data(&method(:receive_data))
         @connection.on_closed(&method(:socket_closed))
         @promises = Array.new(128) { nil }
         @read_buffer = ByteBuffer.new
-        @current_frame = Protocol::ResponseFrame.new(@read_buffer)
+        @frame_encoder = FrameEncoder.new(@compressor)
+        @frame_decoder = FrameDecoder.new(@compressor)
+        @current_frame = FrameDecoder::NULL_FRAME
         @request_queue_in = []
         @request_queue_out = []
         @event_listeners = []
@@ -113,7 +116,7 @@ module Cql
       #   the response
       def send_request(request, timeout=nil)
         return Future.failed(NotConnectedError.new) if closed?
-        promise = RequestPromise.new(request)
+        promise = RequestPromise.new(request, @frame_encoder)
         id = nil
         @lock.synchronize do
           if (id = next_stream_id)
@@ -122,7 +125,7 @@ module Cql
         end
         if id
           @connection.write do |buffer|
-            request.encode_frame(id, buffer)
+            @frame_encoder.encode_frame(request, id, buffer)
           end
         else
           @lock.synchronize do
@@ -152,8 +155,9 @@ module Cql
       class RequestPromise < Promise
         attr_reader :request, :frame
 
-        def initialize(request)
+        def initialize(request, frame_encoder)
           @request = request
+          @frame_encoder = frame_encoder
           @timed_out = false
           super()
         end
@@ -170,12 +174,13 @@ module Cql
         end
 
         def encode_frame!
-          @frame = @request.encode_frame(0)
+          @frame = @frame_encoder.encode_frame(@request)
         end
       end
 
       def receive_data(data)
-        @current_frame << data
+        @read_buffer << data
+        @current_frame = @frame_decoder.decode_frame(@read_buffer, @current_frame)
         while @current_frame.complete?
           id = @current_frame.stream_id
           if id == -1
@@ -183,7 +188,7 @@ module Cql
           else
             complete_request(id, @current_frame.body)
           end
-          @current_frame = Protocol::ResponseFrame.new(@read_buffer)
+          @current_frame = @frame_decoder.decode_frame(@read_buffer)
           flush_request_queue
         end
       end
@@ -235,7 +240,7 @@ module Cql
             end
           end
           if id
-            Protocol::Request.change_stream_id(id, frame)
+            @frame_encoder.change_stream_id(id, frame)
             @connection.write(frame)
           else
             break

data/lib/cql/protocol/frame_decoder.rb

@@ -0,0 +1,106 @@
+# encoding: utf-8
+
+module Cql
+  module Protocol
+    class FrameDecoder
+      def initialize(compressor=nil)
+        @compressor = compressor
+      end
+
+      def decode_frame(buffer, partial_frame=nil)
+        partial_frame ||= NULL_FRAME
+        if partial_frame == NULL_FRAME
+          buffer_length = buffer.length
+          return NULL_FRAME if buffer_length < 8
+          fields = buffer.read_int
+          size = buffer.read_int
+          if buffer_length >= size
+            actual_decode(buffer, fields, size)
+          else
+            PartialFrame.new(fields, size)
+          end
+        elsif buffer.length >= partial_frame.size
+          actual_decode(buffer, partial_frame.fields, partial_frame.size)
+        else
+          partial_frame
+        end
+      end
+
+      private
+
+      def actual_decode(buffer, fields, size)
+        if (fields >> 24) & 0x80 == 0
+          raise UnsupportedFrameTypeError, 'Request frames are not supported'
+        end
+        protocol_version = (fields >> 24) & 0x7f
+        compression = (fields >> 16) & 0x01
+        tracing = (fields >> 16) & 0x02
+        stream_id = (fields >> 8) & 0xff
+        stream_id = (stream_id & 0x7f) - (stream_id & 0x80)
+        opcode = fields & 0xff
+        if compression == 1
+          buffer = decompress(buffer, size)
+          size = buffer.size
+        end
+        extra_length = buffer.length - size 
+        trace_id = tracing == 2 ? Decoding.read_uuid!(buffer) : nil
+        response = Response.decode!(opcode, buffer, trace_id)
+        if buffer.length > extra_length
+          buffer.discard(buffer.length - extra_length)
+        end
+        CompleteFrame.new(stream_id, response)
+      end
+
+      def decompress(buffer, size)
+        if @compressor
+          compressed_body = buffer.read(size)
+          ByteBuffer.new(@compressor.decompress(compressed_body))
+        else
+          raise UnexpectedCompressionError, 'Compressed frame received, but no compressor configured'
+        end
+      end
+
+      class NullFrame
+        def size
+          nil
+        end
+
+        def complete?
+          false
+        end
+      end
+
+      class PartialFrame
+        attr_reader :fields, :size
+
+        def initialize(fields, size)
+          @fields = fields
+          @size = size
+        end
+
+        def stream_id
+          nil
+        end
+
+        def complete?
+          false
+        end
+      end
+
+      class CompleteFrame
+        attr_reader :stream_id, :body
+
+        def initialize(stream_id, body)
+          @stream_id = stream_id
+          @body = body
+        end
+
+        def complete?
+          true
+        end
+      end
+
+      NULL_FRAME = NullFrame.new
+    end
+  end
+end

data/lib/cql/protocol/frame_encoder.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+module Cql
+  module Protocol
+    class FrameEncoder
+      def initialize(compressor=nil)
+        @compressor = compressor
+      end
+
+      def encode_frame(request, stream_id=0, buffer=nil)
+        raise InvalidStreamIdError, 'The stream ID must be between 0 and 127' unless 0 <= stream_id && stream_id < 128
+        buffer ||= ByteBuffer.new
+        offset = buffer.bytesize
+        flags = request.trace? ? 2 : 0
+        body = request.write(ByteBuffer.new)
+        if @compressor && request.compressable? && @compressor.compress?(body)
+          flags |= 1
+          body = @compressor.compress(body)
+        end
+        header = [1, flags, stream_id, request.opcode, body.bytesize]
+        buffer << header.pack(Formats::HEADER_FORMAT)
+        buffer << body
+        buffer
+      end
+
+      def change_stream_id(new_stream_id, buffer, offset=0)
+        buffer.update(offset + 2, new_stream_id.chr)
+      end
+    end
+  end
+end

data/lib/cql/protocol/request.rb

@@ -5,23 +5,19 @@ module Cql
     class Request
       include Encoding
 
-      attr_reader :opcode
+      attr_reader :opcode, :trace
 
-      def initialize(opcode)
+      def initialize(opcode, trace=false)
         @opcode = opcode
+        @trace = trace
       end
 
-      def encode_frame(stream_id=0, buffer=ByteBuffer.new)
-        raise InvalidStreamIdError, 'The stream ID must be between 0 and 127' unless 0 <= stream_id && stream_id < 128
-        offset = buffer.bytesize
-        buffer << [1, 0, stream_id, opcode, 0].pack(Formats::HEADER_FORMAT)
-        write(buffer)
-        buffer.update(offset + 4, [(buffer.bytesize - offset - 8)].pack(Formats::INT_FORMAT))
-        buffer
+      def trace?
+        @trace
       end
 
-      def self.change_stream_id(new_stream_id, buffer, offset=0)
-        buffer.update(offset + 2, new_stream_id.chr)
+      def compressable?
+        true
       end
     end
   end