yugabyte-ycql-driver 3.2.3.1

data/lib/cassandra/compression.rb

@@ -0,0 +1,69 @@
+# 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 Compression
+    # @abstract Compressors given to {Cassandra.cluster} as the `:compressor`
+    #   option don't need to be subclasses of this class, but need to implement
+    #   the same methods. This class exists only for documentation purposes.
+    class Compressor
+      # @!method algorithm
+      #
+      # Returns the name of the algorithm this compressor supports,
+      # e.g. "snappy" or "lz4".
+      #
+      # @return [String] algorithm
+
+      # @!method compress?(frame)
+      #
+      # Before compressing a frame the compressor will be asked if it wants
+      # to compress it or not. One reason it could say no is if the frame is
+      # small enough that compression would be unlikely to decrease its size.
+      #
+      # If your operations consist mostly of small prepared statement
+      # executions it might not be useful to compress the frames being sent
+      # _to_ Cassandra, but enabling compression can still be useful on the
+      # frames coming _from_ Cassandra. Making this method always return
+      # false disables request compression, but will still make the client
+      # tell Cassandra that it supports compressed frames.
+      #
+      # The bytes given to {#compress?} are the same as to {#compress}
+      #
+      # @param frame [String] the bytes of the frame to be compressed
+      # @return [true, false] whether to perform compression or not
+
+      # @!method compress(frame)
+      #
+      # Compresses the raw bytes of a frame.
+      #
+      # @param frame [String] the bytes of the frame to be compressed
+      # @return [String] the compressed frame
+
+      # @!method decompress(compressed_frame)
+      #
+      # Decompresses the raw bytes of a compressed frame.
+      #
+      # @param compressed_frame [String] the bytes of the compressed frame to
+      #   be uncompressed
+      # @return [String] uncompressed bytes
+    end
+  end
+end
+
+require 'cassandra/compression/compressors/snappy'
+require 'cassandra/compression/compressors/lz4'

data/lib/cassandra/compression/compressors/lz4.rb

@@ -0,0 +1,73 @@
+# 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 Compression
+    module Compressors
+      # A compressor that uses the LZ4 compression library.
+      #
+      # @note This compressor requires the
+      #   [lz4-ruby](http://rubygems.org/gems/lz4-ruby) gem (v0.3.2 or later
+      #   required).
+      # @note No need to instantiate this class manually, use `compression:
+      #   :lz4` option when calling {Cassandra.cluster} and one will be created
+      #   automatically for you.
+      class Lz4 < Compressor
+        # @private
+        BUFFER_FORMAT = 'Na*'.freeze
+
+        # @return [String] `'lz4'`
+        attr_reader :algorithm
+
+        # @param [Integer] min_size (64) Don't compress frames smaller than
+        #   this size (see {#compress?}).
+        def initialize(min_size = 64)
+          unless defined?(::LZ4::Raw)
+            begin
+              require 'lz4-ruby'
+            rescue LoadError => e
+              raise LoadError, %(LZ4 support requires the "lz4-ruby" gem: #{e.message}),
+                    e.backtrace
+            end
+          end
+
+          @algorithm = 'lz4'.freeze
+          @min_size = min_size
+        end
+
+        # @return [true, false] will return false for frames smaller than the
+        #   `min_size` given to the constructor.
+        # @see Cassandra::Compression::Compressor#compress?
+        def compress?(str)
+          str.bytesize > @min_size
+        end
+
+        # @see Cassandra::Compression::Compressor#compress
+        def compress(str)
+          [str.bytesize, ::LZ4::Raw.compress(str.to_s).first].pack(BUFFER_FORMAT)
+        end
+
+        # @see Cassandra::Compression::Compressor#decompress
+        def decompress(str)
+          decompressed_size, compressed_data = str.to_s.unpack(BUFFER_FORMAT)
+          ::LZ4::Raw.decompress(compressed_data, decompressed_size).first
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/compression/compressors/snappy.rb

@@ -0,0 +1,69 @@
+# 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 Compression
+    module Compressors
+      # A compressor that uses the Snappy compression library.
+      #
+      # @note This compressor requires the
+      #   [snappy](http://rubygems.org/gems/snappy) gem (v0.0.10 or later for
+      #   JRuby support).
+      # @note No need to instantiate this class manually, use `compression:
+      #   :snappy` option when calling {Cassandra.cluster} and one will be
+      #   created automatically for you.
+      class Snappy < Compressor
+        # @return [String] `'snappy'`
+        attr_reader :algorithm
+
+        # @param [Integer] min_size (64) Don't compress frames smaller than
+        #   this size (see {#compress?}).
+        def initialize(min_size = 64)
+          unless defined?(::Snappy)
+            begin
+              require 'snappy'
+            rescue LoadError => e
+              raise LoadError, %(Snappy support requires the "snappy" gem: #{e.message}),
+                    e.backtrace
+            end
+          end
+
+          @algorithm = 'snappy'.freeze
+          @min_size = min_size
+        end
+
+        # @return [true, false] will return false for frames smaller than the
+        #   `min_size` given to the constructor.
+        # @see Cassandra::Compression::Compressor#compress?
+        def compress?(str)
+          str.bytesize > @min_size
+        end
+
+        # @see Cassandra::Compression::Compressor#compress
+        def compress(str)
+          ::Snappy.deflate(str)
+        end
+
+        # @see Cassandra::Compression::Compressor#decompress
+        def decompress(str)
+          ::Snappy.inflate(str)
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/custom_data.rb

@@ -0,0 +1,53 @@
+# 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.
+#++
+
+# Use this module to mark domain object classes as custom type implementations for custom-type
+# columns in C*. This module has no logic of its own, but indicates that the marked class has
+# certain methods.
+# @private
+module Cassandra
+  module CustomData
+    def self.included(base)
+      base.send :include, InstanceMethods
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      # @return [Cassandra::Types::Custom] the custom type that this class represents.
+      def type
+        raise NotImplementedError, "#{self.class} must implement the :type class method"
+      end
+
+      # Deserialize the given data into an instance of this domain object class.
+      # @param data [String] byte-array representation of a column value of this custom type.
+      # @return An instance of the domain object class.
+      # @raise [Cassandra::Errors::DecodingError] upon failure.
+      def deserialize(data)
+        raise NotImplementedError, "#{self.class} must implement the :deserialize class method"
+      end
+    end
+
+    module InstanceMethods
+      # Serialize this domain object into a byte array to send to C*.
+      # @return [String] byte-array representation of this domain object.
+      def serialize
+        raise NotImplementedError, "#{self.class} must implement the :serialize instance method"
+      end
+    end
+  end
+end

data/lib/cassandra/driver.rb

@@ -0,0 +1,260 @@
+# 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 Driver
+    def self.let(name, &block)
+      define_method(name) do
+        @instances.key?(name) ?
+            @instances[name] :
+            @instances[name] = instance_eval(&block)
+      end
+      define_method(:"#{name}=") { |object| @instances[name] = object }
+    end
+
+    let(:io_reactor)       { Ione::Io::IoReactor.new }
+    let(:cluster_registry) { Cluster::Registry.new(logger) }
+    let(:cluster_schema)   { Cluster::Schema.new }
+    let(:cluster_metadata) do
+      Cluster::Metadata.new(
+        cluster_registry,
+        cluster_schema,
+        {
+          'org.apache.cassandra.dht.Murmur3Partitioner' => murmur3_partitioner,
+          'org.apache.cassandra.dht.ByteOrderedPartitioner' => ordered_partitioner,
+          'org.apache.cassandra.dht.RandomPartitioner' => random_partitioner
+        }.freeze,
+        {
+          'SimpleStrategy' => simple_replication_strategy,
+          'NetworkTopologyStrategy' => network_topology_replication_strategy
+        }.freeze,
+        no_replication_strategy
+      )
+    end
+
+    let(:executor)         { Executors::ThreadPool.new(thread_pool_size) }
+    let(:futures_factory)  { Future::Factory.new(executor) }
+
+    let(:schema_fqcn_type_parser) { Cluster::Schema::FQCNTypeParser.new }
+    let(:schema_cql_type_parser)  { Cluster::Schema::CQLTypeParser.new }
+
+    let(:simple_replication_strategy) do
+      Cluster::Schema::ReplicationStrategies::Simple.new
+    end
+    let(:network_topology_replication_strategy) do
+      Cluster::Schema::ReplicationStrategies::NetworkTopology.new
+    end
+    let(:no_replication_strategy) do
+      Cluster::Schema::ReplicationStrategies::None.new
+    end
+
+    let(:murmur3_partitioner) { Cluster::Schema::Partitioners::Murmur3.new }
+    let(:ordered_partitioner) { Cluster::Schema::Partitioners::Ordered.new }
+    let(:random_partitioner)  { Cluster::Schema::Partitioners::Random.new }
+
+    let(:connector) do
+      Cluster::Connector.new(logger,
+                             io_reactor,
+                             cluster_registry,
+                             connection_options,
+                             execution_options)
+    end
+
+    let(:schema_fetcher) { create_schema_fetcher_picker }
+
+    let(:control_connection) do
+      Cluster::ControlConnection.new(logger,
+                                     io_reactor,
+                                     cluster_registry,
+                                     cluster_schema,
+                                     cluster_metadata,
+                                     profile_manager.default_profile.load_balancing_policy,
+                                     reconnection_policy,
+                                     address_resolution_policy,
+                                     connector,
+                                     connection_options,
+                                     schema_fetcher)
+    end
+
+    let(:cluster_klass) { Cluster }
+
+    let(:cluster) do
+      cluster_klass.new(logger,
+                        io_reactor,
+                        executor,
+                        control_connection,
+                        cluster_registry,
+                        cluster_schema,
+                        cluster_metadata,
+                        execution_options,
+                        connection_options,
+                        profile_manager,
+                        reconnection_policy,
+                        address_resolution_policy,
+                        connector,
+                        futures_factory,
+                        timestamp_generator)
+    end
+
+    let(:execution_options) do
+      Execution::Options.new(consistency: profile_manager.default_profile.consistency,
+                             trace: trace,
+                             page_size: page_size,
+                             timeout: profile_manager.default_profile.timeout,
+                             idempotent: false,
+                             load_balancing_policy: profile_manager.default_profile.load_balancing_policy,
+                             retry_policy: profile_manager.default_profile.retry_policy)
+    end
+
+    let(:connection_options) do
+      Cluster::Options.new(
+        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
+      )
+    end
+
+    let(:custom_types)              { [] }
+    let(:port)                      { 9042 }
+    let(:protocol_version)          { nil }
+    let(:allow_beta_protocol)       { false }
+    let(:connect_timeout)           { 10 }
+    let(:ssl)                       { false }
+    let(:logger)                    { NullLogger.new }
+    let(:compressor)                { nil }
+    let(:credentials)               { nil }
+    let(:auth_provider)             { nil }
+    let(:datacenter)                { nil }
+    let(:load_balancing_policy)     do
+      LoadBalancing::Policies::TokenAware.new(
+        LoadBalancing::Policies::DCAwareRoundRobin.new(datacenter, 0),
+        shuffle_replicas
+      )
+    end
+    let(:reconnection_policy) do
+      Reconnection::Policies::Exponential.new(0.5, 30, 2)
+    end
+    let(:retry_policy)              { Retry::Policies::Default.new }
+    let(:address_resolution_policy) { AddressResolution::Policies::None.new }
+    let(:consistency)               { :quorum }
+    let(:trace)                     { false }
+    let(:page_size)                 { 10000 }
+    let(:heartbeat_interval)        { 30 }
+    let(:idle_timeout)              { 60 }
+    let(:timeout)                   { 12 }
+    let(:synchronize_schema)        { true }
+    let(:schema_refresh_delay)      { 1 }
+    let(:schema_refresh_timeout)    { 10 }
+    let(:thread_pool_size)          { 4 }
+    let(:shuffle_replicas)          { true }
+    let(:nodelay)                   { true }
+    let(:timestamp_generator)       { nil }
+    let(:connections_per_local_node)  { nil }
+    let(:connections_per_remote_node) { nil }
+    let(:requests_per_connection) { nil }
+    let(:default_execution_profile) {
+      Cassandra::Execution::Profile.new(load_balancing_policy: load_balancing_policy,
+                                        retry_policy: retry_policy,
+                                        consistency: consistency,
+                                        timeout: timeout)
+    }
+    let(:execution_profiles) { {} }
+    let(:profile_manager) { Cassandra::Execution::ProfileManager.new(default_execution_profile, execution_profiles) }
+    let(:listeners) { [] }
+
+    def initialize(defaults = {})
+      @instances = defaults
+    end
+
+    def connect(addresses)
+      profile_manager.load_balancing_policies.each do |lbp|
+        lbp.setup(cluster)
+        cluster_registry.add_listener(lbp)
+      end
+
+      cluster_registry.add_listener(control_connection)
+      listeners.each do |listener|
+        cluster.register(listener)
+      end
+
+      logger.debug('Populating policies and listeners with initial endpoints')
+      addresses.each {|address| cluster_registry.host_found(address)}
+
+      logger.info('Establishing control connection')
+
+      promise = futures_factory.promise
+
+      control_connection.connect_async.on_complete do |f|
+        if f.resolved?
+          promise.fulfill(cluster)
+        else
+          f.on_failure do |e|
+            cluster.close_async
+            promise.break(e)
+          end
+        end
+      end
+
+      promise.future
+    end
+
+    private
+
+    def create_schema_fetcher_picker
+      picker = Cluster::Schema::Fetchers::MultiVersion.new(cluster_registry)
+
+      picker.when('1.2') do
+        Cluster::Schema::Fetchers::V1_2_x.new(schema_fqcn_type_parser, cluster_schema)
+      end
+      picker.when('2.0') do
+        Cluster::Schema::Fetchers::V2_0_x.new(schema_fqcn_type_parser, cluster_schema)
+      end
+      picker.when('2.1') do
+        Cluster::Schema::Fetchers::V2_1_x.new(schema_fqcn_type_parser, cluster_schema)
+      end
+      picker.when('2.2') do
+        Cluster::Schema::Fetchers::V2_2_x.new(schema_fqcn_type_parser, cluster_schema)
+      end
+      picker.when('3.') do
+        Cluster::Schema::Fetchers::V3_0_x.new(schema_cql_type_parser, cluster_schema)
+      end
+      picker.when('4.') do
+        Cluster::Schema::Fetchers::V3_0_x.new(schema_cql_type_parser, cluster_schema)
+      end
+
+      picker
+    end
+  end
+end