cassandra-driver 1.2.0-java → 2.0.0-java

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

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+module Cassandra
+  module Protocol
+    class UnpreparedErrorResponse < ErrorResponse
+      attr_reader :id
+
+      def initialize(code, message, id)
+        super(code, message)
+
+        @id = id
+      end
+
+      def to_error(statement = nil)
+        Errors::UnpreparedError.new(@message, statement, @id)
+      end
+
+      def to_s
+        "#{super} #{@id}"
+      end
+    end
+  end
+end

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

@@ -19,10 +19,6 @@
 module Cassandra
   module Protocol
     class VoidResultResponse < ResultResponse
-      def self.decode(protocol_version, buffer, length, trace_id=nil)
-        new(trace_id)
-      end
-
       def to_s
         %(RESULT VOID)
       end

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

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+module Cassandra
+  module Protocol
+    class WriteTimeoutErrorResponse < ErrorResponse
+      attr_reader :consistency, :received, :blockfor, :write_type
+
+      def initialize(code, message, consistency, received, blockfor, write_type)
+        super(code, message)
+
+        write_type.downcase!
+
+        @consistency = consistency
+        @received    = received
+        @blockfor    = blockfor
+        @write_type  = write_type.to_sym
+      end
+
+      def to_error(statement = nil)
+        Errors::WriteTimeoutError.new(@message, statement, @write_type, @consistency, @blockfor, @received)
+      end
+
+      def to_s
+        "#{super} #{@write_type} #{@consistency} #{@blockfor} #{@received}"
+      end
+    end
+  end
+end

data/lib/cassandra/protocol/v1.rb

@@ -0,0 +1,238 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2014 DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+module Cassandra
+  module Protocol
+    module V1
+      class Encoder
+        HEADER_FORMAT = 'c4N'.freeze
+
+        def initialize(compressor = nil, protocol_version = 1)
+          @compressor       = compressor
+          @protocol_version = protocol_version
+        end
+
+        def encode(buffer, request, stream_id)
+          flags = request.trace? ? 2 : 0
+          body  = request.write(CqlByteBuffer.new, @protocol_version, self)
+
+          if @compressor && request.compressable? && @compressor.compress?(body)
+            flags |= 1
+            body   = @compressor.compress(body)
+          end
+
+          header  = [@protocol_version, flags, stream_id, request.opcode, body.bytesize]
+          buffer << header.pack(HEADER_FORMAT)
+          buffer << body
+          buffer
+        end
+
+        def write_parameters(buffer, params, types)
+          Coder.write_values_v1(buffer, params, types)
+        end
+      end
+
+      class Decoder
+        def initialize(handler, compressor = nil)
+          @handler    = handler
+          @compressor = compressor
+          @state      = :header
+          @header     = nil
+          @length     = nil
+          @buffer     = CqlByteBuffer.new
+        end
+
+        def <<(data)
+          @buffer << data
+
+          __send__(:"decode_#{@state}", @buffer)
+        end
+
+        private
+
+        READY = ReadyResponse.new
+
+        def decode_header(buffer)
+          loop do
+            buffer_length = buffer.length
+
+            return if buffer_length < 8
+
+            frame_header = buffer.read_int
+            frame_length = buffer.read_int
+
+            if (buffer_length - 8) < frame_length
+              @header = frame_header
+              @length = frame_length
+              @state  = :body
+
+              return
+            end
+
+            actual_decode(buffer, frame_header, frame_length)
+          end
+
+          nil
+        end
+
+        def decode_body(buffer)
+          frame_header = @header
+          frame_length = @length
+
+          loop do
+            buffer_length = buffer.length
+
+            return if buffer_length < frame_length
+
+            actual_decode(buffer, frame_header, frame_length)
+
+            if (buffer_length - frame_length) < 8
+              @header = nil
+              @length = nil
+              @state  = :header
+
+              return
+            end
+
+            frame_header = buffer.read_int
+            frame_length = buffer.read_int
+          end
+
+          @header = frame_header
+          @length = frame_length
+
+          nil
+        end
+
+        def actual_decode(buffer, fields, size)
+          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
+            if @compressor
+              buffer = CqlByteBuffer.new(@compressor.decompress(buffer.read(size)))
+              size   = buffer.size
+            else
+              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
+
+          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
+
+          if stream_id == -1
+            @handler.notify_event_listeners(response)
+          else
+            @handler.complete_request(stream_id, response)
+          end
+        end
+
+        CODE_ERROR          = 0x00
+        CODE_READY          = 0x02
+        CODE_AUTHENTICATE   = 0x03
+        CODE_SUPPORTED      = 0x06
+        CODE_RESULT         = 0x08
+        CODE_EVENT          = 0x0c
+        CODE_AUTH_CHALLENGE = 0x0e
+        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)
+          when CODE_ERROR
+            code    = buffer.read_int
+            message = buffer.read_string
+
+            case code
+            when 0x1000 then UnavailableErrorResponse.new(code, message, buffer.read_consistency, buffer.read_int, buffer.read_int)
+            when 0x1100 then WriteTimeoutErrorResponse.new(code, message, buffer.read_consistency, buffer.read_int, buffer.read_int, buffer.read_string)
+            when 0x1200 then ReadTimeoutErrorResponse.new(code, message, buffer.read_consistency, buffer.read_int, buffer.read_int, (buffer.read_byte != 0))
+            when 0x2400 then AlreadyExistsErrorResponse.new(code, message, buffer.read_string, buffer.read_string)
+            when 0x2500 then UnpreparedErrorResponse.new(code, message, buffer.read_short_bytes)
+            else
+              ErrorResponse.new(code, message)
+            end
+          when CODE_RESULT
+            result_type = buffer.read_int
+            case result_type
+            when 0x0001 # Void
+              VoidResultResponse.new(trace_id)
+            when 0x0002 # Rows
+              original_buffer_length = buffer.length
+              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(protocol_version, remaining_bytes, paging_state, trace_id)
+              else
+                RowsResultResponse.new(Coder.read_values_v1(buffer, column_specs), column_specs, paging_state, trace_id)
+              end
+            when 0x0003 # SetKeyspace
+              SetKeyspaceResultResponse.new(buffer.read_string, trace_id)
+            when 0x0004 # Prepared
+              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(id, params_metadata, result_metadata, trace_id)
+            when 0x0005 # SchemaChange
+              SchemaChangeResultResponse.new(buffer.read_string, buffer.read_string, buffer.read_string, trace_id)
+            else
+              raise Errors::DecodingError, "Unsupported result type: #{result_type.inspect}"
+            end
+          when CODE_EVENT
+            event_type = buffer.read_string
+            case event_type
+            when 'SCHEMA_CHANGE'
+              SchemaChangeEventResponse.new(buffer.read_string, buffer.read_string, buffer.read_string)
+            when 'STATUS_CHANGE'
+              StatusChangeEventResponse.new(buffer.read_string, *buffer.read_inet)
+            when 'TOPOLOGY_CHANGE'
+              TopologyChangeEventResponse.new(buffer.read_string, *buffer.read_inet)
+            else
+              raise Errors::DecodingError, "Unsupported event type: #{event_type.inspect}"
+            end
+          else
+            raise Errors::DecodingError, "Unsupported response opcode: #{opcode.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/session.rb

@@ -33,14 +33,14 @@ module Cassandra
       @futures = futures_factory
     end
 
+    # @!method execute_async(statement, options = nil)
     # Executes a given statement and returns a future result
-    # @!method execute_async(statement, *args, options = {})
     #
     # @param statement [String, Cassandra::Statements::Simple,
     #   Cassandra::Statements::Bound, Cassandra::Statements::Prepared]
     #   statement to execute
-    # @param args [*Object] arguments to paramterized query or prepared
-    #   statement
+    #
+    # @param options [nil, Hash] a customizable set of options
     #
     # @option options [Symbol] :consistency consistency level for the request.
     #   Must be one of {Cassandra::CONSISTENCIES}
@@ -56,35 +56,66 @@ module Cassandra
     # @option options [String] :paging_state (nil) this option is used for
     #   stateless paging, where result paging is resumed some time after the
     #   initial request.
+    # @option options [Array] :arguments (nil) positional arguments for the
+    #   statement.
+    #
+    # @overload execute_async(statement, *args, options = nil)
+    #   Executes a statement using the deprecated splat-style way of passing
+    #   positional arguments/
+    #
+    #   @deprecated This style will soon be removed, use the `:arguments`
+    #     option to provide positional arguments instead.
+    #
+    #   @param statement [String, Cassandra::Statements::Simple,
+    #     Cassandra::Statements::Bound, Cassandra::Statements::Prepared]
+    #     statement to execute
+    #
+    #   @param args [*Object] **this style of positional arguments is
+    #     deprecated, please use the `:arguments` options instead** -
+    #     positional arguments to paramterized query or prepared statement.
+    #
+    #   @param options [nil, Hash] a customizable set of options
+    #
+    #   @note Last argument will be treated as `options` if it is a {Hash}.
+    #     Therefore, make sure to pass empty `options` when executing a
+    #     statement with the last parameter required to be a map datatype.
     #
     # @see Cassandra.cluster Options that can be specified on the cluster-level
     #   and their default values.
     #
-    # @note Last argument will be treated as `options` if it is a {Hash}.
-    #   Therefore, make sure to pass empty `options` when executing a statement
-    #   with the last parameter required to be a map datatype.
-    #
-    # @note Positional arguments are only supported on Apache Cassandra 2.0 and
-    #   above.
+    # @note Positional arguments for simple statements are only supported on
+    #   starting with Apache Cassandra 2.0 and above.
     #
     # @return [Cassandra::Future<Cassandra::Result>]
     #
     # @see Cassandra::Session#execute A list of errors this future can be
     #   resolved with
     def execute_async(statement, *args)
-      if args.last.is_a?(::Hash)
-        options = @options.override(args.pop)
+      options = nil
+      options = args.pop if args.last.is_a?(::Hash)
+
+      unless args.empty?
+        ::Kernel.warn "[WARNING] Splat style (*args) positional arguments " \
+                      "are deprecated, use the :arguments option instead, " \
+                      "called from #{caller.first}"
+
+        options ||= {}
+        options[:arguments] = args
+      end
+
+      if options
+        options = @options.override(options)
       else
         options = @options
       end
 
       case statement
       when ::String
-        @client.query(Statements::Simple.new(statement, *args), options)
+        @client.query(Statements::Simple.new(statement, options.arguments), options)
       when Statements::Simple
         @client.query(statement, options)
       when Statements::Prepared
-        @client.execute(statement.bind(*args), options)
+        @client.execute(statement.bind(options.arguments), options)
       when Statements::Bound
         @client.execute(statement, options)
       when Statements::Batch
@@ -92,10 +123,40 @@ module Cassandra
       else
         @futures.error(::ArgumentError.new("unsupported statement #{statement.inspect}"))
       end
+    rescue => e
+      @futures.error(e)
     end
 
+    # @!method execute(statement, options = nil)
     # A blocking wrapper around {Cassandra::Session#execute_async}
-    # @!method execute(statement, *args, options = {})
+    #
+    # @param statement [String, Cassandra::Statements::Simple,
+    #   Cassandra::Statements::Bound, Cassandra::Statements::Prepared]
+    #   statement to execute
+    #
+    # @param options [nil, Hash] a customizable set of options
+    #
+    # @overload execute(statement, *args, options = nil)
+    #   Executes a statement using the deprecated splat-style way of passing
+    #   positional arguments/
+    #
+    #   @deprecated This style will soon be removed, use the `:arguments`
+    #     option to provide positional arguments instead.
+    #
+    #   @param statement [String, Cassandra::Statements::Simple,
+    #     Cassandra::Statements::Bound, Cassandra::Statements::Prepared]
+    #     statement to execute
+    #
+    #   @param args [*Object] **this style of positional arguments is
+    #     deprecated, please use the `:arguments` options instead** -
+    #     positional arguments to paramterized query or prepared statement.
+    #
+    #   @param options [nil, Hash] a customizable set of options
+    #
+    #   @note Last argument will be treated as `options` if it is a {Hash}.
+    #     Therefore, make sure to pass empty `options` when executing a
+    #     statement with the last parameter required to be a map datatype.
+    #
     # @see Cassandra::Session#execute_async
     # @see Cassandra::Future#get
     #
@@ -105,8 +166,24 @@ module Cassandra
     # @raise [Cassandra::Errors::ValidationError] if Cassandra fails to validate
     # @raise [Cassandra::Errors::TimeoutError] if request has not completed
     #   within the `:timeout` given
-    def execute(*args)
-      execute_async(*args).get
+    def execute(statement, *args)
+      options = nil
+      options = args.pop if args.last.is_a?(::Hash)
+
+      unless args.empty?
+        ::Kernel.warn "[WARNING] Splat style (*args) positional arguments " \
+                      "are deprecated, use the :arguments option instead, " \
+                      "called from #{caller.first}"
+
+        options ||= {}
+        options[:arguments] = args
+      end
+
+      if options
+        execute_async(statement, options).get
+      else
+        execute_async(statement).get
+      end
     end
 
     # Prepares a given statement and returns a future prepared statement
@@ -135,6 +212,8 @@ module Cassandra
       else
         @futures.error(::ArgumentError.new("unsupported statement #{statement.inspect}"))
       end
+    rescue => e
+      @futures.error(e)
     end
 
     # A blocking wrapper around {Cassandra::Session#prepare_async}