yugabyte-ycql-driver 3.2.3.1

data/lib/cassandra/protocol/cql_byte_buffer.rb

@@ -0,0 +1,418 @@
+# encoding: utf-8
+
+#--
+# Copyright 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 CqlByteBuffer < Ione::ByteBuffer
+      # @private
+      MINUS = '-'.freeze
+      # @private
+      ZERO = '0'.freeze
+      # @private
+      DECIMAL_POINT = '.'.freeze
+      # @private
+      FLOAT_STRING_FORMAT = 'F'.freeze
+      # @private
+      NO_CHAR = ''.freeze
+
+      def inspect
+        "#<#{self.class.name}:0x#{object_id.to_s(16)} #{to_str.inspect}>"
+      end
+
+      def read_unsigned_byte
+        read_byte
+      rescue RangeError => e
+        raise Errors::DecodingError, e.message, e.backtrace
+      end
+
+      def read_varint(len = bytesize, signed = true)
+        bytes = read(len)
+        n = 0
+        bytes.each_byte do |b|
+          n = (n << 8) | b
+        end
+        n -= 2**(bytes.length * 8) if signed && bytes.getbyte(0) & 0x80 == 0x80
+        n
+      rescue RangeError => e
+        raise Errors::DecodingError, e.message, e.backtrace
+      end
+
+      def read_decimal(len = bytesize)
+        scale = read_signed_int
+        number_string = read_varint(len - 4).to_s
+        if scale <= 0
+          # Special case where the actual scale is positive; scale in the protocol is actually negative of
+          # reality.
+          BigDecimal.new(number_string + '0' * -scale)
+        else
+          if number_string.length <= scale
+            if number_string.start_with?(MINUS)
+              number_string = number_string[1, number_string.length - 1]
+              fraction_string = MINUS + ZERO << DECIMAL_POINT
+            else
+              fraction_string = ZERO + DECIMAL_POINT
+            end
+            (scale - number_string.length).times { fraction_string << ZERO }
+            fraction_string << number_string
+          else
+            fraction_string = number_string[0, number_string.length - scale]
+            fraction_string << DECIMAL_POINT
+            fraction_string <<
+              number_string[number_string.length - scale, number_string.length]
+          end
+          BigDecimal.new(fraction_string)
+        end
+      rescue Errors::DecodingError => e
+        raise Errors::DecodingError, e.message, e.backtrace
+      end
+
+      def read_long
+        top, bottom = read(8).unpack(Formats::TWO_INTS_FORMAT)
+        return (top << 32) | bottom if top <= 0x7fffffff
+        top ^= 0xffffffff
+        bottom ^= 0xffffffff
+        -((top << 32) | bottom) - 1
+      rescue RangeError => e
+        raise Errors::DecodingError, e.message, e.backtrace
+      end
+
+      def read_double
+        read(8).unpack(Formats::DOUBLE_FORMAT).first
+      rescue RangeError => e
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a double: #{e.message}", e.backtrace
+      end
+
+      def read_double_le
+        read(8).unpack(Formats::DOUBLE_FORMAT_LE).first
+      rescue RangeError => e
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a double: #{e.message}", e.backtrace
+      end
+
+      def read_float
+        read(4).unpack(Formats::FLOAT_FORMAT).first
+      rescue RangeError => e
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a float: #{e.message}", e.backtrace
+      end
+
+      def read_signed_int
+        n = read_int
+        return n if n <= 0x7fffffff
+        n - 0xffffffff - 1
+      rescue RangeError => e
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode an int: #{e.message}", e.backtrace
+      end
+
+      def read_unsigned_int_le
+        read(4).unpack(Formats::INT_FORMAT_LE).first
+      rescue RangeError => e
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode an int: #{e.message}", e.backtrace
+      end
+
+      def read_unsigned_short
+        read_short
+      rescue RangeError => e
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a short: #{e.message}", e.backtrace
+      end
+
+      def read_unsigned_short_le
+        read(2).unpack(Formats::SHORT_FORMAT_LE).first
+      rescue RangeError => e
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a short: #{e.message}", e.backtrace
+      end
+
+      def read_string
+        length = read_unsigned_short
+        string = read(length)
+        string.force_encoding(::Encoding::UTF_8)
+        string
+      rescue RangeError => e
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a string: #{e.message}", e.backtrace
+      end
+
+      def read_long_string
+        length = read_signed_int
+        string = read(length)
+        string.force_encoding(::Encoding::UTF_8)
+        string
+      rescue RangeError => e
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a long string: #{e.message}",
+              e.backtrace
+      end
+
+      def read_uuid(impl = Uuid)
+        impl.new(read_varint(16, false))
+      rescue Errors::DecodingError => e
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a UUID: #{e.message}", e.backtrace
+      end
+
+      def read_string_list
+        size = read_unsigned_short
+        Array.new(size) { read_string }
+      end
+
+      def read_bytes
+        size = read_signed_int
+        return nil if size & 0x80000000 == 0x80000000
+        read(size)
+      rescue RangeError => e
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a bytes: #{e.message}", e.backtrace
+      end
+
+      def read_short_bytes
+        read(read_unsigned_short)
+      rescue RangeError => e
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a short bytes: #{e.message}",
+              e.backtrace
+      end
+
+      def read_option
+        id = read_unsigned_short
+        value = nil
+        value = yield id, self if block_given?
+        [id, value]
+      end
+
+      def read_inet
+        size = read_byte
+        ip_addr = IPAddr.new_ntoh(read(size))
+        port = read_int
+        [ip_addr, port]
+      rescue RangeError => e
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode an INET: #{e.message}",
+              e.backtrace
+      end
+
+      def read_inet_addr
+        size = read_byte
+        IPAddr.new_ntoh(read(size))
+      rescue RangeError => e
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode an INET addr: #{e.message}",
+              e.backtrace
+      end
+
+      def read_consistency
+        index = read_unsigned_short
+        if index >= CONSISTENCIES.size || CONSISTENCIES[index].nil?
+          raise Errors::DecodingError, "Unknown consistency index #{index}"
+        end
+        CONSISTENCIES[index]
+      end
+
+      def read_string_map
+        map = {}
+        map_size = read_unsigned_short
+        map_size.times do
+          key = read_string
+          map[key] = read_string
+        end
+        map
+      end
+
+      def read_bytes_map
+        map = {}
+        map_size = read_unsigned_short
+        map_size.times do
+          key = read_string
+          map[key] = read_bytes
+        end
+        map
+      end
+
+      def read_reason_map
+        # reason_map is new in v5. Starts with an int indicating the number of key-value pairs, followed by
+        # the key-value pairs. Keys are inet's, values are short int's.
+        map = {}
+        map_size = read_int
+        map_size.times do
+          key = read_inet_addr
+          map[key] = read_short
+        end
+        map
+      end
+
+      def read_string_multimap
+        map = {}
+        map_size = read_unsigned_short
+        map_size.times do
+          key = read_string
+          map[key] = read_string_list
+        end
+        map
+      end
+
+      def read_smallint
+        n = read_short
+        return n if n <= 0x7fff
+        n - 0xffff - 1
+      rescue RangeError => e
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a smallint: #{e.message}", e.backtrace
+      end
+
+      def read_tinyint
+        n = read_byte
+        return n if n <= 0x7f
+        n - 0xff - 1
+      rescue RangeError => e
+        raise Errors::DecodingError,
+              "Not enough bytes available to decode a tinyint: #{e.message}", e.backtrace
+      end
+
+      def append_tinyint(n)
+        append([n].pack(Formats::CHAR_FORMAT))
+      end
+
+      def append_smallint(n)
+        append_short(n)
+      end
+
+      def append_int(n)
+        append([n].pack(Formats::INT_FORMAT))
+      end
+
+      def append_short(n)
+        append([n].pack(Formats::SHORT_FORMAT))
+      end
+
+      def append_string(str)
+        str = str.to_s
+        append_short(str.bytesize)
+        append(str)
+      end
+
+      def append_long_string(str)
+        append_int(str.bytesize)
+        append(str)
+      end
+
+      def append_uuid(uuid)
+        v = uuid.value
+        append_int((v >> 96) & 0xffffffff)
+        append_int((v >> 64) & 0xffffffff)
+        append_int((v >> 32) & 0xffffffff)
+        append_int((v >> 0) & 0xffffffff)
+      end
+
+      def append_string_list(strs)
+        append_short(strs.size)
+        strs.each do |str|
+          append_string(str)
+        end
+        self
+      end
+
+      def append_bytes(bytes)
+        if bytes
+          append_int(bytes.bytesize)
+          append(bytes)
+        else
+          append_int(-1)
+        end
+      end
+
+      def append_short_bytes(bytes)
+        if bytes
+          append_short(bytes.bytesize)
+          append(bytes)
+        else
+          append_short(-1)
+        end
+      end
+
+      def append_consistency(consistency)
+        index = CONSISTENCIES.index(consistency)
+        raise Errors::EncodingError, %(Unknown consistency "#{consistency}") if index.nil? || CONSISTENCIES[index].nil?
+        append_short(index)
+      end
+
+      def append_string_map(map)
+        append_short(map.size)
+        map.each do |key, value|
+          append_string(key)
+          append_string(value)
+        end
+        self
+      end
+
+      def append_bytes_map(map)
+        append_short(map.size)
+        map.each do |key, value|
+          append_string(key)
+          append_bytes(value)
+        end
+        self
+      end
+
+      def append_long(n)
+        top = n >> 32
+        bottom = n & 0xffffffff
+        append_int(top)
+        append_int(bottom)
+      end
+
+      def append_varint(n)
+        num = n
+        bytes = []
+        loop do
+          bytes << (num & 0xff)
+          num >>= 8
+          break if (num == 0 || num == -1) && (bytes.last[7] == num[7])
+        end
+        append(bytes.reverse.pack(Formats::BYTES_FORMAT))
+      end
+
+      def append_decimal(n)
+        str = n.to_s(FLOAT_STRING_FORMAT)
+        size = str.index(DECIMAL_POINT)
+        number_string = str.gsub(DECIMAL_POINT, NO_CHAR)
+
+        num = number_string.to_i
+        raw = self.class.new.append_varint(num)
+        append_int(number_string.length - size)
+        append(raw)
+      end
+
+      def append_double(n)
+        append([n].pack(Formats::DOUBLE_FORMAT))
+      end
+
+      def append_float(n)
+        append([n].pack(Formats::FLOAT_FORMAT))
+      end
+
+      def eql?(other)
+        other.eql?(to_str)
+      end
+      alias == eql?
+    end
+  end
+end

data/lib/cassandra/protocol/cql_protocol_handler.rb

@@ -0,0 +1,448 @@
+# encoding: utf-8
+
+#--
+# Copyright 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
+    # This class wraps a single connection and translates between request/
+    # response frames and raw bytes.
+    #
+    # You send requests with #send_request, and receive responses through the
+    # returned future.
+    #
+    # Instances of this class are thread safe.
+    #
+    # @example Sending an OPTIONS request
+    #   future = protocol_handler.send_request(Cassandra::Protocol::OptionsRequest.new)
+    #   response = future.get
+    #   puts "These options are supported: #{response.options}"
+    class CqlProtocolHandler
+      # @return [String] the current keyspace for the underlying connection
+      attr_reader :keyspace
+
+      # @return [Exception] outstanding error, from a failed connection.
+      attr_reader :error
+
+      # @return [Integer] the version of the protocol to use in communicating with C*.
+      attr_reader :protocol_version
+
+      def initialize(connection,
+                     scheduler,
+                     protocol_version,
+                     compressor = nil,
+                     heartbeat_interval = 30,
+                     idle_timeout = 60,
+                     requests_per_connection = 128,
+                     custom_type_handlers = {})
+        @protocol_version = protocol_version
+        @connection = connection
+        @scheduler = scheduler
+        @compressor = compressor
+        @connection.on_data(&method(:receive_data))
+        @connection.on_closed(&method(:socket_closed))
+
+        @streams = Array.new(requests_per_connection) {|i| i}
+
+        @promises = {}
+
+        if protocol_version > 3
+          @frame_encoder = V4::Encoder.new(@compressor, protocol_version)
+          @frame_decoder = V4::Decoder.new(self, @compressor, custom_type_handlers)
+        elsif protocol_version > 2
+          @frame_encoder = V3::Encoder.new(@compressor, protocol_version)
+          @frame_decoder = V3::Decoder.new(self, @compressor)
+        else
+          @frame_encoder = V1::Encoder.new(@compressor, protocol_version)
+          @frame_decoder = V1::Decoder.new(self, @compressor)
+        end
+
+        @request_queue_in = []
+        @request_queue_out = []
+        @event_listeners = []
+        @data = {}
+        @lock = Mutex.new
+        @closed_promise = Ione::Promise.new
+        @keyspace = nil
+        @heartbeat = nil
+        @terminate = nil
+        @heartbeat_interval = heartbeat_interval
+        @idle_timeout = idle_timeout
+        @error = nil
+      end
+
+      # Returns the hostname of the underlying connection
+      #
+      # @return [String] the hostname
+      def host
+        @connection.host
+      end
+
+      # Returns the port of the underlying connection
+      #
+      # @return [Integer] the port
+      def port
+        @connection.port
+      end
+
+      # Associate arbitrary data with this protocol handler object. This is
+      # useful in situations where additional metadata can be loaded after the
+      # connection has been set up, or to keep statistics specific to the
+      # connection this protocol handler wraps.
+      def []=(key, value)
+        @lock.lock
+        @data[key] = value
+      ensure
+        @lock.unlock
+      end
+
+      # @see {#[]=}
+      # @return the value associated with the key
+      def [](key)
+        @lock.lock
+        @data[key]
+      ensure
+        @lock.unlock
+      end
+
+      # @return [true, false] true if the underlying connection is connected
+      def connected?
+        @connection.connected?
+      end
+
+      # @return [true, false] true if the underlying connection is closed
+      def closed?
+        @connection.closed?
+      end
+
+      # Register to receive notification when the underlying connection has
+      # closed. If the connection closed abruptly the error will be passed
+      # to the listener, otherwise it will not receive any parameters.
+      #
+      # @yieldparam error [nil, Error] the error that caused the connection to
+      #   close, if any
+      def on_closed(&listener)
+        @closed_promise.future.on_value(&listener)
+        @closed_promise.future.on_failure(&listener)
+      end
+
+      # Register to receive server sent events, like schema changes, nodes going
+      # up or down, etc. To actually receive events you also need to send a
+      # REGISTER request for the events you wish to receive.
+      #
+      # @yieldparam event [Cassandra::Protocol::EventResponse] an event sent by the server
+      def on_event(&listener)
+        @lock.lock
+        @event_listeners += [listener]
+      ensure
+        @lock.unlock
+      end
+
+      # Serializes and send a request over the underlying connection.
+      #
+      # Returns a future that will resolve to the response. When the connection
+      # closes the futures of all active requests will be failed with the error
+      # that caused the connection to close, or nil.
+      #
+      # When `timeout` is specified the future will fail with
+      # {Cassandra::Errors::TimeoutError} after that many seconds have passed. If a
+      # response arrives after that time it will be lost. If a response never arrives
+      # for the request the channel occupied by the request will _not_ be reused.
+      #
+      # @param [Cassandra::Protocol::Request] request
+      # @param [Float] timeout an optional number of seconds to wait until
+      #   failing the request
+      # @return [Ione::Future<Cassandra::Protocol::Response>] a future that resolves to
+      #   the response
+      def send_request(request, timeout = nil, with_heartbeat = true)
+        return Ione::Future.failed(Errors::IOError.new('Connection closed')) if closed?
+        schedule_heartbeat if with_heartbeat
+        promise = RequestPromise.new(request, timeout, @scheduler)
+        id = nil
+        @lock.lock
+        begin
+          if (id = next_stream_id)
+            @promises[id] = promise
+          end
+        ensure
+          @lock.unlock
+        end
+        if id
+          write_request(id, promise)
+        else
+          @lock.lock
+          begin
+            @request_queue_in << promise
+          ensure
+            @lock.unlock
+          end
+        end
+        promise.future
+      end
+
+      # Closes the underlying connection.
+      #
+      # @return [Ione::Future] a future that completes when the connection has closed
+      def close(cause = nil)
+        if @heartbeat
+          @scheduler.cancel_timer(@heartbeat)
+          @heartbeat = nil
+        end
+
+        if @terminate
+          @scheduler.cancel_timer(@terminate)
+          @terminate = nil
+        end
+
+        @scheduler.schedule_timer(0).on_value do
+          @connection.close(cause)
+        end
+
+        @closed_promise.future
+      end
+
+      def notify_event_listeners(event_response)
+        event_listeners = nil
+        @lock.lock
+        begin
+          event_listeners = @event_listeners
+          return if event_listeners.empty?
+        ensure
+          @lock.unlock
+        end
+        event_listeners.each do |listener|
+          listener.call(event_response)
+        end
+      end
+
+      def complete_request(id, response)
+        promise = nil
+        @lock.lock
+        begin
+          promise = @promises.delete(id)
+          @streams.unshift(id)
+        ensure
+          @lock.unlock
+        end
+        @keyspace = response.keyspace if response.is_a?(Protocol::SetKeyspaceResultResponse)
+        if response.is_a?(Protocol::SchemaChangeResultResponse) &&
+           response.change == 'DROPPED' &&
+           response.keyspace == @keyspace &&
+           response.target == Protocol::Constants::SCHEMA_CHANGE_TARGET_KEYSPACE
+          @keyspace = nil
+        end
+        flush_request_queue
+        promise.fulfill(response) unless promise.timed_out?
+      end
+
+      private
+
+      # @private
+      class RequestPromise < Ione::Promise
+        extend AttrBoolean
+
+        attr_reader :request, :timeout
+        attr_boolean :timed_out
+        attr_accessor :timer
+
+        def initialize(request, timeout, scheduler)
+          @request = request
+          @timeout = timeout
+          @timed_out = false
+          @scheduler = scheduler
+          @lock = Mutex.new
+          @timer = nil
+          super()
+        end
+
+        def time_out!
+          unless future.completed?
+            @timed_out = true
+            fail(Errors::TimeoutError.new('Timed out'))
+          end
+        end
+
+        def maybe_start_timer
+          # This is more complicated than one would expect. First, we want to start a timer
+          # if a timeout is set. But there is a race condition where send_request creates
+          # a fresh promise and adds it to @promises, but another thread handles a socket
+          # closure event and fails all known promises. When a promise fails, we want to cancel
+          # the timer, if set. So, we synchronize access to @timer to be sure we don't set up
+          # and cancel the timer at the same time. However, if promise.fail runs first, there
+          # will be no timer to cancel, and then when maybe_start_timer gets called in the other
+          # thread, it'll create a timer on a promise that no one is going to action on going forward.
+          # So, that leads to leaking the timer until it times out. To avoid this, we want to
+          # check that the future of the promise isn't completed before starting the timer.
+
+          return if @timeout.nil?
+          return if @future.completed?
+
+          if @timer.nil?
+            @lock.synchronize do
+              if @timer.nil?
+                return if @future.completed?
+                @timer = @scheduler.schedule_timer(@timeout)
+                @timer.on_value { time_out! }
+              end
+            end
+          end
+        end
+
+        def fulfill(response)
+          super
+          maybe_cancel_timer
+        end
+
+        def fail(cause)
+          super
+          maybe_cancel_timer
+        end
+
+        def maybe_cancel_timer
+          return if @timeout.nil?
+          timer = nil
+          if @timer
+            @lock.synchronize do
+              if @timer
+                timer = @timer
+                @timer = nil
+              end
+            end
+          end
+          @scheduler.cancel_timer(timer) if timer
+        end
+      end
+
+      def receive_data(data)
+        reschedule_termination
+        @frame_decoder << data
+      end
+
+      def flush_request_queue
+        @lock.lock
+        begin
+          if @request_queue_out.empty? && !@request_queue_in.empty?
+            @request_queue_out = @request_queue_in
+            @request_queue_in = []
+          end
+        ensure
+          @lock.unlock
+        end
+        loop do
+          id = nil
+          promise = nil
+          @lock.lock
+          begin
+            if @request_queue_out.any? && (id = next_stream_id)
+              promise = @request_queue_out.shift
+              next if promise.timed_out?
+              @promises[id] = promise
+            end
+          ensure
+            @lock.unlock
+          end
+
+          break unless id
+          write_request(id, promise)
+        end
+      end
+
+      def write_request(id, request_promise)
+        @connection.write do |buffer|
+          @frame_encoder.encode(buffer, request_promise.request, id)
+        end
+        request_promise.maybe_start_timer
+      end
+
+      def socket_closed(cause)
+        if cause
+          e = Errors::IOError.new(cause.message)
+          e.set_backtrace(cause.backtrace)
+
+          cause = e
+        end
+        @error = cause
+
+        request_failure_cause = cause || Errors::IOError.new('Connection closed')
+        promises_to_fail = nil
+        @lock.synchronize do
+          @scheduler.cancel_timer(@heartbeat) if @heartbeat
+          @scheduler.cancel_timer(@terminate) if @terminate
+
+          @heartbeat = nil
+          @terminate = nil
+
+          promises_to_fail = @promises.values
+          promises_to_fail.concat(@request_queue_in)
+          promises_to_fail.concat(@request_queue_out)
+          @promises.clear
+          @request_queue_in.clear
+          @request_queue_out.clear
+        end
+        promises_to_fail.each do |promise|
+          promise.fail(request_failure_cause) unless promise.timed_out?
+        end
+        if cause
+          @closed_promise.fail(cause)
+        else
+          @closed_promise.fulfill
+        end
+      end
+
+      def schedule_heartbeat
+        return unless @heartbeat_interval
+
+        timer = nil
+
+        @lock.synchronize do
+          @scheduler.cancel_timer(@heartbeat) if @heartbeat && !@heartbeat.resolved?
+
+          @heartbeat = timer = @scheduler.schedule_timer(@heartbeat_interval)
+        end
+
+        timer.on_value do
+          send_request(HEARTBEAT, nil, false).on_value do
+            schedule_heartbeat
+          end
+        end
+      end
+
+      def reschedule_termination
+        return unless @idle_timeout
+
+        timer = nil
+
+        @lock.synchronize do
+          @scheduler.cancel_timer(@terminate) if @terminate
+
+          @terminate = timer = @scheduler.schedule_timer(@idle_timeout)
+        end
+
+        timer.on_value do
+          @terminate = nil
+          @connection.close(TERMINATED)
+        end
+      end
+
+      def next_stream_id
+        @streams.shift
+      end
+
+      HEARTBEAT  = OptionsRequest.new
+      TERMINATED = Errors::TimeoutError.new('Terminated due to inactivity')
+    end
+  end
+end