yugabyte-ycql-driver 3.2.3.1

data/lib/cassandra/cluster/failed_connection.rb

@@ -0,0 +1,35 @@
+# 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
+  class Cluster
+    # @private
+    class FailedConnection
+      attr_reader :error, :host
+
+      def initialize(error, host)
+        @error = error
+        @host  = host
+      end
+
+      def connected?
+        false
+      end
+    end
+  end
+end

data/lib/cassandra/cluster/metadata.rb

@@ -0,0 +1,142 @@
+# 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
+  class Cluster
+    # @private
+    class Metadata
+      include MonitorMixin
+
+      attr_reader :name
+
+      def initialize(cluster_registry,
+                     cluster_schema,
+                     schema_partitioners,
+                     replication_strategies,
+                     default_replication_strategy)
+        @registry         = cluster_registry
+        @schema           = cluster_schema
+        @partitioners     = schema_partitioners
+        @strategies       = replication_strategies
+        @default_strategy = default_replication_strategy
+        @token_replicas   = ::Hash.new
+        @token_ring       = ::Array.new
+      end
+
+      def find_replicas(keyspace, statement)
+        return EMPTY_LIST unless statement.respond_to?(:partition_key) && statement.respond_to?(:keyspace)
+
+        keyspace      = String(statement.keyspace || keyspace)
+        partition_key = statement.partition_key
+        return EMPTY_LIST unless keyspace && partition_key
+
+        partitioner = @partitioner
+        return EMPTY_LIST unless partitioner
+
+        keyspace_hosts = @token_replicas[keyspace]
+        return EMPTY_LIST if keyspace_hosts.nil? || keyspace_hosts.empty?
+
+        token = partitioner.create_token(partition_key)
+        index = insertion_point(@token_ring, token)
+        index = 0 if index >= @token_ring.size
+        hosts = keyspace_hosts[@token_ring[index]]
+        return EMPTY_LIST unless hosts
+
+        hosts
+      end
+
+      def update(data)
+        @name        = data['cluster_name']
+        @partitioner = @partitioners[data['partitioner']]
+
+        self
+      end
+
+      def rebuild_token_map
+        partitioner = @partitioner
+        return self unless partitioner
+
+        tokens        = ::SortedSet.new
+        token_to_host = ::Hash.new
+
+        @registry.each_host do |host|
+          host.tokens.each do |token|
+            token = begin
+                      partitioner.parse_token(token)
+                    rescue
+                      next
+                    end
+            tokens.add(token)
+            token_to_host[token] = host
+          end
+        end
+
+        token_ring     = tokens.to_a
+        token_replicas = ::Hash.new
+        token_maps     = ::Hash.new
+
+        @schema.each_keyspace do |keyspace|
+          replication = keyspace.replication
+          key         = replication_key(replication.klass, replication.options)
+
+          unless token_maps.include?(key)
+            strategy        = @strategies[replication.klass] || @default_strategy
+            token_maps[key] = strategy.replication_map(
+              token_to_host,
+              token_ring,
+              replication.options
+            )
+          end
+
+          token_replicas[keyspace.name] = token_maps[key]
+        end
+
+        @token_replicas = token_replicas
+        @token_ring     = token_ring
+
+        self
+      end
+
+      private
+
+      def replication_key(klass, options)
+        (klass + ':' + options.keys.sort.map {|k| "#{k}=#{options[k]}"}.join(',')).hash
+      end
+
+      def insertion_point(list, item)
+        min = 0
+        max = list.size - 1
+
+        while min <= max
+          idx = (min + max) / 2
+          val = list[idx]
+
+          if val < item
+            min = idx + 1
+          elsif val > item
+            max = idx - 1
+          else
+            return idx # item found
+          end
+        end
+
+        min # item not found.
+      end
+    end
+  end
+end

data/lib/cassandra/cluster/options.rb

@@ -0,0 +1,145 @@
+# 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
+  class Cluster
+    # @private
+    class Options
+      extend AttrBoolean
+
+      attr_reader :auth_provider, :compressor, :connect_timeout, :credentials,
+                  :heartbeat_interval, :idle_timeout, :port, :schema_refresh_delay,
+                  :schema_refresh_timeout, :ssl, :custom_type_handlers
+      attr_boolean :protocol_negotiable, :synchronize_schema, :nodelay, :allow_beta_protocol
+
+      attr_accessor :protocol_version
+
+      def initialize(logger,
+                     protocol_version,
+                     credentials,
+                     auth_provider,
+                     compressor,
+                     port,
+                     connect_timeout,
+                     ssl,
+                     connections_per_local_node,
+                     connections_per_remote_node,
+                     heartbeat_interval,
+                     idle_timeout,
+                     synchronize_schema,
+                     schema_refresh_delay,
+                     schema_refresh_timeout,
+                     nodelay,
+                     requests_per_connection,
+                     custom_types,
+                     allow_beta_protocol)
+        @logger                 = logger
+        @protocol_version       = protocol_version
+        @credentials            = credentials
+        @auth_provider          = auth_provider
+        @compressor             = compressor
+        @port                   = port
+        @connect_timeout        = connect_timeout
+        @ssl                    = ssl
+        @heartbeat_interval     = heartbeat_interval
+        @idle_timeout           = idle_timeout
+        @synchronize_schema     = synchronize_schema
+        @schema_refresh_delay   = schema_refresh_delay
+        @schema_refresh_timeout = schema_refresh_timeout
+        @nodelay                = nodelay
+        @allow_beta_protocol    = allow_beta_protocol
+        @custom_type_handlers   = {}
+        custom_types.each do |type_klass|
+          @custom_type_handlers[type_klass.type] = type_klass
+        end
+
+        @connections_per_local_node  = connections_per_local_node
+        @connections_per_remote_node = connections_per_remote_node
+        @requests_per_connection = requests_per_connection
+
+        # If @protocol_version is nil, it means we want the driver to negotiate the
+        # protocol starting with our known max. If @protocol_version is not nil,
+        # it means the user wants us to use a particular version, so we should not
+        # support negotiation.
+
+        @protocol_negotiable = @protocol_version.nil?
+        @protocol_version ||= allow_beta_protocol ?
+            Cassandra::Protocol::Versions::BETA_VERSION :
+            Cassandra::Protocol::Versions::MAX_SUPPORTED_VERSION
+      end
+
+      def compression
+        @compressor && @compressor.algorithm
+      end
+
+      def create_authenticator(authentication_class, host)
+        if @auth_provider
+          # Auth providers should take an auth-class and host, but they used to not, so for backward compatibility
+          # we figure out if this provider does, and if so send both args, otherwise just send the auth-class.
+
+          if @auth_provider.method(:create_authenticator).arity == 1
+            @auth_provider.create_authenticator(authentication_class)
+          else
+            @auth_provider.create_authenticator(authentication_class, host)
+          end
+        end
+      end
+
+      def connections_per_local_node
+        # Return the option if set.
+        return @connections_per_local_node if @connections_per_local_node
+
+        # For v3 and later, default is 1 local connection.
+        # For v2 and earlier, default is 2 local connections.
+        # Return the default
+        (@protocol_version > 2) ? 1 : 2
+      end
+
+      def connections_per_remote_node
+        # Return the option if set; otherwise return the default (1).
+        @connections_per_remote_node || 1
+      end
+
+      def requests_per_connection
+        # There are a few possibilities here based on @requests_per_connection:
+        # nil: default to 1024 for protocol 3 and later, 128 for < 3.
+        # we're in v2 and value too high: return 128. We don't worry
+        #   about this case for v3+ because option validation in
+        #   Cassandra::cluster_async takes care of that.
+        # good value: return it.
+        #
+        # NOTE: We can't compute and cache the result because protocol_version
+        # can change over time in theory (if all nodes are upgraded to a new
+        # version of Cassandra)
+
+        # Return the default if option wasn't specified.
+        default_requests_per_connection = @protocol_version > 2 ? 1024 : 128
+        return default_requests_per_connection unless @requests_per_connection
+
+        if @requests_per_connection > 128 && @protocol_version < 3
+          @logger.warn(
+            ":requests_per_connection setting of #{@requests_per_connection} is more " \
+                'than the max of 128 for protocol v2. Falling back to 128.'
+          )
+          return 128
+        end
+        @requests_per_connection
+      end
+    end
+  end
+end

data/lib/cassandra/cluster/registry.rb

@@ -0,0 +1,284 @@
+# 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
+  class Cluster
+    # @private
+    class Registry
+      include MonitorMixin
+
+      def initialize(logger)
+        @logger    = logger
+        @hosts     = ::Hash.new
+        @listeners = ::Array.new
+
+        mon_initialize
+      end
+
+      def add_listener(listener)
+        synchronize do
+          listeners = @listeners.dup
+          listeners.push(listener)
+          @listeners = listeners
+        end
+
+        self
+      end
+
+      def remove_listener(listener)
+        synchronize do
+          listeners = @listeners.dup
+          listeners.delete(listener)
+          @listeners = listeners
+        end
+
+        self
+      end
+
+      def each_host(&block)
+        if block_given?
+          @hosts.each_value(&block)
+          self
+        else
+          @hosts.values
+        end
+      end
+      alias hosts each_host
+
+      # @param address [IPAddr] resolved address of the node
+      def host(address)
+        @hosts[address.to_s]
+      end
+
+      # @param address [IPAddr] resolved address of the node
+      def has_host?(address)
+        @hosts.key?(address.to_s)
+      end
+
+      # @param address [IPAddr] resolved address of the node
+      # @param data [Hash<String, String>] attributes of the host, typically a row from system.local or system.peers.
+      def host_found(address, data = {})
+        ip   = address.to_s
+        host = @hosts[ip]
+
+        if host
+          if host.id              == data['host_id']         &&
+             host.release_version == data['release_version'] &&
+             host.rack            == data['rack']            &&
+             host.datacenter      == data['data_center']     &&
+             host.broadcast_address == data['broadcast_address'] &&
+             host.listen_address == data['listen_address']
+
+            return self if host.up?
+
+            host = toggle_up(host)
+          else
+            @logger.debug("Host #{host.ip} metadata has been updated, it will be " \
+                'considered lost and found')
+
+            notify_lost(host)
+
+            host = create_host(address, data)
+
+            notify_found(host)
+          end
+        else
+          host = create_host(address, data)
+
+          notify_found(host)
+        end
+
+        synchronize do
+          hosts     = @hosts.dup
+          hosts[ip] = host
+          @hosts    = hosts
+        end
+
+        self
+      end
+
+      # @param address [IPAddr] resolved address of the node
+      def host_down(address)
+        ip   = address.to_s
+        host = @hosts[ip]
+
+        return self unless host && !host.down?
+
+        host = toggle_down(host)
+
+        synchronize do
+          hosts     = @hosts.dup
+          hosts[ip] = host
+          @hosts    = hosts
+        end
+
+        self
+      end
+
+      # @param address [IPAddr] resolved address of the node
+      def host_up(address)
+        ip   = address.to_s
+        host = @hosts[ip]
+
+        return self unless host && !host.up?
+
+        host = toggle_up(host)
+
+        synchronize do
+          hosts     = @hosts.dup
+          hosts[ip] = host
+          @hosts    = hosts
+        end
+
+        self
+      end
+
+      # @param address [IPAddr] resolved address of the node
+      def host_lost(address)
+        ip   = address.to_s
+        host = nil
+
+        return self unless @hosts.key?(ip)
+
+        synchronize do
+          hosts  = @hosts.dup
+          host   = hosts.delete(ip)
+          @hosts = hosts
+        end
+
+        notify_lost(host)
+
+        host
+      end
+
+      private
+
+      # @param ip [String] resolved address of the node
+      # @param data [Hash<String, String>] attributes of the host, typically a row from system.local or system.peers.
+      def create_host(ip, data)
+        Host.new(ip,
+                 data['host_id'],
+                 data['rack'],
+                 data['data_center'],
+                 data['release_version'],
+                 Array(data['tokens']).freeze,
+                 :up,
+                 data['broadcast_address'],
+                 data['listen_address'])
+      end
+
+      # @param host [Host] host that is found to be up.
+      def toggle_up(host)
+        host = Host.new(host.ip,
+                        host.id,
+                        host.rack,
+                        host.datacenter,
+                        host.release_version,
+                        host.tokens,
+                        :up,
+                        host.broadcast_address,
+                        host.listen_address)
+        @logger.debug("Host #{host.ip} is up")
+        @listeners.each do |listener|
+          begin
+            listener.host_up(host)
+          rescue
+            nil
+          end
+        end
+        host
+      end
+
+      # @param host [Host] host that is found to be down.
+      def toggle_down(host)
+        host = Host.new(host.ip,
+                        host.id,
+                        host.rack,
+                        host.datacenter,
+                        host.release_version,
+                        host.tokens,
+                        :down,
+                        host.broadcast_address,
+                        host.listen_address)
+        @logger.debug("Host #{host.ip} is down")
+        @listeners.reverse_each do |listener|
+          begin
+            listener.host_down(host)
+          rescue
+            nil
+          end
+        end
+        host
+      end
+
+      # @param host [Host] host that is lost.
+      def notify_lost(host)
+        if host.up?
+          @logger.debug("Host #{host.ip} is down and lost")
+          host = Host.new(host.ip,
+                          host.id,
+                          host.rack,
+                          host.datacenter,
+                          host.release_version,
+                          host.tokens,
+                          :down,
+                          host.broadcast_address,
+                          host.listen_address)
+          @listeners.reverse_each do |listener|
+            begin
+              listener.host_down(host)
+            rescue
+              nil
+            end
+            begin
+              listener.host_lost(host)
+            rescue
+              nil
+            end
+          end
+        else
+          @logger.debug("Host #{host.ip} is lost")
+          @listeners.reverse_each do |listener|
+            begin
+              listener.host_lost(host)
+            rescue
+              nil
+            end
+          end
+        end
+      end
+
+      # @param host [Host] host that is found.
+      def notify_found(host)
+        @logger.debug("Host #{host.ip} is found and up")
+        @listeners.each do |listener|
+          begin
+            listener.host_found(host)
+          rescue
+            nil
+          end
+          begin
+            listener.host_up(host)
+          rescue
+            nil
+          end
+        end
+      end
+    end
+  end
+end