yugabyte-ycql-driver 3.2.3.1

data/lib/cassandra/address_resolution/policies.rb

@@ -0,0 +1,2 @@
+require 'cassandra/address_resolution/policies/none'
+require 'cassandra/address_resolution/policies/ec2_multi_region'

data/lib/cassandra/address_resolution/policies/ec2_multi_region.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
+  module AddressResolution
+    module Policies
+      # This policy resolves private ips of the hosts in the same datacenter and
+      # public ips of hosts in other datacenters.
+      #
+      # @note Initializing this policy is not necessary, you should just pass
+      #   `:ec_multi_region` to the `:address_resolution` option of
+      #   {Cassandra.cluster}
+      class EC2MultiRegion
+        # @private
+        def initialize(resolver = Resolv)
+          @resolver = resolver
+        end
+
+        # Returns ip address after a double DNS lookup. First, it will get
+        # hostname from a given ip, then resolve the resulting hostname. This
+        # policy works because AWS public hostnames resolve to a private ip
+        # address within the same datacenter.
+        #
+        # @param address [IPAddr] node ip address from Cassandra's system table
+        #
+        # @return [IPAddr] private ip withing the same datacenter, public ip
+        #   otherwise. Returns original address if DNS lookups fail.
+        def resolve(address)
+          @resolver.each_name(Resolv::DNS::Name.create(address.reverse)) do |name|
+            @resolver.each_address(name) do |addr|
+              return ::IPAddr.new(addr)
+            end
+          end
+
+          # default to original address if reverse DNS lookup failed
+          address
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/address_resolution/policies/none.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
+  module AddressResolution
+    module Policies
+      # The default address resolution policy. Always returns original address.
+      class None
+        # Returns original address.
+        #
+        # @param address [IPAddr] node ip address from Cassandra's system table
+        #
+        # @return [IPAddr] same as `address`
+        def resolve(address)
+          address
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/aggregate.rb

@@ -0,0 +1,123 @@
+# 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 user defined aggregate
+  # @see Cassandra::Keyspace#each_aggregate
+  # @see Cassandra::Keyspace#aggregate
+  # @see Cassandra::Keyspace#has_aggregate?
+  class Aggregate
+    # @private
+    attr_reader :keyspace
+    # @return [String] aggregate name
+    attr_reader :name
+    # @return [Cassandra::Type] aggregate return type
+    attr_reader :type
+    # @return [Array<Cassandra::Type>] aggregate argument types
+    attr_reader :argument_types
+    # @return [Cassandra::Type] aggregate state type
+    attr_reader :state_type
+    # @return [Object, nil] the initial value of the aggregate state or nil
+    attr_reader :initial_state
+    # @return [Cassandra::Function] the state function used by this aggregate
+    attr_reader :state_function
+    # @return [Cassandra::Function] the final function used by this aggregate
+    attr_reader :final_function
+
+    # @private
+    def initialize(keyspace,
+                   name,
+                   type,
+                   argument_types,
+                   state_type,
+                   initial_state,
+                   state_function,
+                   final_function)
+      @keyspace       = keyspace
+      @name           = name
+      @type           = type
+      @argument_types = argument_types
+      @state_type     = state_type
+      @initial_state  = initial_state
+      @state_function = state_function
+      @final_function = final_function
+    end
+
+    # @private
+    def eql?(other)
+      other.is_a?(Aggregate) && \
+        @keyspace == other.keyspace && \
+        @name == other.name && \
+        @type == other.type && \
+        @argument_types == other.argument_types && \
+        @state_type == other.state_type && \
+        @initial_state == other.initial_state && \
+        @state_function == other.state_function && \
+        @final_function == other.final_function
+    end
+    alias == eql?
+
+    # @private
+    def hash
+      @hash ||= begin
+        h = 17
+        h = 31 * h + @keyspace.hash
+        h = 31 * h + @name.hash
+        h = 31 * h + @type.hash
+        h = 31 * h + @argument_types.hash
+        h = 31 * h + @state_type.hash
+        h = 31 * h + @initial_state.hash
+        h = 31 * h + @state_function.hash
+        h = 31 * h + @final_function.hash
+        h
+      end
+    end
+
+    # @private
+    def inspect
+      "#<Cassandra::Aggregate:0x#{object_id.to_s(16)} " \
+          "@keyspace=#{@keyspace.inspect}, " \
+          "@name=#{@name.inspect}, " \
+          "@type=#{@type.inspect}, " \
+          "@argument_types=#{@argument_types.inspect}, " \
+          "@initial_state=#{@initial_state.inspect}, " \
+          "@state_function=#{@state_function.inspect}, " \
+          "@final_function=#{@final_function.inspect}>"
+    end
+
+    # @return [String] a cql representation of this aggregate
+    def to_cql
+      cql = 'CREATE AGGREGATE simplex.average('
+      first = true
+      @argument_types.each do |type|
+        if first
+          first = false
+        else
+          cql << ', '
+        end
+        cql << type.to_s
+      end
+      cql << ')'
+      cql << "\n  SFUNC #{@state_function.name}"
+      cql << "\n  STYPE #{@state_type}"
+      cql << "\n  FINALFUNC #{@final_function.name}" if @final_function
+      cql << "\n  INITCOND #{@initial_state}"
+      cql << ';'
+    end
+  end
+end

data/lib/cassandra/argument.rb

@@ -0,0 +1,51 @@
+# 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 function argument
+  class Argument
+    # @return [String] column name
+    attr_reader :name
+    # @return [Cassandra::Type] column type
+    attr_reader :type
+
+    # @private
+    def initialize(name, type)
+      @name = name
+      @type = type
+    end
+
+    # @private
+    def eql?(other)
+      other.is_a?(Argument) && \
+        @name == other.name && \
+        @type == other.type
+    end
+    alias == eql?
+
+    # @private
+    def hash
+      @hash ||= begin
+        h = 17
+        h = 31 * h + @name.hash
+        h = 31 * h + @type.hash
+        h
+      end
+    end
+  end
+end

data/lib/cassandra/attr_boolean.rb

@@ -0,0 +1,33 @@
+# 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.
+#++
+
+# This file monkey-patches Module to have an attr_boolean method to make it easy
+# for classes to define boolean instance variables with "foo?" reader methods.
+# Inspired by http://stackoverflow.com/questions/4013591/attr-reader-with-question-mark-in-a-name
+module Cassandra
+  module AttrBoolean
+    def attr_boolean(*names)
+      names.each do |name|
+        define_method(:"#{name}?") do
+          res = instance_variable_get(:"@#{name}")
+          !res.nil? && res != false
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/auth.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 Auth
+    # An auth provider is a factory for {Cassandra::Auth::Authenticator authenticator}
+    # instances (or objects matching that interface). Its {#create_authenticator} will
+    # be called once for each connection that requires authentication.
+    #
+    # If the authentication requires keeping state, keep that in the
+    # authenticator instances, not in the auth provider.
+    #
+    # @note Creating an authenticator must absolutely not block, or the whole
+    #   connection process will block.
+    #
+    # @abstract Auth providers given to {Cassandra.cluster} don't need to be
+    #   subclasses of this class, but need to implement the same methods. This
+    #   class exists only for documentation purposes.
+    #
+    # @see Cassandra::Auth::Providers
+    class Provider
+      # @!method create_authenticator(authentication_class, host)
+      #
+      # Create a new authenticator object. This method will be called once per
+      # connection that requires authentication. The auth provider can create
+      # different authenticators for different authentication classes, or return
+      # nil if it does not support the authentication class.
+      #
+      # @note This method must absolutely not block.
+      #
+      # @param authentication_class [String] the authentication class used by
+      #   the server.
+      # @param host [Cassandra::Host] the node to whom we're authenticating.
+      #
+      # @return [Cassandra::Auth::Authenticator, nil] an object with an
+      #   interface matching {Cassandra::Auth::Authenticator} or `nil` if the
+      #   authentication class is not supported.
+    end
+
+    # An authenticator handles the authentication challenge/response cycles of
+    # a single connection. It can be stateful, but it must not for any reason
+    # block. If any of the method calls block, the whole connection process
+    # will be blocked.
+    #
+    # @abstract Authenticators created by auth providers don't need to be
+    #   subclasses of this class, but need to implement the same methods. This
+    #   class exists only for documentation purposes.
+    #
+    # @see https://github.com/apache/cassandra/blob/cassandra-2.0.16/doc/native_protocol_v2.spec#L257-L273 Cassandra
+    #   native protocol v2 SASL authentication
+    # @see Cassandra::Auth::Provider#create_authenticator
+    class Authenticator
+      # @!method initial_response
+      #
+      # This method must return the initial authentication token to be sent to
+      # the server.
+      #
+      # @note This method must absolutely not block.
+      #
+      # @return [String] the initial authentication token
+
+      # @!method challenge_response(token)
+      #
+      # If the authentication requires multiple challenge/response cycles this
+      # method will be called when a challenge is returned by the server. A
+      # response token must be created and will be sent back to the server.
+      #
+      # @note This method must absolutely not block.
+      #
+      # @param token [String] a challenge token sent by the server
+      # @return [String] the authentication token to send back to the server
+
+      # @!method authentication_successful(token)
+      #
+      # Called when the authentication is successful.
+      #
+      # @note This method must absolutely not block.
+      #
+      # @param token [String] a token sent by the server
+      # @return [void]
+    end
+  end
+end
+
+require 'cassandra/auth/providers'

data/lib/cassandra/auth/providers.rb

@@ -0,0 +1,17 @@
+#--
+# 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.
+#++
+
+require 'cassandra/auth/providers/password'

data/lib/cassandra/auth/providers/password.rb

@@ -0,0 +1,65 @@
+# 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 Auth
+    module Providers
+      # Auth provider used for Cassandra's built in authentication.
+      #
+      # @note No need to instantiate this class manually, use `:username` and
+      #   `:password` options when calling {Cassandra.cluster} and one will be
+      #   created automatically for you.
+      class Password < Provider
+        # Authenticator used for Cassandra's built in authentication,
+        # see {Cassandra::Auth::Providers::Password}
+        # @private
+        class Authenticator
+          # @private
+          def initialize(username, password)
+            @username = username
+            @password = password
+          end
+
+          def initial_response
+            "\x00#{@username}\x00#{@password}"
+          end
+
+          def challenge_response(token)
+          end
+
+          def authentication_successful(token)
+          end
+        end
+
+        # @param username [String] username to use for authentication to Cassandra
+        # @param password [String] password to use for authentication to Cassandra
+        def initialize(username, password)
+          @username = username
+          @password = password
+        end
+
+        # Returns a Password Authenticator
+        # @param authentication_class [String] ignored
+        # @return [Cassandra::Auth::Authenticator]
+        def create_authenticator(authentication_class)
+          Authenticator.new(@username, @password)
+        end
+      end
+    end
+  end
+end