cassandra-driver 3.0.0.beta.1-java → 3.0.0-java

data/lib/cassandra/protocol/responses/void_result_response.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -19,6 +19,9 @@
 module Cassandra
   module Protocol
     class VoidResultResponse < ResultResponse
+      # @private
+      RESULT_TYPES[0x01] = self
+
       def to_s
         %(RESULT VOID)
       end
@@ -26,10 +29,6 @@ module Cassandra
       def void?
         true
       end
-
-      private
-
-      RESULT_TYPES[0x01] = self
     end
   end
 end

data/lib/cassandra/protocol/responses/write_failure_error_response.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -21,7 +21,15 @@ module Cassandra
     class WriteFailureErrorResponse < ErrorResponse
       attr_reader :consistency, :received, :blockfor, :numfailures, :write_type
 
-      def initialize(custom_payload, warnings, code, message, consistency, received, blockfor, numfailures, write_type)
+      def initialize(custom_payload,
+                     warnings,
+                     code,
+                     message,
+                     consistency,
+                     received,
+                     blockfor,
+                     numfailures,
+                     write_type)
         super(custom_payload, warnings, code, message)
 
         write_type.downcase!
@@ -34,11 +42,25 @@ module Cassandra
       end
 
       def to_error(keyspace, statement, options, hosts, consistency, retries)
-        Errors::WriteError.new(@message, @custom_payload, @warnings, keyspace, statement, options, hosts, consistency, retries, @write_type, @consistency, @blockfor, @numfailures, @received)
+        Errors::WriteError.new(@message,
+                               @custom_payload,
+                               @warnings,
+                               keyspace,
+                               statement,
+                               options,
+                               hosts,
+                               consistency,
+                               retries,
+                               @write_type,
+                               @consistency,
+                               @blockfor,
+                               @numfailures,
+                               @received)
       end
 
       def to_s
-        "#{super} #{@write_type} #{@consistency} #{@blockfor} #{@numfailures} #{@received}"
+        "#{super} #{@write_type} #{@consistency} #{@blockfor} " \
+            "#{@numfailures} #{@received}"
       end
     end
   end

data/lib/cassandra/protocol/responses/write_timeout_error_response.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -21,7 +21,14 @@ module Cassandra
     class WriteTimeoutErrorResponse < ErrorResponse
       attr_reader :consistency, :received, :blockfor, :write_type
 
-      def initialize(custom_payload, warnings, code, message, consistency, received, blockfor, write_type)
+      def initialize(custom_payload,
+                     warnings,
+                     code,
+                     message,
+                     consistency,
+                     received,
+                     blockfor,
+                     write_type)
         super(custom_payload, warnings, code, message)
 
         write_type.downcase!
@@ -33,7 +40,19 @@ module Cassandra
       end
 
       def to_error(keyspace, statement, options, hosts, consistency, retries)
-        Errors::WriteTimeoutError.new(@message, @custom_payload, @warnings, keyspace, statement, options, hosts, consistency, retries, @write_type, @consistency, @blockfor, @received)
+        Errors::WriteTimeoutError.new(@message,
+                                      @custom_payload,
+                                      @warnings,
+                                      keyspace,
+                                      statement,
+                                      options,
+                                      hosts,
+                                      consistency,
+                                      retries,
+                                      @write_type,
+                                      @consistency,
+                                      @blockfor,
+                                      @received)
       end
 
       def to_s

data/lib/cassandra/protocol/v1.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -37,7 +37,7 @@ module Cassandra
             body   = @compressor.compress(body)
           end
 
-          header  = [@protocol_version, flags, stream_id, request.opcode, body.bytesize]
+          header = [@protocol_version, flags, stream_id, request.opcode, body.bytesize]
           buffer << header.pack(HEADER_FORMAT)
           buffer << body
           buffer
@@ -131,7 +131,8 @@ module Cassandra
               buffer = CqlByteBuffer.new(@compressor.decompress(buffer.read(size)))
               size   = buffer.size
             else
-              raise Errors::DecodingError, 'Compressed frame received, but no compressor configured'
+              raise Errors::DecodingError,
+                    'Compressed frame received, but no compressor configured'
             end
           end
 
@@ -145,9 +146,7 @@ module Cassandra
           extra_length = buffer.length - size
           response = decode_response(opcode, protocol_version, buffer, size, trace_id)
 
-          if buffer.length > extra_length
-            buffer.discard(buffer.length - extra_length)
-          end
+          buffer.discard(buffer.length - extra_length) if buffer.length > extra_length
 
           if stream_id == -1
             @handler.notify_event_listeners(response)
@@ -156,8 +155,6 @@ module Cassandra
           end
         end
 
-        private
-
         CODE_ERROR          = 0x00
         CODE_READY          = 0x02
         CODE_AUTHENTICATE   = 0x03
@@ -168,22 +165,61 @@ module Cassandra
         CODE_AUTH_SUCCESS   = 0x10
 
         def decode_response(opcode, protocol_version, buffer, size, trace_id)
-          response = case opcode
-          when CODE_READY          then READY
-          when CODE_AUTHENTICATE   then AuthenticateResponse.new(buffer.read_string)
-          when CODE_AUTH_CHALLENGE then AuthChallengeResponse.new(buffer.read_bytes)
-          when CODE_AUTH_SUCCESS   then AuthSuccessResponse.new(buffer.read_bytes)
-          when CODE_SUPPORTED      then SupportedResponse.new(buffer.read_string_multimap)
+          case opcode
+          when CODE_READY then
+            READY
+          when CODE_AUTHENTICATE then
+            AuthenticateResponse.new(buffer.read_string)
+          when CODE_AUTH_CHALLENGE then
+            AuthChallengeResponse.new(buffer.read_bytes)
+          when CODE_AUTH_SUCCESS then
+            AuthSuccessResponse.new(buffer.read_bytes)
+          when CODE_SUPPORTED then
+            SupportedResponse.new(buffer.read_string_multimap)
           when CODE_ERROR
-            code    = buffer.read_int
+            code = buffer.read_int
             message = buffer.read_string
 
             case code
-            when 0x1000 then UnavailableErrorResponse.new(nil, nil, code, message, buffer.read_consistency, buffer.read_int, buffer.read_int)
-            when 0x1100 then WriteTimeoutErrorResponse.new(nil, nil, code, message, buffer.read_consistency, buffer.read_int, buffer.read_int, buffer.read_string)
-            when 0x1200 then ReadTimeoutErrorResponse.new(nil, nil, code, message, buffer.read_consistency, buffer.read_int, buffer.read_int, (buffer.read_byte != 0))
-            when 0x2400 then AlreadyExistsErrorResponse.new(nil, nil, code, message, buffer.read_string, buffer.read_string)
-            when 0x2500 then UnpreparedErrorResponse.new(nil, nil, code, message, buffer.read_short_bytes)
+            when 0x1000 then
+              UnavailableErrorResponse.new(nil,
+                                           nil,
+                                           code,
+                                           message,
+                                           buffer.read_consistency,
+                                           buffer.read_int,
+                                           buffer.read_int)
+            when 0x1100 then
+              WriteTimeoutErrorResponse.new(nil,
+                                            nil,
+                                            code,
+                                            message,
+                                            buffer.read_consistency,
+                                            buffer.read_int,
+                                            buffer.read_int,
+                                            buffer.read_string)
+            when 0x1200 then
+              ReadTimeoutErrorResponse.new(nil,
+                                           nil,
+                                           code,
+                                           message,
+                                           buffer.read_consistency,
+                                           buffer.read_int,
+                                           buffer.read_int,
+                                           (buffer.read_byte != 0))
+            when 0x2400 then
+              AlreadyExistsErrorResponse.new(nil,
+                                             nil,
+                                             code,
+                                             message,
+                                             buffer.read_string,
+                                             buffer.read_string)
+            when 0x2500 then
+              UnpreparedErrorResponse.new(nil,
+                                          nil,
+                                          code,
+                                          message,
+                                          buffer.read_short_bytes)
             else
               ErrorResponse.new(nil, nil, code, message)
             end
@@ -197,50 +233,75 @@ module Cassandra
               column_specs, paging_state = Coder.read_metadata_v1(buffer)
 
               if column_specs.nil?
-                consumed_bytes  = original_buffer_length - buffer.length
-                remaining_bytes = CqlByteBuffer.new(buffer.read(size - consumed_bytes - 4))
-                RawRowsResultResponse.new(nil, nil, protocol_version, remaining_bytes, paging_state, trace_id)
+                consumed_bytes = original_buffer_length - buffer.length
+                remaining_bytes =
+                  CqlByteBuffer.new(buffer.read(size - consumed_bytes - 4))
+                RawRowsResultResponse.new(nil,
+                                          nil,
+                                          protocol_version,
+                                          remaining_bytes,
+                                          paging_state,
+                                          trace_id)
               else
-                RowsResultResponse.new(nil, nil, Coder.read_values_v1(buffer, column_specs), column_specs, paging_state, trace_id)
+                RowsResultResponse.new(nil,
+                                       nil,
+                                       Coder.read_values_v1(buffer, column_specs),
+                                       column_specs,
+                                       paging_state,
+                                       trace_id)
               end
             when 0x0003 # SetKeyspace
               SetKeyspaceResultResponse.new(nil, nil, buffer.read_string, trace_id)
             when 0x0004 # Prepared
-              id              = buffer.read_short_bytes
+              id = buffer.read_short_bytes
               params_metadata = Coder.read_metadata_v1(buffer).first
               result_metadata = nil
               result_metadata = Coder.read_metadata_v1(buffer).first if protocol_version > 1
 
-              PreparedResultResponse.new(nil, nil, id, params_metadata, result_metadata, nil, trace_id)
+              PreparedResultResponse.new(nil,
+                                         nil,
+                                         id,
+                                         params_metadata,
+                                         result_metadata,
+                                         nil,
+                                         trace_id)
             when 0x0005 # SchemaChange
-              change    = buffer.read_string
-              keyspace  = buffer.read_string
-              name      = buffer.read_string
+              change = buffer.read_string
+              keyspace = buffer.read_string
+              name = buffer.read_string
               arguments = EMPTY_LIST
-              target    = nil
+              target = nil
 
               if name.empty?
-                name   = nil
+                name = nil
                 target = Constants::SCHEMA_CHANGE_TARGET_KEYSPACE
               else
                 target = Constants::SCHEMA_CHANGE_TARGET_TABLE
               end
 
-              SchemaChangeResultResponse.new(nil, nil, change, keyspace, name, target, arguments, nil)
+              SchemaChangeResultResponse.new(nil,
+                                             nil,
+                                             change,
+                                             keyspace,
+                                             name,
+                                             target,
+                                             arguments,
+                                             nil)
             else
-              raise Errors::DecodingError, "Unsupported result type: #{result_type.inspect}"
+              raise Errors::DecodingError,
+                    "Unsupported result type: #{result_type.inspect}"
             end
           when CODE_EVENT
             event_type = buffer.read_string
             case event_type
             when 'SCHEMA_CHANGE'
-              change    = buffer.read_string
-              keyspace  = buffer.read_string
-              name      = buffer.read_string
+              change = buffer.read_string
+              keyspace = buffer.read_string
+              name = buffer.read_string
               arguments = EMPTY_LIST
 
               if name.empty?
-                name   = nil
+                name = nil
                 target = Constants::SCHEMA_CHANGE_TARGET_KEYSPACE
               else
                 target = Constants::SCHEMA_CHANGE_TARGET_TABLE

data/lib/cassandra/protocol/v3.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 #--
-# Copyright 2013-2015 DataStax, Inc.
+# Copyright 2013-2016 DataStax, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -37,7 +37,7 @@ module Cassandra
             body   = @compressor.compress(body)
           end
 
-          header  = [@protocol_version, flags, stream_id, request.opcode, body.bytesize]
+          header = [@protocol_version, flags, stream_id, request.opcode, body.bytesize]
           buffer << header.pack(HEADER_FORMAT)
           buffer << body
 
@@ -81,7 +81,9 @@ module Cassandra
             stream_id  = (frame_header >> 8) & 0xff
             stream_id  = (stream_id & 0x7f) - (stream_id & 0x80)
 
-            @handler.complete_request(stream_id, ErrorResponse.new(nil, nil, 0x000A, "Invalid or unsupported protocol version"))
+            error_response = ErrorResponse.new(nil, nil, 0x000A,
+                                               'Invalid or unsupported protocol version')
+            @handler.complete_request(stream_id, error_response)
 
             return
           end
@@ -150,7 +152,7 @@ module Cassandra
           nil
         end
 
-        def actual_decode(buffer, fields, size, code)
+        def actual_decode(buffer, fields, frame_length, code)
           protocol_version = (fields >> 24) & 0x7f
           compression      = (fields >> 16) & 0x01
           tracing          = (fields >> 16) & 0x02
@@ -158,28 +160,40 @@ module Cassandra
           stream_id        = (stream_id & 0x7fff) - (stream_id & 0x8000)
           opcode           = code & 0xff
 
+          # If we're dealing with a compressed body, read the whole body, decompress,
+          # and treat the uncompressed body as if that's what we got in the first place.
+          # This means we must reset frame_length to that uncompressed size.
           if compression == 1
             if @compressor
-              buffer = CqlByteBuffer.new(@compressor.decompress(buffer.read(size)))
-              size   = buffer.size
+              buffer = CqlByteBuffer.new(
+                @compressor.decompress(buffer.read(frame_length)))
+              frame_length = buffer.size
             else
-              raise Errors::DecodingError, 'Compressed frame received, but no compressor configured'
+              raise Errors::DecodingError,
+                    'Compressed frame received, but no compressor configured'
             end
           end
 
-          if tracing == 2
-            trace_id = buffer.read_uuid
-            size    -= 16
-          else
-            trace_id = nil
-          end
+          # We want to read one full frame; but after we read/parse chunks of the body
+          # there may be more cruft left in the frame that we don't care about. So,
+          # we save off the current size of the buffer, do all our reads for the
+          # frame, get the final remaining size, and based on that discard possible
+          # remaining bytes in the frame. In particular, we account for the possibility
+          # that the buffer contains some/all of a subsequent frame as well, and we
+          # don't want to mess with that.
 
-          extra_length = buffer.length - size
-          response = decode_response(opcode, protocol_version, buffer, size, trace_id)
+          buffer_starting_length = buffer.length
 
-          if buffer.length > extra_length
-            buffer.discard(buffer.length - extra_length)
-          end
+          trace_id = (buffer.read_uuid if tracing == 2)
+
+          remaining_frame_length = frame_length -
+                                   (buffer_starting_length - buffer.length)
+          response = decode_response(opcode, protocol_version, buffer,
+                                     remaining_frame_length, trace_id)
+
+          # Calculate and discard remaining cruft in the frame.
+          extra_length = frame_length - (buffer_starting_length - buffer.length)
+          buffer.discard(extra_length) if extra_length > 0
 
           if stream_id == -1
             @handler.notify_event_listeners(response)
@@ -191,15 +205,49 @@ module Cassandra
         def decode_response(opcode, protocol_version, buffer, size, trace_id)
           case opcode
           when 0x00 # ERROR
-            code    = buffer.read_int
+            code = buffer.read_int
             message = buffer.read_string
 
             case code
-            when 0x1000 then UnavailableErrorResponse.new(nil, nil, code, message, buffer.read_consistency, buffer.read_int, buffer.read_int)
-            when 0x1100 then WriteTimeoutErrorResponse.new(nil, nil, code, message, buffer.read_consistency, buffer.read_int, buffer.read_int, buffer.read_string)
-            when 0x1200 then ReadTimeoutErrorResponse.new(nil, nil, code, message, buffer.read_consistency, buffer.read_int, buffer.read_int, (buffer.read_byte != 0))
-            when 0x2400 then AlreadyExistsErrorResponse.new(nil, nil, code, message, buffer.read_string, buffer.read_string)
-            when 0x2500 then UnpreparedErrorResponse.new(nil, nil, code, message, buffer.read_short_bytes)
+            when 0x1000
+              UnavailableErrorResponse.new(nil,
+                                           nil,
+                                           code,
+                                           message,
+                                           buffer.read_consistency,
+                                           buffer.read_int,
+                                           buffer.read_int)
+            when 0x1100
+              WriteTimeoutErrorResponse.new(nil,
+                                            nil,
+                                            code,
+                                            message,
+                                            buffer.read_consistency,
+                                            buffer.read_int,
+                                            buffer.read_int,
+                                            buffer.read_string)
+            when 0x1200
+              ReadTimeoutErrorResponse.new(nil,
+                                           nil,
+                                           code,
+                                           message,
+                                           buffer.read_consistency,
+                                           buffer.read_int,
+                                           buffer.read_int,
+                                           (buffer.read_byte != 0))
+            when 0x2400
+              AlreadyExistsErrorResponse.new(nil,
+                                             nil,
+                                             code,
+                                             message,
+                                             buffer.read_string,
+                                             buffer.read_string)
+            when 0x2500
+              UnpreparedErrorResponse.new(nil,
+                                          nil,
+                                          code,
+                                          message,
+                                          buffer.read_short_bytes)
             else
               ErrorResponse.new(nil, nil, code, message)
             end
@@ -219,49 +267,70 @@ module Cassandra
               column_specs, paging_state = Coder.read_metadata_v3(buffer)
 
               if column_specs.nil?
-                consumed_bytes  = original_buffer_length - buffer.length
-                remaining_bytes = CqlByteBuffer.new(buffer.read(size - consumed_bytes - 4))
-                RawRowsResultResponse.new(nil, nil, protocol_version, remaining_bytes, paging_state, trace_id)
+                consumed_bytes = original_buffer_length - buffer.length
+                remaining_bytes =
+                  CqlByteBuffer.new(buffer.read(size - consumed_bytes - 4))
+                RawRowsResultResponse.new(nil,
+                                          nil,
+                                          protocol_version,
+                                          remaining_bytes,
+                                          paging_state,
+                                          trace_id)
               else
-                RowsResultResponse.new(nil, nil, Coder.read_values_v3(buffer, column_specs), column_specs, paging_state, trace_id)
+                RowsResultResponse.new(nil,
+                                       nil,
+                                       Coder.read_values_v3(buffer, column_specs),
+                                       column_specs,
+                                       paging_state,
+                                       trace_id)
               end
             when 0x0003 # SetKeyspace
               SetKeyspaceResultResponse.new(nil, nil, buffer.read_string, trace_id)
             when 0x0004 # Prepared
-              id              = buffer.read_short_bytes
+              id = buffer.read_short_bytes
               params_metadata = Coder.read_metadata_v3(buffer).first
               result_metadata = nil
               result_metadata = Coder.read_metadata_v3(buffer).first if protocol_version > 1
 
-              PreparedResultResponse.new(nil, nil, id, params_metadata, result_metadata, nil, trace_id)
+              PreparedResultResponse.new(nil,
+                                         nil,
+                                         id,
+                                         params_metadata,
+                                         result_metadata,
+                                         nil,
+                                         trace_id)
             when 0x0005 # SchemaChange
-              change    = buffer.read_string
-              target    = buffer.read_string
-              keyspace  = buffer.read_string
+              change = buffer.read_string
+              target = buffer.read_string
+              keyspace = buffer.read_string
               arguments = EMPTY_LIST
-              name      = nil
-
-              if target == Constants::SCHEMA_CHANGE_TARGET_TABLE
-                name = buffer.read_string
-              end
-
-              SchemaChangeResultResponse.new(nil, nil, change, keyspace, name, target, arguments, nil)
+              name = nil
+
+              name = buffer.read_string if target == Constants::SCHEMA_CHANGE_TARGET_TABLE
+
+              SchemaChangeResultResponse.new(nil,
+                                             nil,
+                                             change,
+                                             keyspace,
+                                             name,
+                                             target,
+                                             arguments,
+                                             nil)
             else
-              raise Errors::DecodingError, "Unsupported result type: #{result_type.inspect}"
+              raise Errors::DecodingError,
+                    "Unsupported result type: #{result_type.inspect}"
             end
           when 0x0C # EVENT
             event_type = buffer.read_string
             case event_type
             when 'SCHEMA_CHANGE'
-              change    = buffer.read_string
-              target    = buffer.read_string
-              keyspace  = buffer.read_string
-              name      = nil
+              change = buffer.read_string
+              target = buffer.read_string
+              keyspace = buffer.read_string
+              name = nil
               arguments = EMPTY_LIST
 
-              if target == Constants::SCHEMA_CHANGE_TARGET_TABLE
-                name = buffer.read_string
-              end
+              name = buffer.read_string if target == Constants::SCHEMA_CHANGE_TARGET_TABLE
 
               SchemaChangeEventResponse.new(change, keyspace, name, target, arguments)
             when 'STATUS_CHANGE'
@@ -269,14 +338,16 @@ module Cassandra
             when 'TOPOLOGY_CHANGE'
               TopologyChangeEventResponse.new(buffer.read_string, *buffer.read_inet)
             else
-              raise Errors::DecodingError, "Unsupported event type: #{event_type.inspect}"
+              raise Errors::DecodingError,
+                    "Unsupported event type: #{event_type.inspect}"
             end
           when 0x0E # AUTH_CHALLENGE
             AuthChallengeResponse.new(buffer.read_bytes)
           when 0x10 # AUTH_SUCCESS
             AuthSuccessResponse.new(buffer.read_bytes)
           else
-            raise Errors::DecodingError, "Unsupported response opcode: #{opcode.inspect}"
+            raise Errors::DecodingError,
+                  "Unsupported response opcode: #{opcode.inspect}"
           end
         end
       end