yugabyte-ycql-driver 3.2.3.1

data/lib/cassandra/execution/profile_manager.rb

@@ -0,0 +1,71 @@
+# 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 Execution
+    # @private
+    class ProfileManager
+      attr_reader :profiles
+      attr_reader :load_balancing_policies
+
+      def initialize(default_profile, profiles)
+        # default_profile is the default profile that we constructed internally. However, the user can override it
+        # with their own :default profile. If that happens, ignore the internally generated default profile.
+
+        profiles[:default] = default_profile unless profiles.key?(:default)
+
+        # Save off all of the load-balancing policies for easy access.
+        @load_balancing_policies = Set.new
+        profiles.each do |name, profile|
+          @load_balancing_policies << profile.load_balancing_policy
+        end
+        @profiles = profiles
+      end
+
+      def default_profile
+        @profiles[:default]
+      end
+
+      def distance(host)
+        # Return the min distance to the host, as per each lbp.
+        distances = Set.new
+        @load_balancing_policies.each do |lbp|
+          distances.add(lbp.distance(host))
+        end
+        return :local if distances.include?(:local)
+        return :remote if distances.include?(:remote)
+
+        # Fall back to ignore the host.
+        :ignore
+      end
+
+      # NOTE: It's only safe to call add_profile when setting up the cluster object. In particular,
+      # this is only ok before calling Driver#connect.
+      def add_profile(name, profile)
+        @profiles[name] = profile
+        @load_balancing_policies << profile.load_balancing_policy
+      end
+
+      # @private
+      def inspect
+        "#<#{self.class.name}:0x#{object_id.to_s(16)} " \
+          "profiles=#{@profiles.inspect}>"
+      end
+    end
+  end
+end

data/lib/cassandra/execution/trace.rb

@@ -0,0 +1,192 @@
+# 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 Execution
+    class Trace
+      class Event
+        # @return [Cassandra::Uuid] event uuid
+        attr_reader :id
+
+        # @return [String] description of activity
+        attr_reader :activity
+
+        attr_reader :source
+        attr_reader :source_elapsed
+        attr_reader :thread
+
+        # @private
+        def initialize(id, activity, source, source_elapsed, thread)
+          @id             = id
+          @activity       = activity
+          @source         = source
+          @source_elapsed = source_elapsed
+          @thread         = thread
+        end
+
+        # @private
+        def ==(other)
+          other == @id
+        end
+
+        alias eql? ==
+      end
+
+      include MonitorMixin
+
+      # @return [Cassandra::Uuid] trace id
+      attr_reader :id
+
+      # @private
+      def initialize(id, client, load_balancing_policy)
+        @id            = id
+        @client        = client
+        @coordinator   = nil
+        @duration      = nil
+        @parameters    = nil
+        @request       = nil
+        @started_at    = nil
+        @events        = nil
+        @client_ip     = nil
+        @loaded        = false
+        @loaded_events = false
+        @load_balancing_policy = load_balancing_policy
+
+        mon_initialize
+      end
+
+      # Returns the ip of coordinator node. Typically the same as
+      # {Cassandra::Execution::Info#hosts}`.last`
+      #
+      # @return [IPAddr] ip of the coordinator node
+      def coordinator
+        load unless @loaded
+
+        @coordinator
+      end
+
+      # Returns the ip of the client node, the node that ran the driver
+      # instance that started tracing.
+      #
+      # @return [IPAddr, nil] ip of the client node running the driver
+      def client
+        load unless @loaded
+
+        @client_ip
+      end
+
+      def duration
+        load unless @loaded
+
+        @duration
+      end
+
+      def parameters
+        load unless @loaded
+
+        @parameters
+      end
+
+      def request
+        load unless @loaded
+
+        @request
+      end
+
+      def started_at
+        load unless @loaded
+
+        @started_at
+      end
+
+      # Returns all trace events
+      #
+      # @return [Array<Cassandra::Execution::Trace::Event>] events
+      def events
+        load_events unless @loaded_events
+
+        @events
+      end
+
+      # @private
+      def inspect
+        "#<#{self.class.name}:0x#{object_id.to_s(16)} @id=#{@id.inspect}>"
+      end
+
+      private
+
+      # @private
+      SELECT_SESSION = 'SELECT * FROM system_traces.sessions WHERE session_id = %s'.freeze
+      # @private
+      SELECT_EVENTS  = 'SELECT * FROM system_traces.events WHERE session_id = %s'.freeze
+
+      # @private
+      def load
+        synchronize do
+          return if @loaded
+
+          attempt = 1
+          data    = @client.query(Statements::Simple.new(SELECT_SESSION % @id),
+                                  VOID_OPTIONS.override(load_balancing_policy: @load_balancing_policy)).get.first
+
+          while data.nil? && attempt <= 5
+            sleep(attempt * 0.4)
+            data = @client.query(Statements::Simple.new(SELECT_SESSION % @id),
+                                 VOID_OPTIONS.override(load_balancing_policy: @load_balancing_policy)).get.first
+            break if data
+            attempt += 1
+          end
+
+          raise ::RuntimeError, "unable to load trace #{@id}" if data.nil?
+
+          @coordinator = data['coordinator']
+          @duration    = data['duration']
+          @parameters  = data['parameters']
+          @request     = data['request']
+          @started_at  = data['started_at']
+          @client_ip   = data['client']
+          @loaded      = true
+        end
+
+        nil
+      end
+
+      # @private
+      def load_events
+        synchronize do
+          return if @loaded_events
+
+          @events = []
+
+          @client.query(Statements::Simple.new(SELECT_EVENTS % @id),
+                        VOID_OPTIONS.override(load_balancing_policy: @load_balancing_policy)).get.each do |row|
+            @events << Event.new(row['event_id'],
+                                 row['activity'],
+                                 row['source'],
+                                 row['source_elapsed'],
+                                 row['thread'])
+          end
+
+          @events.freeze
+
+          @loaded_events = true
+        end
+      end
+    end
+  end
+end

data/lib/cassandra/executors.rb

@@ -0,0 +1,113 @@
+# 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 Executors
+    class ThreadPool
+      # @private
+      class Task
+        def initialize(*args, &block)
+          @args    = args
+          @block   = block
+        end
+
+        def run
+          @block.call(*@args)
+        rescue ::Exception
+        ensure
+          @args = @block = nil
+        end
+      end
+
+      include MonitorMixin
+
+      def initialize(size)
+        mon_initialize
+
+        @cond    = new_cond
+        @tasks   = ::Array.new
+        @waiting = 0
+        @term    = false
+        @pool    = ::Array.new(size, &method(:spawn_thread))
+      end
+
+      def execute(*args, &block)
+        synchronize do
+          return if @term
+
+          @tasks << Task.new(*args, &block)
+          @cond.signal if @waiting > 0
+        end
+
+        nil
+      end
+
+      def shutdown
+        execute do
+          synchronize do
+            @term = true
+            @cond.broadcast if @waiting > 0
+          end
+        end
+
+        nil
+      end
+
+      private
+
+      def spawn_thread(i)
+        Thread.new(&method(:run))
+      end
+
+      def run
+        Thread.current.abort_on_exception = true
+
+        loop do
+          tasks = nil
+
+          synchronize do
+            @waiting += 1
+            @cond.wait while !@term && @tasks.empty?
+            @waiting -= 1
+
+            return if @tasks.empty?
+
+            tasks  = @tasks
+            @tasks = ::Array.new
+          end
+
+          tasks.each(&:run).clear
+        end
+      end
+    end
+
+    class SameThread
+      def execute(*args, &block)
+        yield(*args)
+        nil
+      rescue ::Exception
+        nil
+      end
+
+      def shutdown
+        nil
+      end
+    end
+  end
+end

data/lib/cassandra/function.rb

@@ -0,0 +1,156 @@
+# 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 function
+  # @see Cassandra::Keyspace#each_function
+  # @see Cassandra::Keyspace#function
+  # @see Cassandra::Keyspace#has_function?
+  class Function
+    # @private
+    attr_reader :keyspace
+    # @return [String] function name
+    attr_reader :name
+    # @return [String] function language
+    attr_reader :language
+    # @return [Cassandra::Type] function return type
+    attr_reader :type
+    # @return [String] function body
+    attr_reader :body
+
+    # @private
+    def initialize(keyspace, name, language, type, arguments, body, called_on_null)
+      @keyspace       = keyspace
+      @name           = name
+      @language       = language
+      @type           = type
+      @arguments      = arguments
+      @body           = body
+      @called_on_null = called_on_null
+
+      # Build up an arguments hash keyed on arg-name.
+      @arguments_hash = @arguments.each_with_object({}) do |arg, h|
+        h[arg.name] = arg
+      end
+    end
+
+    # @return [Boolean] whether this function will be called on null input
+    def called_on_null?
+      @called_on_null
+    end
+
+    # @param name [String] argument name
+    # @return [Boolean] whether this function has a given argument
+    def has_argument?(name)
+      @arguments_hash.key?(name)
+    end
+
+    # @param name [String] argument name
+    # @return [Cassandra::Argument, nil] an argument or nil
+    def argument(name)
+      @arguments_hash[name]
+    end
+
+    # Yield or enumerate each argument defined in this function
+    # @overload each_argument
+    #   @yieldparam argument [Cassandra::Argument] current argument
+    #   @return [Cassandra::Table] self
+    # @overload each_argument
+    #   @return [Array<Cassandra::Argument>] a list of arguments
+    def each_argument(&block)
+      if block_given?
+        @arguments.each(&block)
+        self
+      else
+        # We return a dup of the arguments so that the caller can manipulate
+        # the array however they want without affecting the source.
+        @arguments.dup
+      end
+    end
+    alias arguments each_argument
+
+    # Get the list of argument types for this function.
+    # @return [Array<Cassandra::Type>] a list of argument types.
+    def argument_types
+      @arguments.map(&:type)
+    end
+
+    # @private
+    def eql?(other)
+      other.is_a?(Function) && \
+        @keyspace == other.keyspace && \
+        @name == other.name && \
+        @language == other.language && \
+        @type == other.type && \
+        @arguments == other.arguments && \
+        @body == other.body && \
+        @called_on_null == other.called_on_null?
+    end
+    alias == eql?
+
+    # @private
+    def hash
+      @hash ||= begin
+        h = 17
+        h = 31 * h + @keyspace.hash
+        h = 31 * h + @name.hash
+        h = 31 * h + @language.hash
+        h = 31 * h + @type.hash
+        h = 31 * h + @arguments.hash
+        h = 31 * h + @body.hash
+        h = 31 * h + @called_on_null.hash
+        h
+      end
+    end
+
+    # @private
+    def inspect
+      "#<Cassandra::Function:0x#{object_id.to_s(16)} " \
+          "@keyspace=#{@keyspace.inspect}, " \
+          "@name=#{@name.inspect}, " \
+          "@language=#{@language.inspect}, " \
+          "@type=#{@type.inspect}, " \
+          "@arguments=#{@arguments.inspect} " \
+          "@body=#{@body.inspect}>"
+    end
+
+    # @return [String] a cql representation of this function
+    def to_cql
+      cql = "CREATE FUNCTION #{Util.escape_name(@keyspace)}.#{Util.escape_name(@name)}("
+      first = true
+      @arguments.each do |argument|
+        if first
+          first = false
+        else
+          cql << ', '
+        end
+        cql << "#{argument.name} #{argument.type}"
+      end
+      cql << ')'
+      cql << if @called_on_null
+               "\n  CALLED ON NULL INPUT"
+             else
+               "\n  RETURNS NULL ON NULL INPUT"
+             end
+      cql << "\n  RETURNS #{@type}"
+      cql << "\n  LANGUAGE #{@language}"
+      cql << "\n  AS $$#{@body}$$"
+      cql << ';'
+    end
+  end
+end