rethinkdb 1.16.0.1 → 2.0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f11a0723b23f0f85750e89da95f68a9bc50f70c
-  data.tar.gz: fc81d994d1b54b887a7228f7d80b8c5a07a9016c
+  metadata.gz: dae3d5d3b038eca2d30595a269cb259351d5bd98
+  data.tar.gz: 7a03e7c5f271bbb2a7e2e63f74a2757864c4cdbb
 SHA512:
-  metadata.gz: ef85ef58f60f5ab17790c61dc4121943cc4d29fad9cea95f16dda9c6338865be98bbdab496ec1cbbc7671728fd10f8be397be3c07ba39548d0ceda4efc306681
-  data.tar.gz: d8a59acf79a53e9ccc8d9e20b4ebe8f84d804003270be43e203e5204589ab435ceb4b167e732a216cf8dcddfa4406b727579dddddf3fa9d5249fb69f3af01091
+  metadata.gz: 308251a1089f50555e2e8177af64235bea9b5a36d35615aca7852f8f72530f17cb0c70569d6a727012aad0f273c6912262cedd9e6b6e1748d60d59e5ec4feb91
+  data.tar.gz: 6f31e8e16757cdaa9fc98137fd732323fa32c7d03c0af3edc2fcad299dfa9dff0c3bad2db838e2e7db1426c07bf3ed3729b8c723b38d3f784396722b3ccfbe5a

data/lib/exc.rb

@@ -1,30 +1,6 @@
 module RethinkDB
-  class RqlError < RuntimeError; end
-  class RqlRuntimeError < RqlError; end
-  class RqlDriverError < RqlError; end
-  class RqlCompileError < RqlError; end
-
-  # class Error < StandardError
-  #   def initialize(msg, bt)
-  #     @msg = msg
-  #     @bt = bt
-  #     @pp_query_bt = "UNIMPLEMENTED #{bt.inspect}"
-  #     super inspect
-  #   end
-  #   def inspect
-  #     "#{@msg}\n#{@pp_query_bt}"
-  #   end
-  #   attr_accessor :msg, :bt, :pp_query_bt
-  # end
-
-  # class Connection_Error < Error; end
-
-  # class Compile_Error < Error; end
-  # class Malformed_Protobuf_Error < Compile_Error; end
-  # class Malformed_Query_Error < Compile_Error; end
-
-  # class Runtime_Error < Error; end
-  # class Data_Error < Runtime_Error; end
-  # class Type_Error < Data_Error; end
-  # class Resource_Error < Runtime_Error; end
+  RqlError        = Class.new(RuntimeError)
+  RqlRuntimeError = Class.new(RqlError)
+  RqlDriverError  = Class.new(RqlError)
+  RqlCompileError = Class.new(RqlError)
 end

data/lib/func.rb

@@ -60,8 +60,8 @@ module RethinkDB
       :mul => :*,
       :div => :/,
       :mod => :%,
-      :any => [:"|", :or],
-      :all => [:"&", :and],
+      :or => :"|",
+      :and => :"&",
       :order_by => :orderby,
       :concat_map => :concatmap,
       :for_each => :foreach,
@@ -82,7 +82,7 @@ module RethinkDB
 
         if [:<, :<=, :>, :>=, :+, :-, :*, :/, :%].include?(__method__)
           a.each {|arg|
-            if arg.class == RQL && arg.bitop
+            if arg.is_a?(RQL) && arg.bitop
               err = "Calling #{__method__} on result of infix bitwise operator:\n" +
                 "#{arg.inspect}.\n" +
                 "This is almost always a precedence error.\n" +
@@ -94,7 +94,7 @@ module RethinkDB
         end
 
         if (opt_offset = @@optarg_offsets[termtype.downcase])
-          if opt_offset.class == Hash
+          if opt_offset.is_a?(Hash)
             opt_offset = opt_offset[b ? :with_block : :without]
           end
           # TODO: This should drop the Hash comparison or at least
@@ -102,7 +102,7 @@ module RethinkDB
           # Any time one of these operations is changed to support a
           # hash argument, we'll have to remember to fix
           # @@optarg_offsets, otherwise.
-          optargs = a.delete_at(opt_offset) if a[opt_offset].class == Hash
+          optargs = a.delete_at(opt_offset) if a[opt_offset].is_a?(Hash)
         end
 
         args = ((@body != RQL) ? [self] : []) + a + (b ? [new_func(&b)] : [])
@@ -131,7 +131,7 @@ module RethinkDB
     def -@; RQL.new.sub(0, self); end
 
     def [](ind)
-      if ind.class == Range
+      if ind.is_a?(Range)
         return slice(ind.begin, ind.end, :right_bound =>
                      (ind.exclude_end? ? 'open' : 'closed'))
       else

data/lib/net.rb

@@ -1,3 +1,5 @@
+require 'monitor'
+require 'set'
 require 'socket'
 require 'thread'
 require 'timeout'
@@ -9,14 +11,285 @@ module RethinkDB
     end
   end
 
+  class EM_Guard
+    @@mutex = Mutex.new
+    @@registered = false
+    @@conns = Set.new
+    def self.register(conn)
+      @@mutex.synchronize {
+        if !@@registered
+          @@registered = true
+          EM.add_shutdown_hook {
+            EM_Guard.remove_em_waiters
+          }
+        end
+        @@conns += [conn]
+      }
+    end
+    def self.unregister(conn)
+      @@mutex.synchronize {
+        @@conns -= [conn]
+      }
+    end
+    def self.remove_em_waiters
+      old_conns = Set.new
+      @@mutex.synchronize {
+        @@registered = false
+        @@conns, old_conns = old_conns, @@conns
+      }
+      # This function acquires `@mon` on the connections, so it's
+      # safer to do this outside our own synchronization.
+      old_conns.each {|conn|
+        conn.remove_em_waiters
+      }
+    end
+  end
+
+  class Handler
+    def initialize
+      @stopped = false
+    end
+    def handle(m, args, caller)
+      if !stopped?
+        if method(m).arity == args.size
+          send(m, *args)
+        else
+          send(m, *args, caller)
+        end
+      end
+    end
+
+    def on_open(caller)
+    end
+    def on_close(caller)
+    end
+    def on_wait_complete(caller)
+    end
+
+    def on_error(err, caller)
+      raise err
+    end
+    def on_val(val, caller)
+    end
+    def on_array(arr, caller)
+      if method(:on_atom).owner != Handler
+        handle(:on_atom, [arr], caller)
+      else
+        arr.each {|x|
+          break if stopped?
+          handle(:on_stream_val, [x], caller)
+        }
+      end
+    end
+    def on_atom(val, caller)
+      handle(:on_val, [val], caller)
+    end
+    def on_stream_val(val, caller)
+      handle(:on_val, [val], caller)
+    end
+
+    def on_unhandled_change(val, caller)
+      handle(:on_stream_val, [val], caller)
+    end
+
+    def stop
+      @stopped = true
+    end
+    def stopped?
+      @stopped
+    end
+  end
+
+  class CallbackHandler < Handler
+    def initialize(callback)
+      if callback.arity > 2 || callback.arity < -3
+        raise ArgumentError, "Wrong number of arguments for callback (callback " +
+          "accepts #{callback.arity} arguments, but it should accept 0, 1 or 2)."
+      end
+      @callback = callback
+    end
+    def do_call(err, val)
+      if @callback.arity == 0
+        raise err if err
+        @callback.call
+      elsif @callback.arity == 1
+        raise err if err
+        @callback.call(val)
+      else
+        @callback.call(err, val)
+      end
+    end
+    def on_val(x)
+      do_call(nil, x)
+    end
+    def on_error(err)
+      do_call(err, nil)
+    end
+  end
+
+  class QueryHandle
+    def initialize(handler, msg, all_opts, token, conn)
+      @handler = handler
+      @msg = msg
+      @all_opts = all_opts
+      @token = token
+      @conn = conn
+      @opened = false
+      @closed = false
+    end
+    def closed?
+      @closed
+    end
+    def close
+      if !@closed
+        handle_close
+        return @conn.stop(@token)
+      end
+      return false
+    end
+    def handle(m, *args)
+      @handler.handle(m, args, self)
+    end
+    def handle_open
+      if !@opened
+        @opened = true
+        handle(:on_open)
+      end
+    end
+    def handle_close
+      if !@closed
+        @closed = true
+        handle(:on_close)
+      end
+    end
+    def safe_next_tick(&b)
+      EM.next_tick {
+        b.call if !@closed
+      }
+    end
+    def callback(res)
+      begin
+        if @handler.stopped? || !EM.reactor_running?
+          @closed = true
+          @conn.stop(@token)
+          return
+        elsif res
+          is_cfeed = (res['n'] & [Response::ResponseNote::SEQUENCE_FEED,
+                                  Response::ResponseNote::ATOM_FEED,
+                                  Response::ResponseNote::ORDER_BY_LIMIT_FEED,
+                                  Response::ResponseNote::UNIONED_FEED]) != []
+          if (res['t'] == Response::ResponseType::SUCCESS_PARTIAL) ||
+              (res['t'] == Response::ResponseType::SUCCESS_SEQUENCE)
+            safe_next_tick {
+              handle_open
+              if res['t'] == Response::ResponseType::SUCCESS_PARTIAL
+                @conn.register_query(@token, @all_opts, self) if !@conn.closed?
+                @conn.dispatch([Query::QueryType::CONTINUE], @token) if !@conn.closed?
+              end
+              Shim.response_to_native(res, @msg, @all_opts).each {|row|
+                if is_cfeed
+                  if (row.has_key?('new_val') && row.has_key?('old_val') &&
+                      @handler.respond_to?(:on_change))
+                    handle(:on_change, row['old_val'], row['new_val'])
+                  elsif (row.has_key?('new_val') && !row.has_key?('old_val') &&
+                         @handler.respond_to?(:on_initial_val))
+                    handle(:on_initial_val, row['new_val'])
+                  elsif row.has_key?('error') && @handler.respond_to?(:on_change_error)
+                    handle(:on_change_error, row['error'])
+                  elsif row.has_key?('state') && @handler.respond_to?(:on_state)
+                    handle(:on_state, row['state'])
+                  else
+                    handle(:on_unhandled_change, row)
+                  end
+                else
+                  handle(:on_stream_val, row)
+                end
+              }
+              if (res['t'] == Response::ResponseType::SUCCESS_SEQUENCE ||
+                  @conn.closed?)
+                handle_close
+              end
+            }
+          elsif res['t'] == Response::ResponseType::SUCCESS_ATOM
+            safe_next_tick {
+              return if @closed
+              handle_open
+              val = Shim.response_to_native(res, @msg, @all_opts)
+              if val.is_a?(Array)
+                handle(:on_array, val)
+              else
+                handle(:on_atom, val)
+              end
+              handle_close
+            }
+          elsif res['t'] == Response::ResponseType::WAIT_COMPLETE
+            safe_next_tick {
+              return if @closed
+              handle_open
+              handle(:on_wait_complete)
+              handle_close
+            }
+          else
+            exc = nil
+            begin
+              exc = Shim.response_to_native(res, @msg, @all_opts)
+            rescue Exception => e
+              exc = e
+            end
+            safe_next_tick {
+              return if @closed
+              handle_open
+              handle(:on_error, e)
+              handle_close
+            }
+          end
+        else
+          safe_next_tick {
+            return if @closed
+            handle_close
+          }
+        end
+      rescue Exception => e
+        safe_next_tick {
+          return if @closed
+          handle_open
+          handle(:on_error, e)
+          handle_close
+        }
+      end
+    end
+  end
+
   class RQL
     @@default_conn = nil
     def self.set_default_conn c; @@default_conn = c; end
-    def run(c=@@default_conn, opts=nil, &b)
-      unbound_if(@body == RQL)
-      c, opts = @@default_conn, c if !opts && !c.kind_of?(RethinkDB::Connection)
+    def parse(*args, &b)
+      conn = nil
+      opts = nil
+      block = nil
+      args = args.map{|x| x.is_a?(Class) ? x.new : x}
+      args.each {|arg|
+        case arg
+        when RethinkDB::Connection
+          raise ArgumentError, "Unexpected second Connection #{arg.inspect}." if conn
+          conn = arg
+        when Hash
+          raise ArgumentError, "Unexpected second Hash #{arg.inspect}." if opts
+          opts = arg
+        when Proc
+          raise ArgumentError, "Unexpected second callback #{arg.inspect}." if block
+          block = arg
+        when Handler
+          raise ArgumentError, "Unexpected second callback #{arg.inspect}." if block
+          block = arg
+        else
+          raise ArgumentError, "Unexpected argument #{arg.inspect} " +
+            "(got #{args.inspect})."
+        end
+      }
+      conn = @@default_conn if !conn
       opts = {} if !opts
-      opts = {opts => true} if opts.class != Hash
+      block = b if !block
       if (tf = opts[:time_format])
         opts[:time_format] = (tf = tf.to_s)
         if tf != 'raw' && tf != 'native'
@@ -35,11 +308,37 @@ module RethinkDB
           raise ArgumentError, "`binary_format` must be 'raw' or 'native' (got `#{bf}`)."
         end
       end
-      if !c
+      if !conn
         raise ArgumentError, "No connection specified!\n" \
         "Use `query.run(conn)` or `conn.repl(); query.run`."
       end
-      c.run(@body, opts, &b)
+      {conn: conn, opts: opts, block: block}
+    end
+    def run(*args, &b)
+      unbound_if(@body == RQL)
+      args = parse(*args, &b)
+      args[:conn].run(@body, args[:opts], args[:block])
+    end
+    def em_run(*args, &b)
+      if !EM.reactor_running?
+        raise RuntimeError, "RethinkDB::RQL::em_run can only be called inside `EM.run`"
+      end
+      unbound_if(@body == RQL)
+      args = parse(*args, &b)
+      if args[:block].is_a?(Proc)
+        args[:block] = CallbackHandler.new(args[:block])
+      end
+      if !args[:block].is_a?(Handler)
+        raise ArgumentError, "No handler specified."
+      end
+
+      # If the user has defined the `on_state` method, we assume they want states.
+      if args[:block].respond_to?(:on_state)
+        args[:opts] = args[:opts].merge(include_states: true)
+      end
+
+      EM_Guard.register(args[:conn])
+      args[:conn].run(@body, args[:opts], args[:block])
     end
   end
 
@@ -57,11 +356,11 @@ module RethinkDB
       preview = preview_res.pretty_inspect[0...-1]
       state = @run ? "(exhausted)" : "(enumerable)"
       extra = out_of_date ? " (Connection #{@conn.inspect} is closed.)" : ""
-      "#<RethinkDB::Cursor:#{self.object_id} #{state}#{extra}: #{RPP.pp(@msg)}" +
+      "#<RethinkDB::Cursor:#{object_id} #{state}#{extra}: #{RPP.pp(@msg)}" +
         (@run ? "" : "\n#{preview}") + ">"
     end
 
-    def initialize(results, msg, connection, opts, token, more = true) # :nodoc:
+    def initialize(results, msg, connection, opts, token, more) # :nodoc:
       @more = more
       @results = results
       @msg = msg
@@ -73,43 +372,64 @@ module RethinkDB
       fetch_batch
     end
 
-    def each (&block) # :nodoc:
+    def each(&block) # :nodoc:
       raise RqlRuntimeError, "Can only iterate over a cursor once." if @run
-      return self.enum_for(:each) if !block
+      return enum_for(:each) if !block
       @run = true
       while true
         @results.each(&block)
         return self if !@more
         raise RqlRuntimeError, "Connection is closed." if @more && out_of_date
-        res = @conn.wait(@token)
+        wait_for_batch(nil)
+      end
+    end
+
+    def close
+      if @more
+        @more = false
+        @conn.stop(@token)
+        return true
+      end
+      return false
+    end
+
+    def wait_for_batch(timeout)
+        res = @conn.wait(@token, timeout)
         @results = Shim.response_to_native(res, @msg, @opts)
         if res['t'] == Response::ResponseType::SUCCESS_SEQUENCE
           @more = false
         else
           fetch_batch
         end
-      end
     end
 
-    def close
+    def fetch_batch
       if @more
-        @more = false
-        @conn.wait(@token) # Ignore the response - TODO: do this asynchronously
-        q = [Query::QueryType::STOP]
-        res = @conn.run_internal(q, @opts, @token)
-        if ((res['t'] != Response::ResponseType::SUCCESS_SEQUENCE &&
-             res['t'] != Response::ResponseType::SUCCESS_FEED &&
-             res['t'] != Response::ResponseType::SUCCESS_ATOM_FEED) ||
-            res['r'] != [])
-          raise RqlRuntimeError, "Server sent malformed STOP response #{PP.pp(res, "")}"
-        end
-        return true
+        @conn.register_query(@token, @opts)
+        @conn.dispatch([Query::QueryType::CONTINUE], @token)
       end
     end
 
-    def fetch_batch
-      @conn.register_query(@token, @opts)
-      @conn.dispatch([Query::QueryType::CONTINUE], @token)
+    def next(wait=true)
+      if @run
+        raise RqlRuntimeError, "Cannot call `next` on a cursor after calling `each`."
+      end
+      if @more && out_of_date
+        raise RqlRuntimeError, "Connection is closed."
+      end
+      timeout = wait
+      if wait == true
+        timeout = nil
+      elsif !wait
+        timeout = 0
+      end
+
+      while @results.length == 0
+        raise StopIteration if !@more
+        wait_for_batch(timeout)
+      end
+
+      @results.shift
     end
   end
 
@@ -127,11 +447,14 @@ module RethinkDB
         @abort_module = Faux_Abort
       end
 
-      opts = {:host => opts} if opts.class == String
+      opts = Hash[opts.map{|(k,v)| [k.to_sym,v]}] if opts.is_a?(Hash)
+      opts = {:host => opts} if opts.is_a?(String)
       @host = opts[:host] || "localhost"
-      @port = opts[:port] || 28015
+      @port = (opts[:port] || 28015).to_i
       @default_db = opts[:db]
       @auth_key = opts[:auth_key] || ""
+      @timeout = opts[:timeout].to_i
+      @timeout = 20 if @timeout <= 0
 
       @@last = self
       @default_opts = @default_db ? {:db => RQL.new.db(@default_db)} : {}
@@ -140,7 +463,7 @@ module RethinkDB
       @token_cnt = 0
       @token_cnt_mutex = Mutex.new
 
-      self.connect()
+      connect()
     end
     attr_reader :host, :port, :default_db, :conn_id
 
@@ -148,12 +471,13 @@ module RethinkDB
       @token_cnt_mutex.synchronize{@token_cnt += 1}
     end
 
-    def register_query(token, opts)
+    def register_query(token, opts, callback=nil)
       if !opts[:noreply]
-        @listener_mutex.synchronize{
-          raise RqlDriverError, "Internal driver error, token already in use." \
-            if @waiters.has_key?(token)
-          @waiters[token] = ConditionVariable.new
+        @mon.synchronize {
+          if @waiters.has_key?(token)
+            raise RqlDriverError, "Internal driver error, token already in use."
+          end
+          @waiters[token] = callback ? callback : @mon.new_cond
           @opts[token] = opts
         }
       end
@@ -161,11 +485,17 @@ module RethinkDB
     def run_internal(q, opts, token)
       register_query(token, opts)
       dispatch(q, token)
-      opts[:noreply] ? nil : wait(token)
+      opts[:noreply] ? nil : wait(token, nil)
+    end
+    def stop(token)
+      dispatch([Query::QueryType::STOP], token)
+      @mon.synchronize {
+        !!@waiters.delete(token)
+      }
     end
-    def run(msg, opts, &b)
-      reconnect(:noreply_wait => false) if @auto_reconnect && !self.is_open()
-      raise RqlRuntimeError, "Connection is closed." if !self.is_open()
+    def run(msg, opts, b)
+      reconnect(:noreply_wait => false) if @auto_reconnect && !is_open()
+      raise RqlRuntimeError, "Connection is closed." if !is_open()
 
       global_optargs = {}
       all_opts = @default_opts.merge(opts)
@@ -177,40 +507,45 @@ module RethinkDB
       q = [Query::QueryType::START,
            msg,
            Hash[all_opts.map {|k,v|
-                  [k.to_s, (v.class == RQL ? v.to_pb : RQL.new.expr(v).to_pb)]
+                  [k.to_s, (v.is_a?(RQL) ? v.to_pb : RQL.new.expr(v).to_pb)]
                 }]]
 
-      res = run_internal(q, all_opts, token)
-      return res if !res
-      if res['t'] == Response::ResponseType::SUCCESS_PARTIAL ||
-         res['t'] == Response::ResponseType::SUCCESS_FEED ||
-         res['t'] == Response::ResponseType::SUCCESS_ATOM_FEED
-        value = Cursor.new(Shim.response_to_native(res, msg, opts),
-                           msg, self, opts, token, true)
-      elsif res['t'] == Response::ResponseType::SUCCESS_SEQUENCE
-        value = Cursor.new(Shim.response_to_native(res, msg, opts),
-                   msg, self, opts, token, false)
+      if b.is_a? Handler
+        callback = QueryHandle.new(b, msg, all_opts, token, self)
+        register_query(token, all_opts, callback)
+        dispatch(q, token)
+        return callback
       else
-        value = Shim.response_to_native(res, msg, opts)
-      end
+        res = run_internal(q, all_opts, token)
+        return res if !res
+        if res['t'] == Response::ResponseType::SUCCESS_PARTIAL
+          value = Cursor.new(Shim.response_to_native(res, msg, opts),
+                             msg, self, opts, token, true)
+        elsif res['t'] == Response::ResponseType::SUCCESS_SEQUENCE
+          value = Cursor.new(Shim.response_to_native(res, msg, opts),
+                             msg, self, opts, token, false)
+        else
+          value = Shim.response_to_native(res, msg, opts)
+        end
 
-      if res['p']
-        real_val = {
-          "profile" => res['p'],
-          "value" => value
-        }
-      else
-        real_val = value
-      end
+        if res['p']
+          real_val = {
+            "profile" => res['p'],
+            "value" => value
+          }
+        else
+          real_val = value
+        end
 
-      if b
-        begin
-          b.call(real_val)
-        ensure
-          value.close if value.class == Cursor
+        if b
+          begin
+            b.call(real_val)
+          ensure
+            value.close if value.is_a?(Cursor)
+          end
+        else
+          real_val
         end
-      else
-        real_val
       end
     end
 
@@ -232,21 +567,38 @@ module RethinkDB
       return token
     end
 
-    def wait(token)
+    def wait(token, timeout)
       begin
-        res = nil
-        @listener_mutex.synchronize {
-          raise RqlRuntimeError, "Connection is closed." if !@waiters.has_key?(token)
-          res = @data.delete(token)
-          if res == nil
-            @waiters[token].wait(@listener_mutex)
+        @mon.synchronize {
+          end_time = timeout ? Time.now.to_f + timeout : nil
+          loop {
             res = @data.delete(token)
-          end
-          @waiters.delete(token)
+            return res if res
+
+            # Theoretically we only need to check the second property,
+            # but this is safer in case someone makes changes to
+            # `close` in the future.
+            if !is_open() || !@waiters.has_key?(token)
+              raise RqlRuntimeError, "Connection is closed."
+            end
+
+            if end_time
+              cur_time = Time.now.to_f
+              if cur_time >= end_time
+                raise Timeout::Error, "Timed out waiting for cursor response."
+              else
+                # We can't use `wait_while` because it doesn't take a
+                # timeout, and we can't use an external `timeout {
+                # ... }` block because in Ruby 1.9.1 it seems to confuse
+                # the synchronization in `@mon` to be timed out while
+                # waiting in a synchronize block.
+                @waiters[token].wait(end_time - cur_time)
+              end
+            else
+              @waiters[token].wait
+            end
+          }
         }
-        raise RqlRuntimeError, "Connection is closed." if res.nil? && !self.is_open()
-        raise RqlDriverError, "Internal driver error, no response found." if res.nil?
-        return res
       rescue @abort_module::Abort => e
         print "\nAborting query and reconnecting...\n"
         reconnect(:noreply_wait => false)
@@ -263,12 +615,12 @@ module RethinkDB
     def inspect
       db = @default_opts[:db] || RQL.new.db('test')
       properties = "(#{@host}:#{@port}) (Default DB: #{db.inspect})"
-      state = self.is_open() ? "(open)" : "(closed)"
-      "#<RethinkDB::Connection:#{self.object_id} #{properties} #{state}>"
+      state = is_open() ? "(open)" : "(closed)"
+      "#<RethinkDB::Connection:#{object_id} #{properties} #{state}>"
     end
 
     @@last = nil
-    @@magic_number = VersionDummy::Version::V0_3
+    @@magic_number = VersionDummy::Version::V0_4
     @@wire_protocol = VersionDummy::Protocol::JSON
 
     def debug_socket; @socket; end
@@ -278,14 +630,15 @@ module RethinkDB
     # enumerables on the client.
     def reconnect(opts={})
       raise ArgumentError, "Argument to reconnect must be a hash." if opts.class != Hash
-      self.close(opts)
-      self.connect()
+      close(opts)
+      connect()
     end
 
     def connect()
       raise RuntimeError, "Connection must be closed before calling connect." if @socket
       @socket = TCPSocket.open(@host, @port)
-      @listener_mutex = Mutex.new
+      @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+      @mon = Monitor.new
       @waiters = {}
       @opts = {}
       @data = {}
@@ -294,11 +647,15 @@ module RethinkDB
       self
     end
 
-    def is_open()
+    def is_open
       @socket && @listener
     end
+    def closed?
+      !is_open
+    end
 
     def close(opts={})
+      EM_Guard.unregister(self)
       raise ArgumentError, "Argument to close must be a hash." if opts.class != Hash
       if !(opts.keys - [:noreply_wait]).empty?
         raise ArgumentError, "close does not understand these options: " +
@@ -306,7 +663,22 @@ module RethinkDB
       end
       opts[:noreply_wait] = true if !opts.keys.include?(:noreply_wait)
 
-      self.noreply_wait() if opts[:noreply_wait] && self.is_open()
+      @mon.synchronize {
+        @opts.clear
+        @data.clear
+        @waiters.each {|k,v|
+          case v
+          when QueryHandle
+            v.handle_close
+          when MonitorMixin::ConditionVariable
+            @waiters[k] = nil
+            v.signal
+          end
+        }
+        @waiters.clear
+      }
+
+      noreply_wait() if opts[:noreply_wait] && is_open()
       if @listener
         @listener.terminate
         @listener.join
@@ -314,17 +686,11 @@ module RethinkDB
       @socket.close if @socket
       @listener = nil
       @socket = nil
-      @listener_mutex.synchronize {
-        @opts.clear
-        @data.clear
-        @waiters.values.each{ |w| w.signal }
-        @waiters.clear
-      }
       self
     end
 
     def noreply_wait
-      raise RqlRuntimeError, "Connection is closed." if !self.is_open()
+      raise RqlRuntimeError, "Connection is closed." if !is_open()
       q = [Query::QueryType::NOREPLY_WAIT]
       res = run_internal(q, {noreply: false}, new_token)
       if res['t'] != Response::ResponseType::WAIT_COMPLETE
@@ -338,12 +704,31 @@ module RethinkDB
       raise RqlRuntimeError, "No last connection.  Use RethinkDB::Connection.new."
     end
 
+    def remove_em_waiters
+      @mon.synchronize {
+        @waiters.each {|k,v|
+          if v.is_a? QueryHandle
+            v.handle_close
+            @waiters.delete(k)
+          end
+        }
+      }
+    end
+
     def note_data(token, data) # Synchronize around this!
-      raise RqlDriverError, "Unknown token in response." if !@waiters.has_key?(token)
-      @data[token] = data
       @opts.delete(token)
-      w = @waiters[token]
-      w.signal if w
+      w = @waiters.delete(token)
+      case w
+      when MonitorMixin::ConditionVariable
+        @data[token] = data
+        w.signal
+      when QueryHandle
+        w.callback(data)
+      when nil
+        # nothing
+      else
+        raise RqlDriverError, "Unrecognized value #{w.inspect} in `@waiters`."
+      end
     end
 
     def note_error(token, e) # Synchronize around this!
@@ -374,15 +759,16 @@ module RethinkDB
             @auth_key + [@@wire_protocol].pack('L<'))
       response = ""
       while response[-1..-1] != "\0"
-        response += @socket.read_exn(1, 20)
+        response += @socket.read_exn(1, @timeout)
       end
       response = response[0...-1]
       if response != "SUCCESS"
         raise RqlRuntimeError, "Server dropped connection with message: \"#{response}\""
       end
 
-      raise RqlDriverError, "Internal driver error, listener already started." \
-        if @listener
+      if @listener
+        raise RqlDriverError, "Internal driver error, listener already started."
+      end
       @listener = Thread.new {
         while true
           begin
@@ -396,9 +782,9 @@ module RethinkDB
               raise RqlRuntimeError, "Bad response, server is buggy.\n" +
                 "#{e.inspect}\n" + response
             end
-            @listener_mutex.synchronize{note_data(token, data)}
+            @mon.synchronize{note_data(token, data)}
           rescue Exception => e
-            @listener_mutex.synchronize {
+            @mon.synchronize {
               @waiters.keys.each{ |k| note_error(k, e) }
               @listener = nil
               Thread.current.terminate

data/lib/ql2.pb.rb

@@ -7,6 +7,7 @@ module RethinkDB
 			V0_1 = 1063369270
 			V0_2 = 1915781601
 			V0_3 = 1601562686
+			V0_4 = 1074539808
 		end
 		
 		module Protocol
@@ -42,13 +43,19 @@ module RethinkDB
 			SUCCESS_ATOM = 1
 			SUCCESS_SEQUENCE = 2
 			SUCCESS_PARTIAL = 3
-			SUCCESS_FEED = 5
 			WAIT_COMPLETE = 4
-			SUCCESS_ATOM_FEED = 6
 			CLIENT_ERROR = 16
 			COMPILE_ERROR = 17
 			RUNTIME_ERROR = 18
 		end
+		
+		module ResponseNote
+			SEQUENCE_FEED = 1
+			ATOM_FEED = 2
+			ORDER_BY_LIMIT_FEED = 3
+			UNIONED_FEED = 4
+			INCLUDES_STATES = 5
+		end
 	end
 	
 	module Datum
@@ -103,7 +110,7 @@ module RethinkDB
 			SLICE = 30
 			SKIP = 70
 			LIMIT = 71
-			INDEXES_OF = 87
+			OFFSETS_OF = 87
 			CONTAINS = 93
 			GET_FIELD = 31
 			KEYS = 94
@@ -113,7 +120,8 @@ module RethinkDB
 			PLUCK = 33
 			WITHOUT = 34
 			MERGE = 35
-			BETWEEN = 36
+			BETWEEN_DEPRECATED = 36
+			BETWEEN = 182
 			REDUCE = 37
 			MAP = 38
 			FILTER = 39
@@ -160,8 +168,8 @@ module RethinkDB
 			INDEX_RENAME = 156
 			FUNCALL = 64
 			BRANCH = 65
-			ANY = 66
-			ALL = 67
+			OR = 66
+			AND = 67
 			FOR_EACH = 68
 			FUNC = 69
 			ASC = 73
@@ -237,6 +245,8 @@ module RethinkDB
 			FILL = 167
 			GET_NEAREST = 168
 			POLYGON_SUB = 171
+			MINVAL = 180
+			MAXVAL = 181
 		end
 		
 		module AssocPair

data/lib/rpp.rb

@@ -102,18 +102,19 @@ module RethinkDB
                args[0][0] != Term::TermType::DB)
         return false
       else
-        return !["db", "db_create", "db_drop", "json", "funcall", "args", "branch", "http",
-          "binary", "javascript", "random", "time", "iso8601", "epoch_time", "now",
-          "geojson", "point", "circle", "line", "polygon", "asc", "desc", "literal",
-          "range"].include?(name)
+        return !["db", "db_create", "db_drop", "json", "funcall",
+                 "args", "branch", "http", "binary", "javascript", "random",
+                 "time", "iso8601", "epoch_time", "now", "geojson", "point",
+                 "circle", "line", "polygon", "asc", "desc", "literal",
+                 "range", "error"].include?(name)
       end
     end
     def self.pp_int(q, term, bt, pre_dot=false)
       q.text("\x7", 0) if bt == []
 
-      term = term.to_pb if term.class == RQL
+      term = term.to_pb if term.is_a?(RQL)
       if term.class != Array
-        if term.class == Hash
+        if term.is_a?(Hash)
           if not pp_pseudotype(q, term, bt)
             pp_int_optargs(q, term, bt, pre_dot)
           end
@@ -178,7 +179,7 @@ module RethinkDB
         q.text("r")
         arg_offset = 0
       end
-      if name == "getattr"
+      if name == "bracket"
         argstart, argstop = "[", "]"
       else
         q.text(".")
@@ -186,7 +187,7 @@ module RethinkDB
         argstart, argstop = "(", ")"
       end
 
-      if args[-1] && args[-1].class == Array && args[-1][0] == Term::TermType::FUNC
+      if args[-1] && args[-1].is_a?(Array) && args[-1][0] == Term::TermType::FUNC
         func_bt = bt_consume(bt, args.size() - 1 + arg_offset)
         func = args.pop
       end

data/lib/shim.rb

@@ -60,8 +60,6 @@ module RethinkDB
       begin
         case r['t']
         when rt::SUCCESS_ATOM      then r['r'][0]
-        when rt::SUCCESS_FEED      then r['r']
-        when rt::SUCCESS_ATOM_FEED then r['r']
         when rt::SUCCESS_PARTIAL   then r['r']
         when rt::SUCCESS_SEQUENCE  then r['r']
         when rt::RUNTIME_ERROR     then raise RqlRuntimeError, r['r'][0]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rethinkdb
 version: !ruby/object:Gem::Version
-  version: 1.16.0.1
+  version: 2.0.0.1
 platform: ruby
 authors:
 - RethinkDB Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-19 00:00:00.000000000 Z
+date: 2015-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json