cassandra-driver 1.0.0.beta.2-java

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

@@ -0,0 +1,34 @@
+# 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 TopologyChangeEventResponse < StatusChangeEventResponse
+      TYPE = 'TOPOLOGY_CHANGE'.freeze
+
+      def initialize(*args)
+        super
+        @type = TYPE
+      end
+
+      private
+
+      EVENT_TYPES[TYPE] = self
+    end
+  end
+end

data/lib/cassandra/protocol/responses/void_result_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 VoidResultResponse < ResultResponse
+      def self.decode(protocol_version, buffer, length, trace_id=nil)
+        new(trace_id)
+      end
+
+      def to_s
+        %(RESULT VOID)
+      end
+
+      def void?
+        true
+      end
+
+      private
+
+      RESULT_TYPES[0x01] = self
+    end
+  end
+end

data/lib/cassandra/protocol/type_converter.rb

@@ -0,0 +1,384 @@
+# 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 TypeConverter
+      def initialize
+        @from_bytes_converters = from_bytes_converters
+        @to_bytes_converters = to_bytes_converters
+      end
+
+      def from_bytes(buffer, type, size_bytes=4)
+        return nil if buffer.empty?
+        case type
+        when Array
+          return nil unless read_size(buffer, size_bytes)
+          case type.first
+          when :list
+            bytes_to_list(buffer, @from_bytes_converters[type[1]])
+          when :map
+            bytes_to_map(buffer, @from_bytes_converters[type[1]], @from_bytes_converters[type[2]])
+          when :set
+            bytes_to_set(buffer, @from_bytes_converters[type[1]])
+          end
+        else
+          @from_bytes_converters[type].call(buffer, size_bytes)
+        end
+      end
+
+      def to_bytes(buffer, type, value, size_bytes=4)
+        case type
+        when Array
+          unless value.nil? || value.is_a?(Enumerable)
+            raise InvalidValueError, 'Value for collection must be enumerable'
+          end
+          case type.first
+          when :list, :set
+            _, sub_type = type
+            if value
+              raw = CqlByteBuffer.new
+              raw.append_short(value.size)
+              value.each do |element|
+                to_bytes(raw, sub_type, element, 2)
+              end
+              buffer.append_bytes(raw)
+            else
+              nil_to_bytes(buffer, size_bytes)
+            end
+          when :map
+            _, key_type, value_type = type
+            if value
+              raw = CqlByteBuffer.new
+              raw.append_short(value.size)
+              value.each do |key, value|
+                to_bytes(raw, key_type, key, 2)
+                to_bytes(raw, value_type, value, 2)
+              end
+              buffer.append_bytes(raw)
+            else
+              nil_to_bytes(buffer, size_bytes)
+            end
+          else
+            raise UnsupportedColumnTypeError, %(Unsupported column collection type: #{type.first})
+          end
+        else
+          converter = @to_bytes_converters[type]
+          unless converter
+            raise UnsupportedColumnTypeError, %(Unsupported column type: #{type})
+          end
+          converter.call(buffer, value, size_bytes)
+        end
+      rescue TypeError => e
+        raise TypeError, %("#{value}" cannot be encoded as #{type.to_s.upcase}: #{e.message}), e.backtrace
+      end
+
+      private
+
+      def from_bytes_converters
+        {
+          :ascii => method(:bytes_to_ascii),
+          :bigint => method(:bytes_to_bigint),
+          :blob => method(:bytes_to_blob),
+          :boolean => method(:bytes_to_boolean),
+          :counter => method(:bytes_to_bigint),
+          :decimal => method(:bytes_to_decimal),
+          :double => method(:bytes_to_double),
+          :float => method(:bytes_to_float),
+          :int => method(:bytes_to_int),
+          :timestamp => method(:bytes_to_timestamp),
+          :varchar => method(:bytes_to_varchar),
+          :text => method(:bytes_to_varchar),
+          :varint => method(:bytes_to_varint),
+          :timeuuid => method(:bytes_to_timeuuid),
+          :uuid => method(:bytes_to_uuid),
+          :inet => method(:bytes_to_inet),
+        }
+      end
+
+      def to_bytes_converters
+        {
+          :ascii => method(:ascii_to_bytes),
+          :bigint => method(:bigint_to_bytes),
+          :blob => method(:blob_to_bytes),
+          :boolean => method(:boolean_to_bytes),
+          :counter => method(:bigint_to_bytes),
+          :decimal => method(:decimal_to_bytes),
+          :double => method(:double_to_bytes),
+          :float => method(:float_to_bytes),
+          :inet => method(:inet_to_bytes),
+          :int => method(:int_to_bytes),
+          :text => method(:varchar_to_bytes),
+          :varchar => method(:varchar_to_bytes),
+          :timestamp => method(:timestamp_to_bytes),
+          :timeuuid => method(:uuid_to_bytes),
+          :uuid => method(:uuid_to_bytes),
+          :varint => method(:varint_to_bytes),
+        }
+      end
+
+      def read_size(buffer, size_bytes)
+        if size_bytes == 2
+          size = buffer.read_short
+          return nil if size & 0x8000 == 0x8000
+        else
+          size = buffer.read_signed_int
+          return nil if size & 0x80000000 == 0x80000000
+        end
+        size
+      end
+
+      def bytes_to_ascii(buffer, size_bytes)
+        bytes = size_bytes == 4 ? buffer.read_bytes : buffer.read_short_bytes
+        bytes ? bytes.force_encoding(::Encoding::ASCII) : nil
+      end
+
+      def bytes_to_bigint(buffer, size_bytes)
+        return nil unless read_size(buffer, size_bytes)
+        buffer.read_long
+      end
+
+      def bytes_to_blob(buffer, size_bytes)
+        bytes = size_bytes == 4 ? buffer.read_bytes : buffer.read_short_bytes
+        bytes ? bytes : nil
+      end
+
+      def bytes_to_boolean(buffer, size_bytes)
+        return nil unless read_size(buffer, size_bytes)
+        buffer.read(1) == Constants::TRUE_BYTE
+      end
+
+      def bytes_to_decimal(buffer, size_bytes)
+        size = read_size(buffer, size_bytes)
+        return nil unless size
+        buffer.read_decimal(size)
+      end
+
+      def bytes_to_double(buffer, size_bytes)
+        return nil unless read_size(buffer, size_bytes)
+        buffer.read_double
+      end
+
+      def bytes_to_float(buffer, size_bytes)
+        return nil unless read_size(buffer, size_bytes)
+        buffer.read_float
+      end
+
+      def bytes_to_int(buffer, size_bytes)
+        return nil unless read_size(buffer, size_bytes)
+        buffer.read_signed_int
+      end
+
+      def bytes_to_timestamp(buffer, size_bytes)
+        return nil unless read_size(buffer, size_bytes)
+        timestamp = buffer.read_long
+        Time.at(timestamp/1000.0)
+      end
+
+      def bytes_to_varchar(buffer, size_bytes)
+        bytes = size_bytes == 4 ? buffer.read_bytes : buffer.read_short_bytes
+        bytes ? bytes.force_encoding(::Encoding::UTF_8) : nil
+      end
+
+      def bytes_to_varint(buffer, size_bytes)
+        size = read_size(buffer, size_bytes)
+        return nil unless size
+        buffer.read_varint(size)
+      end
+
+      def bytes_to_uuid(buffer, size_bytes)
+        return nil unless read_size(buffer, size_bytes)
+        buffer.read_uuid
+      end
+
+      def bytes_to_timeuuid(buffer, size_bytes)
+        return nil unless read_size(buffer, size_bytes)
+        buffer.read_uuid(TimeUuid)
+      end
+
+      def bytes_to_inet(buffer, size_bytes)
+        size = read_size(buffer, size_bytes)
+        return nil unless size
+        IPAddr.new_ntoh(buffer.read(size))
+      end
+
+      def bytes_to_list(buffer, value_converter)
+        list = []
+        size = buffer.read_short
+        size.times do
+          list << value_converter.call(buffer, 2)
+        end
+        list
+      end
+
+      def bytes_to_map(buffer, key_converter, value_converter)
+        map = {}
+        size = buffer.read_short
+        size.times do
+          key = key_converter.call(buffer, 2)
+          value = value_converter.call(buffer, 2)
+          map[key] = value
+        end
+        map
+      end
+
+      def bytes_to_set(buffer, value_converter)
+        set = Set.new
+        size = buffer.read_short
+        size.times do
+          set << value_converter.call(buffer, 2)
+        end
+        set
+      end
+
+      def ascii_to_bytes(buffer, value, size_bytes)
+        v = value && value.encode(::Encoding::ASCII)
+        if size_bytes == 4
+          buffer.append_bytes(v)
+        else
+          buffer.append_short_bytes(v)
+        end
+      end
+
+      def bigint_to_bytes(buffer, value, size_bytes)
+        if value
+          size_to_bytes(buffer, 8, size_bytes)
+          buffer.append_long(value)
+        else
+          nil_to_bytes(buffer, size_bytes)
+        end
+      end
+
+      def blob_to_bytes(buffer, value, size_bytes)
+        v = value && value.encode(::Encoding::BINARY)
+        if size_bytes == 4
+          buffer.append_bytes(v)
+        else
+          buffer.append_short_bytes(v)
+        end
+      end
+
+      def boolean_to_bytes(buffer, value, size_bytes)
+        if !value.nil?
+          size_to_bytes(buffer, 1, size_bytes)
+          buffer.append(value ? Constants::TRUE_BYTE : Constants::FALSE_BYTE)
+        else
+          nil_to_bytes(buffer, size_bytes)
+        end
+      end
+
+      def decimal_to_bytes(buffer, value, size_bytes)
+        raw = value && CqlByteBuffer.new.append_decimal(value)
+        if size_bytes == 4
+          buffer.append_bytes(raw)
+        else
+          buffer.append_short_bytes(raw)
+        end
+      end
+
+      def double_to_bytes(buffer, value, size_bytes)
+        if value
+          size_to_bytes(buffer, 8, size_bytes)
+          buffer.append_double(value)
+        else
+          nil_to_bytes(buffer, size_bytes)
+        end
+      end
+
+      def float_to_bytes(buffer, value, size_bytes)
+        if value
+          size_to_bytes(buffer, 4, size_bytes)
+          buffer.append_float(value)
+        else
+          nil_to_bytes(buffer, size_bytes)
+        end
+      end
+
+      def inet_to_bytes(buffer, value, size_bytes)
+        if value
+          size_to_bytes(buffer, value.ipv6? ? 16 : 4, size_bytes)
+          buffer.append(value.hton)
+        else
+          nil_to_bytes(buffer, size_bytes)
+        end
+      end
+
+      def int_to_bytes(buffer, value, size_bytes)
+        if value
+          size_to_bytes(buffer, 4, size_bytes)
+          buffer.append_int(value)
+        else
+          nil_to_bytes(buffer, size_bytes)
+        end
+      end
+
+      def varchar_to_bytes(buffer, value, size_bytes)
+        v = value && value.encode(::Encoding::UTF_8)
+        if size_bytes == 4
+          buffer.append_bytes(v)
+        else
+          buffer.append_short_bytes(v)
+        end
+      end
+
+      def timestamp_to_bytes(buffer, value, size_bytes)
+        if value
+          ms = (value.to_f * 1000).to_i
+          size_to_bytes(buffer, 8, size_bytes)
+          buffer.append_long(ms)
+        else
+          nil_to_bytes(buffer, size_bytes)
+        end
+      end
+
+      def uuid_to_bytes(buffer, value, size_bytes)
+        if value
+          size_to_bytes(buffer, 16, size_bytes)
+          buffer.append_uuid(value)
+        else
+          nil_to_bytes(buffer, size_bytes)
+        end
+      end
+
+      def varint_to_bytes(buffer, value, size_bytes)
+        raw = value && CqlByteBuffer.new.append_varint(value)
+        if size_bytes == 4
+          buffer.append_bytes(raw)
+        else
+          buffer.append_short_bytes(raw)
+        end
+      end
+
+      def size_to_bytes(buffer, size, size_bytes)
+        if size_bytes == 4
+          buffer.append_int(size)
+        else
+          buffer.append_short(size)
+        end
+      end
+
+      def nil_to_bytes(buffer, size_bytes)
+        if size_bytes == 4
+          buffer.append_int(-1)
+        else
+          buffer.append_short(-1)
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/protocol.rb

@@ -0,0 +1,93 @@
+# 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
+  # @private
+  ProtocolError = Class.new(Error)
+
+  # @private
+  module Protocol
+    DecodingError = Class.new(ProtocolError)
+    EncodingError = Class.new(ProtocolError)
+    InvalidStreamIdError = Class.new(ProtocolError)
+    InvalidValueError = Class.new(ProtocolError)
+    UnsupportedOperationError = Class.new(ProtocolError)
+    UnsupportedFrameTypeError = Class.new(ProtocolError)
+    UnsupportedResultKindError = Class.new(ProtocolError)
+    UnsupportedColumnTypeError = Class.new(ProtocolError)
+    UnsupportedEventTypeError = Class.new(ProtocolError)
+    UnsupportedFeatureError = Class.new(ProtocolError)
+    UnexpectedCompressionError = Class.new(ProtocolError)
+    UnmaterializedRowsError = Class.new(ProtocolError)
+
+    module Formats
+      CHAR_FORMAT = 'c'.freeze
+      DOUBLE_FORMAT = 'G'.freeze
+      FLOAT_FORMAT = 'g'.freeze
+      INT_FORMAT = 'N'.freeze
+      SHORT_FORMAT = 'n'.freeze
+
+      BYTES_FORMAT = 'C*'.freeze
+      TWO_INTS_FORMAT = 'NN'.freeze
+      HEADER_FORMAT = 'c4N'.freeze
+    end
+
+    module Constants
+      TRUE_BYTE = "\x01".freeze
+      FALSE_BYTE = "\x00".freeze
+      PROTOCOL_VERSION = "\x01".freeze
+      COMPRESSION_OFF = "\x00".freeze
+    end
+  end
+end
+
+require 'cassandra/protocol/cql_byte_buffer'
+require 'cassandra/protocol/type_converter'
+require 'cassandra/protocol/response'
+require 'cassandra/protocol/responses/auth_challenge_response'
+require 'cassandra/protocol/responses/auth_success_response'
+require 'cassandra/protocol/responses/error_response'
+require 'cassandra/protocol/responses/detailed_error_response'
+require 'cassandra/protocol/responses/ready_response'
+require 'cassandra/protocol/responses/authenticate_response'
+require 'cassandra/protocol/responses/supported_response'
+require 'cassandra/protocol/responses/result_response'
+require 'cassandra/protocol/responses/void_result_response'
+require 'cassandra/protocol/responses/rows_result_response'
+require 'cassandra/protocol/responses/raw_rows_result_response'
+require 'cassandra/protocol/responses/set_keyspace_result_response'
+require 'cassandra/protocol/responses/prepared_result_response'
+require 'cassandra/protocol/responses/schema_change_result_response'
+require 'cassandra/protocol/responses/event_response'
+require 'cassandra/protocol/responses/schema_change_event_response'
+require 'cassandra/protocol/responses/status_change_event_response'
+require 'cassandra/protocol/responses/topology_change_event_response'
+require 'cassandra/protocol/request'
+require 'cassandra/protocol/requests/auth_response_request'
+require 'cassandra/protocol/requests/batch_request'
+require 'cassandra/protocol/requests/startup_request'
+require 'cassandra/protocol/requests/credentials_request'
+require 'cassandra/protocol/requests/options_request'
+require 'cassandra/protocol/requests/register_request'
+require 'cassandra/protocol/requests/query_request'
+require 'cassandra/protocol/requests/void_query_request'
+require 'cassandra/protocol/requests/prepare_request'
+require 'cassandra/protocol/requests/execute_request'
+require 'cassandra/protocol/frame_encoder'
+require 'cassandra/protocol/frame_decoder'
+require 'cassandra/protocol/cql_protocol_handler'

data/lib/cassandra/reconnection/policies/constant.rb

@@ -0,0 +1,48 @@
+# 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 Reconnection
+    module Policies
+      # A reconnection policy that returns a constant reconnection interval
+      class Constant < Policy
+        # @private
+        class Schedule
+          def initialize(interval)
+            @interval = interval
+          end
+
+          def next
+            @interval
+          end
+        end
+
+        # @param interval [Numeric] reconnection interval (in seconds)
+        def initialize(interval)
+          @schedule = Schedule.new(Float(interval))
+        end
+
+        # @return [Cassandra::Reconnection::Schedule] reconnection schedule
+        #   with constant interval
+        def schedule
+          @schedule
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/reconnection/policies/exponential.rb

@@ -0,0 +1,79 @@
+# 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 Reconnection
+    module Policies
+      # A reconnection policy that returns a constant exponentially growing
+      # reconnection interval up to a given maximum
+      class Exponential < Policy
+        # @private
+        class Schedule
+          def initialize(start, max, exponent)
+            @interval = start
+            @max      = max
+            @exponent = exponent
+          end
+
+          def next
+            @interval.tap { backoff if @interval < @max }
+          end
+
+          private
+
+          def backoff
+            new_interval = @interval * @exponent
+
+            if new_interval >= @max
+              @interval = @max
+            else
+              @interval = new_interval
+            end
+          end
+        end
+
+        # @param start    [Numeric] beginning interval
+        # @param max      [Numeric] maximum reconnection interval
+        # @param exponent [Numeric] (2) interval exponent to use
+        #
+        # @example Using this policy
+        #   policy   = Cassandra::Reconnection::Policies::Exponential.new(0.5, 10, 2)
+        #   schedule = policy.schedule
+        #   schedule.next # 0.5
+        #   schedule.next # 1.0
+        #   schedule.next # 2.0
+        #   schedule.next # 4.0
+        #   schedule.next # 8.0
+        #   schedule.next # 10.0
+        #   schedule.next # 10.0
+        #   schedule.next # 10.0
+        def initialize(start, max, exponent = 2)
+          @start    = start
+          @max      = max
+          @exponent = exponent
+        end
+
+        # @return [Cassandra::Reconnection::Schedule] an exponential
+        #   reconnection schedule
+        def schedule
+          Schedule.new(@start, @max, @exponent)
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/reconnection/policies.rb

@@ -0,0 +1,20 @@
+# 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.
+#++
+
+require 'cassandra/reconnection/policies/constant'
+require 'cassandra/reconnection/policies/exponential'