rethinkdb 2.0.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dae3d5d3b038eca2d30595a269cb259351d5bd98
-  data.tar.gz: 7a03e7c5f271bbb2a7e2e63f74a2757864c4cdbb
+  metadata.gz: 4dbe3bed2b00fa519fa84f136b6b140da9e97c49
+  data.tar.gz: 478001c0afd50dcbad8d02d843ffa2602d7cec6d
 SHA512:
-  metadata.gz: 308251a1089f50555e2e8177af64235bea9b5a36d35615aca7852f8f72530f17cb0c70569d6a727012aad0f273c6912262cedd9e6b6e1748d60d59e5ec4feb91
-  data.tar.gz: 6f31e8e16757cdaa9fc98137fd732323fa32c7d03c0af3edc2fcad299dfa9dff0c3bad2db838e2e7db1426c07bf3ed3729b8c723b38d3f784396722b3ccfbe5a
+  metadata.gz: 34d05e329c5c523c91f324e67205cef95ad57c2af7ae9b01977ddd76e2bb03be110b45165fd42fbe36535865548bef1e8b82cb37925a21cc98dea9e25e1b9a6d
+  data.tar.gz: 07a54b27fba8686fd47b9a6a814f18e417400fc4636240f015c255aa7e52358ffc623fb2c375c66fc1b2a2f07d0fa044b07d609e1441ced43eab383b61f472de

data/lib/exc.rb

@@ -1,6 +1,17 @@
 module RethinkDB
-  RqlError        = Class.new(RuntimeError)
-  RqlRuntimeError = Class.new(RqlError)
-  RqlDriverError  = Class.new(RqlError)
-  RqlCompileError = Class.new(RqlError)
+  ReqlError = RqlError = Class.new(RuntimeError)
+
+  ReqlRuntimeError = RqlRuntimeError = Class.new(ReqlError)
+  ReqlInternalError = RqlInternalError = Class.new(ReqlRuntimeError)
+  ReqlResourceLimitError = RqlResourceLimitError = Class.new(ReqlRuntimeError)
+  ReqlQueryLogicError = RqlQueryLogicError = Class.new(ReqlRuntimeError)
+  ReqlNonExistenceError = RqlNonExistenceError = Class.new(ReqlQueryLogicError)
+  ReqlAvailabilityError = RqlAvailabilityError = Class.new(ReqlRuntimeError)
+  ReqlOpFailedError = RqlOpFailedError = Class.new(ReqlAvailabilityError)
+  ReqlOpIndeterminateError = RqlOpIndeterminateError = Class.new(ReqlAvailabilityError)
+  ReqlUserError = RqlUserError = Class.new(ReqlRuntimeError)
+
+  ReqlDriverError = RqlDriverError = Class.new(ReqlError)
+  ReqlAuthError = RqlAuthError = Class.new(ReqlDriverError)
+  ReqlCompileError = RqlCompileError = Class.new(ReqlError)
 end

data/lib/func.rb

@@ -88,7 +88,7 @@ module RethinkDB
                 "This is almost always a precedence error.\n" +
                 "Note that `a < b | b < c` <==> `a < (b | b) < c`.\n" +
                 "If you really want this behavior, use `.or` or `.and` instead."
-              raise RqlDriverError, err
+              raise ReqlDriverError, err
             end
           }
         end
@@ -151,7 +151,7 @@ module RethinkDB
     def do(*args, &b)
       a = ((@body != RQL) ? [self] : []) + args.dup
       if a == [] && !b
-        raise RqlDriverError, "Expected 1 or more arguments but found 0."
+        raise ReqlDriverError, "Expected 1 or more arguments but found 0."
       end
       funcall_args = (b ? [new_func(&b)] : [a.pop]) + a
       # PP.pp funcall_args

data/lib/net.rb

@@ -4,6 +4,7 @@ require 'socket'
 require 'thread'
 require 'timeout'
 require 'pp' # This is needed for pretty_inspect
+require 'openssl'
 
 module RethinkDB
   module Faux_Abort
@@ -162,6 +163,12 @@ module RethinkDB
         handle(:on_close)
       end
     end
+    def handle_force_close
+      if !@closed
+        handle(:on_error, ReqlRuntimeError.new("Connection is closed."))
+      end
+      handle_close
+    end
     def safe_next_tick(&b)
       EM.next_tick {
         b.call if !@closed
@@ -194,6 +201,9 @@ module RethinkDB
                   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?('old_val') && !row.has_key?('new_val') &&
+                         @handler.respond_to?(:on_uninitial_val))
+                    handle(:on_uninitial_val, row['old_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)
@@ -317,6 +327,9 @@ module RethinkDB
     def run(*args, &b)
       unbound_if(@body == RQL)
       args = parse(*args, &b)
+      if args[:block].is_a?(Handler)
+        raise RuntimeError, "Cannot call `run` with a handler, did you mean `em_run`?"
+      end
       args[:conn].run(@body, args[:opts], args[:block])
     end
     def em_run(*args, &b)
@@ -373,13 +386,13 @@ module RethinkDB
     end
 
     def each(&block) # :nodoc:
-      raise RqlRuntimeError, "Can only iterate over a cursor once." if @run
+      raise ReqlRuntimeError, "Can only iterate over a cursor once." if @run
       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
+        raise ReqlRuntimeError, "Connection is closed." if @more && out_of_date
         wait_for_batch(nil)
       end
     end
@@ -412,10 +425,10 @@ module RethinkDB
 
     def next(wait=true)
       if @run
-        raise RqlRuntimeError, "Cannot call `next` on a cursor after calling `each`."
+        raise ReqlRuntimeError, "Cannot call `next` on a cursor after calling `each`."
       end
       if @more && out_of_date
-        raise RqlRuntimeError, "Connection is closed."
+        raise ReqlRuntimeError, "Connection is closed."
       end
       timeout = wait
       if wait == true
@@ -434,6 +447,7 @@ module RethinkDB
   end
 
   class Connection
+    include OpenSSL
     def auto_reconnect(x=true)
       @auto_reconnect = x
       self
@@ -455,6 +469,7 @@ module RethinkDB
       @auth_key = opts[:auth_key] || ""
       @timeout = opts[:timeout].to_i
       @timeout = 20 if @timeout <= 0
+      @ssl_opts = opts[:ssl] || {}
 
       @@last = self
       @default_opts = @default_db ? {:db => RQL.new.db(@default_db)} : {}
@@ -475,7 +490,7 @@ module RethinkDB
       if !opts[:noreply]
         @mon.synchronize {
           if @waiters.has_key?(token)
-            raise RqlDriverError, "Internal driver error, token already in use."
+            raise ReqlDriverError, "Internal driver error, token already in use."
           end
           @waiters[token] = callback ? callback : @mon.new_cond
           @opts[token] = opts
@@ -495,7 +510,7 @@ module RethinkDB
     end
     def run(msg, opts, b)
       reconnect(:noreply_wait => false) if @auto_reconnect && !is_open()
-      raise RqlRuntimeError, "Connection is closed." if !is_open()
+      raise ReqlRuntimeError, "Connection is closed." if !is_open()
 
       global_optargs = {}
       all_opts = @default_opts.merge(opts)
@@ -550,14 +565,16 @@ module RethinkDB
     end
 
     def send packet
-      written = 0
-      while written < packet.length
-        # Supposedly slice will not copy the array if it goes all the way to the end
-        # We use IO::syswrite here rather than IO::write because of incompatibilities in
-        # JRuby regarding filling up the TCP send buffer.
-        # Reference: https://github.com/rethinkdb/rethinkdb/issues/3795
-        written += @socket.syswrite(packet.slice(written, packet.length))
-      end
+      @mon.synchronize {
+        written = 0
+        while written < packet.length
+          # Supposedly slice will not copy the array if it goes all the way to the end
+          # We use IO::syswrite here rather than IO::write because of incompatibilities in
+          # JRuby regarding filling up the TCP send buffer.
+          # Reference: https://github.com/rethinkdb/rethinkdb/issues/3795
+          written += @socket.syswrite(packet.slice(written, packet.length))
+        end
+      }
     end
 
     def dispatch(msg, token)
@@ -579,7 +596,7 @@ module RethinkDB
             # 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."
+              raise ReqlRuntimeError, "Connection is closed."
             end
 
             if end_time
@@ -636,8 +653,7 @@ module RethinkDB
 
     def connect()
       raise RuntimeError, "Connection must be closed before calling connect." if @socket
-      @socket = TCPSocket.open(@host, @port)
-      @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+      init_socket
       @mon = Monitor.new
       @waiters = {}
       @opts = {}
@@ -647,6 +663,46 @@ module RethinkDB
       self
     end
 
+    def init_socket
+      unless @ssl_opts.empty?
+        @tcp_socket = base_socket
+        context = create_context(@ssl_opts)
+        @socket = OpenSSL::SSL::SSLSocket.new(@tcp_socket, context)
+        @socket.sync_close = true
+        @socket.connect
+        verify_cert!(@socket, context)
+      else
+        @socket = base_socket
+      end
+    end
+
+    def base_socket
+      socket = TCPSocket.open(@host, @port)
+      socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+      socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1)
+      socket
+    end
+
+    def create_context(options)
+      context = OpenSSL::SSL::SSLContext.new
+      context.ssl_version = :TLSv1_2
+      if options[:ca_certs]
+        context.ca_file = options[:ca_certs]
+        context.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      else
+        raise 'ssl options provided but missing required "ca_certs" option'
+      end
+      context
+    end
+
+    def verify_cert!(socket, context)
+      if context.verify_mode == OpenSSL::SSL::VERIFY_PEER
+        unless OpenSSL::SSL.verify_certificate_identity(socket.peer_cert, host)
+          raise 'SSL handshake failed due to a hostname mismatch.'
+        end
+      end
+    end
+
     def is_open
       @socket && @listener
     end
@@ -669,7 +725,7 @@ module RethinkDB
         @waiters.each {|k,v|
           case v
           when QueryHandle
-            v.handle_close
+            v.handle_force_close
           when MonitorMixin::ConditionVariable
             @waiters[k] = nil
             v.signal
@@ -690,25 +746,25 @@ module RethinkDB
     end
 
     def noreply_wait
-      raise RqlRuntimeError, "Connection is closed." if !is_open()
+      raise ReqlRuntimeError, "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
-        raise RqlRuntimeError, "Unexpected response to noreply_wait: " + PP.pp(res, "")
+        raise ReqlRuntimeError, "Unexpected response to noreply_wait: " + PP.pp(res, "")
       end
       nil
     end
 
     def self.last
       return @@last if @@last
-      raise RqlRuntimeError, "No last connection.  Use RethinkDB::Connection.new."
+      raise ReqlRuntimeError, "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
+            v.handle_force_close
             @waiters.delete(k)
           end
         }
@@ -727,7 +783,7 @@ module RethinkDB
       when nil
         # nothing
       else
-        raise RqlDriverError, "Unrecognized value #{w.inspect} in `@waiters`."
+        raise ReqlDriverError, "Unrecognized value #{w.inspect} in `@waiters`."
       end
     end
 
@@ -749,7 +805,7 @@ module RethinkDB
           maybe_timeout(timeout_sec) {
             buf = read len
             if !buf || buf.length != len
-              raise RqlRuntimeError, "Connection closed by server."
+              raise ReqlRuntimeError, "Connection closed by server."
             end
             return buf
           }
@@ -762,12 +818,16 @@ module RethinkDB
         response += @socket.read_exn(1, @timeout)
       end
       response = response[0...-1]
-      if response != "SUCCESS"
-        raise RqlRuntimeError, "Server dropped connection with message: \"#{response}\""
+      if response == "SUCCESS"
+        # do nothing
+      elsif response == "ERROR: Incorrect authorization key.\n"
+        raise ReqlAuthError, "Incorrect authorization key."
+      else
+        raise ReqlRuntimeError, "Server dropped connection with message: \"#{response}\""
       end
 
       if @listener
-        raise RqlDriverError, "Internal driver error, listener already started."
+        raise ReqlDriverError, "Internal driver error, listener already started."
       end
       @listener = Thread.new {
         while true
@@ -779,7 +839,7 @@ module RethinkDB
             begin
               data = Shim.load_json(response, @opts[token])
             rescue Exception => e
-              raise RqlRuntimeError, "Bad response, server is buggy.\n" +
+              raise ReqlRuntimeError, "Bad response, server is buggy.\n" +
                 "#{e.inspect}\n" + response
             end
             @mon.synchronize{note_data(token, data)}

data/lib/ql2.pb.rb

@@ -49,6 +49,16 @@ module RethinkDB
 			RUNTIME_ERROR = 18
 		end
 		
+		module ErrorType
+			INTERNAL = 1000000
+			RESOURCE_LIMIT = 2000000
+			QUERY_LOGIC = 3000000
+			NON_EXISTENCE = 3100000
+			OP_FAILED = 4100000
+			OP_INDETERMINATE = 4200000
+			USER = 5000000
+		end
+		
 		module ResponseNote
 			SEQUENCE_FEED = 1
 			ATOM_FEED = 2
@@ -100,6 +110,9 @@ module RethinkDB
 			MUL = 26
 			DIV = 27
 			MOD = 28
+			FLOOR = 183
+			CEIL = 184
+			ROUND = 185
 			APPEND = 29
 			PREPEND = 80
 			DIFFERENCE = 95

data/lib/shim.rb

@@ -57,17 +57,28 @@ module RethinkDB
 
     def self.response_to_native(r, orig_term, opts)
       rt = Response::ResponseType
+      re = Response::ErrorType
       begin
         case r['t']
-        when rt::SUCCESS_ATOM      then r['r'][0]
-        when rt::SUCCESS_PARTIAL   then r['r']
-        when rt::SUCCESS_SEQUENCE  then r['r']
-        when rt::RUNTIME_ERROR     then raise RqlRuntimeError, r['r'][0]
-        when rt::COMPILE_ERROR     then raise RqlCompileError, r['r'][0]
-        when rt::CLIENT_ERROR      then raise RqlDriverError,  r['r'][0]
-        else raise RqlRuntimeError, "Unexpected response: #{r.inspect}"
+        when rt::SUCCESS_ATOM         then r['r'][0]
+        when rt::SUCCESS_PARTIAL      then r['r']
+        when rt::SUCCESS_SEQUENCE     then r['r']
+        when rt::RUNTIME_ERROR
+          case r['e']
+            when re::INTERNAL         then raise ReqlInternalError,         r['r'][0]
+            when re::RESOURCE_LIMIT   then raise ReqlResourceLimitError,    r['r'][0]
+            when re::QUERY_LOGIC      then raise ReqlQueryLogicError,       r['r'][0]
+            when re::NON_EXISTENCE    then raise ReqlNonExistenceError,     r['r'][0]
+            when re::OP_FAILED        then raise ReqlOpFailedError,         r['r'][0]
+            when re::OP_INDETERMINATE then raise ReqlOpIndeterminateError,  r['r'][0]
+            when re::USER             then raise ReqlUserError,             r['r'][0]
+            else                           raise ReqlRuntimeError,          r['r'][0]
+          end
+        when rt::COMPILE_ERROR        then raise ReqlCompileError,          r['r'][0]
+        when rt::CLIENT_ERROR         then raise ReqlDriverError,           r['r'][0]
+        else raise ReqlRuntimeError, "Unexpected response: #{r.inspect}"
         end
-      rescue RqlError => e
+      rescue ReqlError => e
         raise e.class, "#{e.message}\nBacktrace:\n#{RPP.pp(orig_term, r['b'])}"
       end
     end
@@ -93,14 +104,14 @@ module RethinkDB
       case x
       when String then x
       when Symbol then x.to_s
-      else raise RqlDriverError, 'Object keys must be strings or symbols.  '+
+      else raise ReqlDriverError, 'Object keys must be strings or symbols.  '+
           "(Got object `#{x.inspect}` of class `#{x.class}`.)"
       end
     end
 
     def self.fast_expr(x, max_depth)
       if max_depth == 0
-        raise RqlDriverError, "Maximum expression depth exceeded " +
+        raise ReqlDriverError, "Maximum expression depth exceeded " +
           "(you can override this with `r.expr(X, MAX_DEPTH)`)."
       end
       case x
@@ -127,7 +138,7 @@ module RethinkDB
         RQL.new({ '$reql_type$' => 'TIME',
                   'epoch_time'  => epoch_time,
                   'timezone'    => tz })
-      else raise RqlDriverError, "r.expr can't handle #{x.inspect} of class #{x.class}."
+      else raise ReqlDriverError, "r.expr can't handle #{x.inspect} of class #{x.class}."
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rethinkdb
 version: !ruby/object:Gem::Version
-  version: 2.0.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - RethinkDB Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-14 00:00:00.000000000 Z
+date: 2015-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -30,13 +30,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/ql2.pb.rb
 - lib/exc.rb
 - lib/func.rb
 - lib/net.rb
 - lib/rethinkdb.rb
 - lib/rpp.rb
 - lib/shim.rb
+- lib/ql2.pb.rb
 homepage: http://rethinkdb.com
 licenses:
 - Apache-2