cassandra-driver 2.1.7 → 3.0.0.beta.1

data/lib/cassandra/execution/options.rb

@@ -49,6 +49,19 @@ module Cassandra
       # @see Cassandra::Result#paging_state
       attr_reader :paging_state
 
+      # @return [nil, Hash<String, String>] custom outgoing payload, a map of
+      # string and byte buffers.
+      #
+      # @see https://github.com/apache/cassandra/blob/33f1edcce97779c971d4f78712a9a8bf014ffbbc/doc/native_protocol_v4.spec#L127-L133 Description of custom payload in Cassandra native protocol v4.
+      # @see https://datastax.github.io/java-driver/features/custom_payloads/#enabling-custom-payloads-on-c-nodes Enabling custom payloads on Cassandra nodes.
+      #
+      # @example Sending a custom payload
+      #   result = session.execute(payload: {
+      #              'some key' => Cassandra::Protocol::CqlByteBuffer.new
+      #                                                              .append_string('some value')
+      #            })
+      attr_reader :payload
+
       # @private
       def initialize(options)
         consistency        = options[:consistency]
@@ -59,6 +72,8 @@ module Cassandra
         paging_state       = options[:paging_state]
         arguments          = options[:arguments]
         type_hints         = options[:type_hints]
+        idempotent         = options[:idempotent]
+        payload            = options[:payload]
 
         Util.assert_one_of(CONSISTENCIES, consistency) { ":consistency must be one of #{CONSISTENCIES.inspect}, #{consistency.inspect} given" }
 
@@ -94,6 +109,17 @@ module Cassandra
           Util.assert_instance_of_one_of([::Array, ::Hash], type_hints) { ":type_hints must be an Array or a Hash, #{type_hints.inspect} given" }
         end
 
+        unless payload.nil?
+          Util.assert_instance_of(::Hash, payload) { ":payload must be a Hash" }
+          Util.assert_not_empty(payload) { ":payload must not be empty" }
+          Util.assert(payload.size <= 65535) { ":payload cannot contain more than 65535 key/value pairs" }
+
+          payload = payload.each_with_object(::Hash.new) do |(key, value), payload|
+                      payload[String(key)] = String(value)
+                    end
+          payload.freeze
+        end
+
         @consistency        = consistency
         @page_size          = page_size
         @trace              = !!trace
@@ -102,6 +128,8 @@ module Cassandra
         @paging_state       = paging_state
         @arguments          = arguments
         @type_hints         = type_hints
+        @idempotent         = !!idempotent
+        @payload            = payload
       end
 
       # @return [Boolean] whether request tracing was enabled
@@ -109,6 +137,12 @@ module Cassandra
         @trace
       end
 
+      # @return [Boolean] whether statement can be retried on timeout
+      def idempotent?
+        @idempotent
+      end
+
+      # @private
       def eql?(other)
         other.is_a?(Options) &&
           other.consistency == @consistency &&

data/lib/cassandra/execution/trace.rb

@@ -39,6 +39,7 @@ module Cassandra
           @thread         = thread
         end
 
+        # @private
         def ==(other)
           other == @id
         end
@@ -53,41 +54,61 @@ module Cassandra
 
       # @private
       def initialize(id, client)
-        @id     = id
-        @client = client
+        @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
 
         mon_initialize
       end
 
-      # Returns the ip of coordinator node. Typically the same as {Cassandra::Execution::Info#hosts}`.last`
+      # 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 @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 @duration
+        load unless @loaded
 
         @duration
       end
 
       def parameters
-        load unless @parameters
+        load unless @loaded
 
         @parameters
       end
 
       def request
-        load unless @request
+        load unless @loaded
 
         @request
       end
 
       def started_at
-        load unless @started_at
+        load unless @loaded
 
         @started_at
       end
@@ -96,11 +117,12 @@ module Cassandra
       #
       # @return [Array<Cassandra::Execution::Trace::Event>] events
       def events
-        load_events unless @events
+        load_events unless @loaded_events
 
         @events
       end
 
+      # @private
       def inspect
         "#<#{self.class.name}:0x#{self.object_id.to_s(16)} @id=#{@id.inspect}>"
       end
@@ -117,7 +139,16 @@ module Cassandra
         synchronize do
           return if @loaded
 
-          data = @client.query(Statements::Simple.new(SELECT_SESSION % @id), VOID_OPTIONS).get.first
+          attempt = 1
+          data    = @client.query(Statements::Simple.new(SELECT_SESSION % @id), VOID_OPTIONS).get.first
+
+          while data.nil? && attempt <= 5
+            sleep(attempt * 0.4)
+            data = @client.query(Statements::Simple.new(SELECT_SESSION % @id), VOID_OPTIONS).get.first
+            break if data
+            attempt += 1
+          end
+
           raise ::RuntimeError, "unable to load trace #{@id}" if data.nil?
 
           @coordinator = data['coordinator']
@@ -125,6 +156,7 @@ module Cassandra
           @parameters  = data['parameters']
           @request     = data['request']
           @started_at  = data['started_at']
+          @client_ip   = data['client']
           @loaded      = true
         end
 

data/lib/cassandra/function.rb

@@ -0,0 +1,150 @@
+# encoding: utf-8
+
+#--
+# Copyright 2013-2015 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.has_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 { |argument| argument.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#{self.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 << ")"
+      if @called_on_null
+        cql << "\n  CALLED ON NULL INPUT"
+      else
+        cql << "\n  RETURNS NULL ON NULL INPUT"
+      end
+      cql << "\n  RETURNS #{@type}"
+      cql << "\n  LANGUAGE #{@language}"
+      cql << "\n  AS $$#{@body}$$"
+      cql << ";"
+    end
+  end
+end

data/lib/cassandra/future.rb

@@ -51,10 +51,12 @@ module Cassandra
         @error = error
       end
 
-      def get
+      def get(timeout = nil)
         raise(@error, @error.message, @error.backtrace)
       end
 
+      alias :join :get
+
       def on_success
         raise ::ArgumentError, "no block given" unless block_given?
         self
@@ -81,10 +83,6 @@ module Cassandra
         self
       end
 
-      def join
-        self
-      end
-
       def then
         raise ::ArgumentError, "no block given" unless block_given?
         self
@@ -109,10 +107,12 @@ module Cassandra
         @value = value
       end
 
-      def get
+      def get(timeout = nil)
         @value
       end
 
+      alias :join :get
+
       def on_success
         raise ::ArgumentError, "no block given" unless block_given?
         yield(@value) rescue nil
@@ -356,23 +356,23 @@ module Cassandra
     end
 
     # Returns future value or raises future error
-    # @note This method blocks until a future is resolved
-    # @raise [Exception] error used to resolve this future if any
-    # @return [Object] value used to resolve this future if any
-    def get
-      @signal.get
-      
+    #
+    # @note This method blocks until a future is resolved or a times out
+    #
+    # @param timeout [nil, Numeric] a maximum number of seconds to block
+    #   current thread for while waiting for this future to resolve. Will
+    #   wait indefinitely if passed `nil`.
+    #
+    # @raise [Errors::TimeoutError] raised when wait time exceeds the timeout
+    # @raise [Exception] raises when the future has been resolved with an
+    #   error. The original exception will be raised.
+    #
+    # @return [Object] the value that the future has been resolved with
+    def get(timeout = nil)
+      @signal.get(timeout)
     end
 
-    # Block until the future has been resolved
-    # @note This method blocks until a future is resolved
-    # @note This method won't raise any errors or return anything but the
-    #   future itself
-    # @return [self]
-    def join
-      @signal.join
-      self
-    end
+    alias :join :get
   end
 
   # @private
@@ -550,28 +550,59 @@ module Cassandra
         self
       end
 
-      def join
-        return unless @state == :pending
-
-        synchronize do
-          return unless @state == :pending
-
-          @waiting += 1
-          @cond.wait while @state == :pending
-          @waiting -= 1
+      # @param timeout [nil, Numeric] a maximum number of seconds to block
+      #   current thread for while waiting for this future to resolve. Will
+      #   wait indefinitely if passed `nil`.
+      #
+      # @raise [ArgumentError] raised when a negative timeout is given
+      # @raise [Errors::TimeoutError] raised when wait time exceeds the timeout
+      # @raise [Exception] raises when the future has been resolved with an
+      #   error. The original exception will be raised.
+      #
+      # @return [Object] the value that the future has been resolved with
+      def get(timeout = nil)
+        timeout = timeout && Float(timeout)
+
+        if timeout
+          raise ::ArgumentError, "timeout cannot be negative, #{timeout.inspect} given" if timeout < 0
+
+          start    = ::Time.now
+          now      = start
+          deadline = start + timeout
         end
 
-        nil
-      end
+        if @state == :pending
+          synchronize do
+            if @state == :pending
+              @waiting += 1
+              while @state == :pending
+                if deadline
+                  @cond.wait(deadline - now)
+                  now = ::Time.now
+                  break if now >= deadline
+                else
+                  @cond.wait
+                end
+              end
+              @waiting -= 1
+            end
+          end
 
-      def get
-        join if @state == :pending
+          if @state == :pending
+            total_wait = deadline - start
+            raise Errors::TimeoutError, "Future did not complete within #{timeout.inspect} seconds. Wait time: #{total_wait.inspect}"
+          end
+        end
 
-        raise(@error, @error.message, @error.backtrace) if @state == :broken
+        if @state == :broken
+          raise(@error, @error.message, @error.backtrace)
+        end
 
         @value
       end
 
+      alias :join :get
+
       def add_listener(listener)
         if @state == :pending
           synchronize do