yugabyte-ycql-driver 3.2.3.1

data/lib/cassandra/load_balancing/policies/token_aware.rb

@@ -0,0 +1,149 @@
+# 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 LoadBalancing
+    module Policies
+      class TokenAware < Policy
+        # @private
+        class Plan
+          def initialize(hosts, policy, keyspace, statement, options)
+            @hosts     = hosts
+            @policy    = policy
+            @keyspace  = keyspace
+            @statement = statement
+            @options   = options
+            @seen      = ::Hash.new
+          end
+
+          def has_next?
+            until @hosts.empty?
+              host = @hosts.shift
+
+              next unless @policy.distance(host) == :local
+              @seen[host] = true
+              @next = host
+              break
+            end
+
+            return true if @next
+
+            @plan ||= @policy.plan(@keyspace, @statement, @options)
+
+            while @plan.has_next?
+              host = @plan.next
+
+              unless @seen[host]
+                @next = host
+                return true
+              end
+            end
+
+            false
+          end
+
+          def next
+            host  = @next
+            @next = nil
+            host
+          end
+        end
+
+        extend Forwardable
+
+        # @!method distance(host)
+        #   Delegates to wrapped policy
+        #   @see Cassandra::LoadBalancing::Policy#distance
+        #
+        # @!method host_found(host)
+        #   Delegates to wrapped policy
+        #   @see Cassandra::LoadBalancing::Policy#host_found
+        #
+        # @!method host_up(host)
+        #   Delegates to wrapped policy
+        #   @see Cassandra::LoadBalancing::Policy#host_up
+        #
+        # @!method host_down(host)
+        #   Delegates to wrapped policy
+        #   @see Cassandra::LoadBalancing::Policy#host_down
+        #
+        # @!method host_lost(host)
+        #   Delegates to wrapped policy
+        #   @see Cassandra::LoadBalancing::Policy#host_lost
+        def_delegators :@policy, :distance, :host_found, :host_up, :host_down, :host_lost
+
+        # @param wrapped_policy [Cassandra::LoadBalancing::Policy] actual
+        #   policy to filter
+        # @param shuffle [Boolean] (true) whether or not to shuffle the replicas
+        #
+        # @note If replicas are not shuffled (`shuffle = false`), then it is
+        #   possibile to create hotspots in a write-heavy scenario, where most
+        #   of the write requests will be handled by the same node(s). The
+        #   default behavior of shuffling replicas helps mitigate this by
+        #   universally distributing write load between replicas. However, it
+        #   under-utilizes read caching and forces multiple replicas to cache
+        #   the same read statements.
+        def initialize(wrapped_policy, shuffle = true)
+          methods = [:host_up, :host_down, :host_found, :host_lost, :setup, :teardown,
+                     :distance, :plan]
+
+          Util.assert_responds_to_all(methods, wrapped_policy) do
+            "supplied policy must respond to #{methods.inspect}, but doesn't"
+          end
+
+          @policy  = wrapped_policy
+          @shuffle = !!shuffle
+        end
+
+        def setup(cluster)
+          @cluster = cluster
+          @policy.setup(cluster)
+          nil
+        end
+
+        def teardown(cluster)
+          @cluster = nil
+          @policy.teardown(cluster)
+          nil
+        end
+
+        def plan(keyspace, statement, options)
+          return @policy.plan(keyspace, statement, options) unless @cluster
+
+          replicas = @cluster.find_replicas(keyspace, statement)
+          return @policy.plan(keyspace, statement, options) if replicas.empty?
+
+          replicas = if @shuffle
+                       replicas.shuffle
+                     else
+                       replicas.dup
+                     end
+
+          Plan.new(replicas, @policy, keyspace, statement, options)
+        end
+
+        # @private
+        def inspect
+          "#<#{self.class.name}:0x#{object_id.to_s(16)} " \
+          "policy=#{@policy.inspect}, " \
+          "shuffle=#{@shuffle.inspect}>"
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/load_balancing/policies/white_list.rb

@@ -0,0 +1,100 @@
+# 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 LoadBalancing
+    module Policies
+      class WhiteList < Policy
+        extend Forwardable
+
+        # @!method plan(keyspace, statement, options)
+        #   Delegates to wrapped policy
+        #   @see Cassandra::LoadBalancing::Policy#plan
+        #
+        # @!method distance(host)
+        #   Delegates to wrapped policy
+        #   @see Cassandra::LoadBalancing::Policy#distance
+        def_delegators :@policy, :plan, :distance
+
+        # @param ips [Enumerable<String, IPAddr>] a list of ips to whitelist
+        # @param wrapped_policy [Cassandra::LoadBalancing::Policy] actual policy to filter
+        # @raise [ArgumentError] if arguments are of unexpected types
+        def initialize(ips, wrapped_policy)
+          Util.assert_instance_of(::Enumerable, ips) do
+            "ips must be an Enumerable, #{ips.inspect} given"
+          end
+          methods = [:host_up, :host_down, :host_found, :host_lost, :setup, :teardown,
+                     :distance, :plan]
+          Util.assert_responds_to_all(methods, wrapped_policy) do
+            "supplied policy must respond to #{methods.inspect}, but doesn't"
+          end
+
+          @ips    = ::Set.new
+          @policy = wrapped_policy
+
+          ips.each do |ip|
+            case ip
+            when ::IPAddr
+              @ips << ip
+            when ::String
+              @ips << ::IPAddr.new(ip)
+            else
+              raise ::ArgumentError, 'each ip must be a String or IPAddr, ' \
+                  "#{ip.inspect} given"
+            end
+          end
+        end
+
+        # Delegates to wrapped policy if host's ip is whitelisted
+        # @param host [Cassandra::Host] a host instance
+        # @see Cassandra::LoadBalancing::Policy#host_found
+        def host_found(host)
+          @policy.host_found(host) if @ips.include?(host.ip)
+        end
+
+        # Delegates to wrapped policy if host's ip is whitelisted
+        # @param host [Cassandra::Host] a host instance
+        # @see Cassandra::LoadBalancing::Policy#host_lost
+        def host_lost(host)
+          @policy.host_lost(host) if @ips.include?(host.ip)
+        end
+
+        # Delegates to wrapped policy if host's ip is whitelisted
+        # @param host [Cassandra::Host] a host instance
+        # @see Cassandra::LoadBalancing::Policy#host_up
+        def host_up(host)
+          @policy.host_up(host) if @ips.include?(host.ip)
+        end
+
+        # Delegates to wrapped policy if host's ip is whitelisted
+        # @param host [Cassandra::Host] a host instance
+        # @see Cassandra::LoadBalancing::Policy#host_down
+        def host_down(host)
+          @policy.host_down(host) if @ips.include?(host.ip)
+        end
+
+        # @private
+        def inspect
+          "#<#{self.class.name}:0x#{object_id.to_s(16)} " \
+          "policy=#{@policy.inspect}, " \
+          "ips=#{@ips.inspect}>"
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/materialized_view.rb

@@ -0,0 +1,92 @@
+# 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
+  # Represents a cassandra materialized view
+  # @see Cassandra::Keyspace#each_materialized_view
+  # @see Cassandra::Keyspace#materialized_view
+  class MaterializedView < ColumnContainer
+    # @private
+    def initialize(keyspace,
+                   name,
+                   partition_key,
+                   clustering_columns,
+                   other_columns,
+                   options,
+                   include_all_columns,
+                   where_clause,
+                   base_table_name,
+                   id)
+      super(keyspace, name, partition_key, clustering_columns, other_columns, options, id)
+      @include_all_columns = include_all_columns
+      @where_clause = where_clause
+      @base_table_name = base_table_name
+    end
+
+    # @return [Table] the table that this materialized view applies to.
+    def base_table
+      @keyspace.table(@base_table_name)
+    end
+
+    # @return [String] a cql representation of this materialized view
+    def to_cql
+      keyspace_name = Util.escape_name(@keyspace.name)
+      cql = "CREATE MATERIALIZED VIEW #{keyspace_name}.#{Util.escape_name(@name)} AS\nSELECT "
+      cql << if @include_all_columns
+               '*'
+             else
+               @columns.map do |column|
+                 Util.escape_name(column.name)
+               end.join(', ')
+             end
+      cql << "\nFROM #{keyspace_name}.#{Util.escape_name(@base_table_name)}"
+      cql << "\nWHERE #{@where_clause}" if @where_clause
+      cql << "\nPRIMARY KEY (("
+      cql << @partition_key.map do |column|
+        Util.escape_name(column.name)
+      end.join(', ')
+      cql << ')'
+      unless @clustering_columns.empty?
+        cql << ', '
+        cql << @clustering_columns.map do |column|
+          Util.escape_name(column.name)
+        end.join(', ')
+      end
+      cql << ")\nWITH #{@options.to_cql.split("\n").join("\n ")};"
+    end
+
+    # @private
+    def eql?(other)
+      other.is_a?(MaterializedView) &&
+        super.eql?(other) &&
+        @include_all_columns == other.include_all_columns &&
+        @where_clause == other.where_clause &&
+        @base_table_name == other.base_table.name
+    end
+    alias == eql?
+
+    private
+
+    # We need these accessors for eql? to work, but we don't want random users to
+    # get these.
+
+    # @private
+    attr_reader :include_all_columns, :where_clause
+    protected :include_all_columns, :where_clause
+  end
+end

data/lib/cassandra/null_logger.rb

@@ -0,0 +1,56 @@
+# 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
+  # @private
+  class NullLogger
+    def close(*); end
+
+    def debug(*); end
+
+    def debug?
+      false
+    end
+
+    def error(*); end
+
+    def error?
+      false
+    end
+
+    def fatal(*); end
+
+    def fatal?
+      false
+    end
+
+    def info(*); end
+
+    def info?
+      false
+    end
+
+    def unknown(*); end
+
+    def warn(*); end
+
+    def warn?
+      false
+    end
+  end
+end

data/lib/cassandra/protocol.rb

@@ -0,0 +1,102 @@
+# 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
+  # @private
+  module Protocol
+    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
+
+      # All of the formats above are big-endian (e.g. network-byte-order). Some payloads (custom types) may have
+      # little-endian components.
+
+      DOUBLE_FORMAT_LE = 'E'.freeze
+      INT_FORMAT_LE = 'V'.freeze
+      SHORT_FORMAT_LE = 'v'.freeze
+    end
+
+    module Constants
+      TRUE_BYTE = "\x01".freeze
+      FALSE_BYTE = "\x00".freeze
+      PROTOCOL_VERSION = "\x01".freeze
+      COMPRESSION_OFF = "\x00".freeze
+
+      SCHEMA_CHANGE_TARGET_KEYSPACE  = 'KEYSPACE'.freeze
+      SCHEMA_CHANGE_TARGET_TABLE     = 'TABLE'.freeze
+      SCHEMA_CHANGE_TARGET_UDT       = 'TYPE'.freeze
+      SCHEMA_CHANGE_TARGET_FUNCTION  = 'FUNCTION'.freeze
+      SCHEMA_CHANGE_TARGET_AGGREGATE = 'AGGREGATE'.freeze
+    end
+
+    module Versions
+      BETA_VERSION = 5
+      MAX_SUPPORTED_VERSION = 4
+    end
+  end
+end
+
+require 'cassandra/protocol/cql_byte_buffer'
+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/already_exists_error_response'
+require 'cassandra/protocol/responses/read_timeout_error_response'
+require 'cassandra/protocol/responses/unavailable_error_response'
+require 'cassandra/protocol/responses/unprepared_error_response'
+require 'cassandra/protocol/responses/write_timeout_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/responses/read_failure_error_response'
+require 'cassandra/protocol/responses/write_failure_error_response'
+require 'cassandra/protocol/responses/function_failure_error_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/cql_protocol_handler'
+require 'cassandra/protocol/v1'
+require 'cassandra/protocol/v3'
+require 'cassandra/protocol/v4'
+require 'cassandra/protocol/coder'