mongo 2.0.6 → 2.1.0

data/lib/mongo/uri.rb

@@ -27,59 +27,118 @@ module Mongo
   #
   # @since 2.0.0
   class URI
+    include Loggable
 
-    # Scheme Regex: non-capturing, matches scheme.
+    # The uri parser object options.
     #
     # @since 2.0.0
-    SCHEME = %r{(?:mongodb://)}.freeze
+    attr_reader :options
 
-    # User Regex: capturing, group 1, matches anything but ':'
+    # The options specified in the uri.
     #
-    # @since 2.0.0
-    USER = /([^:]+)/.freeze
+    # @since 2.1.0
+    attr_reader :uri_options
 
-    # Password Regex: capturing, group 2, matches anything but '@'
+    # The servers specified in the uri.
     #
     # @since 2.0.0
-    PASSWORD = /([^@]+)/.freeze
+    attr_reader :servers
 
-    # Credentials Regex: non capturing, matches 'user:password@'
+    # Unsafe characters that must be urlencoded.
     #
-    # @since 2.0.0
-    CREDENTIALS = /(?:#{USER}:#{PASSWORD}?@)?/.freeze
+    # @since 2.1.0
+    UNSAFE = /[\:\/\+\@]/
 
-    # Host and port server Regex: matches anything but a forward slash
+    # Unix socket suffix.
     #
-    # @since 2.0.0
-    HOSTPORT = /[^\/]+/.freeze
+    # @since 2.1.0
+    UNIX_SOCKET = /.sock/
 
-    # Unix socket server Regex: matches unix socket server
+    # The mongodb connection string scheme.
     #
     # @since 2.0.0
-    UNIX = /\/.+.sock?/.freeze
+    SCHEME = 'mongodb://'.freeze
 
-    # server Regex: capturing, matches host and port server or unix server
+    # The character delimiting hosts.
     #
-    # @since 2.0.0
-    SERVERS = /((?:(?:#{HOSTPORT}|#{UNIX}),?)+)/.freeze
+    # @since 2.1.0
+    HOST_DELIM = ','.freeze
 
-    # Database Regex: matches anything but the characters that cannot
-    # be part of any MongoDB database name.
+    # The character separating a host and port.
     #
-    # @since 2.0.0
-    DATABASE = %r{(?:/([^/\.\ "*<>:\|\?]*))?}.freeze
+    # @since 2.1.0
+    HOST_PORT_DELIM = ':'.freeze
 
-    # Option Regex: notably only matches the ampersand separator and does
-    # not allow for semicolon to be used to separate options.
+    # The character delimiting a database.
     #
-    # @since 2.0.0
-    OPTIONS = /(?:\?(?:(.+=.+)&?)+)*/.freeze
+    # @since 2.1.0
+    DATABASE_DELIM = '/'.freeze
 
-    # Complete URI Regex: matches all of the combined components
+    # The character delimiting options.
     #
-    # @since 2.0.0
-    URI = /#{SCHEME}#{CREDENTIALS}#{SERVERS}#{DATABASE}#{OPTIONS}/.freeze
+    # @since 2.1.0
+    URI_OPTS_DELIM = '?'.freeze
 
+    # The character delimiting multiple options.
+    #
+    # @since 2.1.0
+    INDIV_URI_OPTS_DELIM = '&'.freeze
+
+    # The character delimiting an option and its value.
+    #
+    # @since 2.1.0
+    URI_OPTS_VALUE_DELIM = '='.freeze
+
+    # The character separating a username from the password.
+    #
+    # @since 2.1.0
+    AUTH_USER_PWD_DELIM = ':'.freeze
+
+    # The character delimiting auth credentials.
+    #
+    # @since 2.1.0
+    AUTH_DELIM = '@'.freeze
+
+    # Error details for an invalid scheme.
+    #
+    # @since 2.1.0
+    INVALID_SCHEME = "Invalid scheme. Scheme must be '#{SCHEME}'".freeze
+
+    # Error details for an invalid options format.
+    #
+    # @since 2.1.0
+    INVALID_OPTS_VALUE_DELIM = "Options and their values must be delimited" +
+      " by '#{URI_OPTS_VALUE_DELIM}'".freeze
+
+    # Error details for an non-urlencoded user name or password.
+    #
+    # @since 2.1.0
+    UNESCAPED_USER_PWD = "User name and password must be urlencoded.".freeze
+
+    # Error details for a non-urlencoded unix socket path.
+    #
+    # @since 2.1.0
+    UNESCAPED_UNIX_SOCKET = "UNIX domain sockets must be urlencoded.".freeze
+
+    # Error details for a non-urlencoded auth databsae name.
+    #
+    # @since 2.1.0
+    UNESCAPED_DATABASE = "Auth database must be urlencoded.".freeze
+
+    # Error details for providing options without a database delimiter.
+    #
+    # @since 2.1.0
+    INVALID_OPTS_DELIM = "Database delimiter '#{DATABASE_DELIM}' must be present if options are specified.".freeze
+
+    # Error details for a missing host.
+    #
+    # @since 2.1.0
+    INVALID_HOST = "Missing host; at least one must be provided.".freeze
+
+    # Error details for an invalid port.
+    #
+    # @since 2.1.0
+    INVALID_PORT = "Invalid port. Port must be an integer greater than 0 and less than 65536".freeze
 
     # MongoDB URI format specification.
     #
@@ -112,31 +171,28 @@ module Mongo
       'GSSAPI'     => :gssapi
     }.freeze
 
+    # Options that are allowed to appear more than once in the uri.
+    #
+    # @since 2.1.0
+    REPEATABLE_OPTIONS = [ :tag_sets ]
+
     # Create the new uri from the provided string.
     #
     # @example Create the new URI.
     #   URI.new('mongodb://localhost:27017')
     #
     # @param [ String ] string The uri string.
+    # @param [ Hash ] options The options.
     #
-    # @raise [ BadURI ] If the uri does not match the spec.
-    #
-    # @since 2.0.0
-    def initialize(string)
-      @match = string.match(URI)
-      raise Error::InvalidURI.new(string) unless @match
-    end
-
-    # Get the servers provided in the URI.
-    #
-    # @example Get the servers.
-    #   uri.servers
-    #
-    # @return [ Array<String> ] The servers.
+    # @raise [ Error::InvalidURI ] If the uri does not match the spec.
     #
     # @since 2.0.0
-    def servers
-      @match[3].split(',')
+    def initialize(string, options = {})
+      @string = string
+      @options = options
+      empty, scheme, remaining = @string.partition(SCHEME)
+      raise_invalid_error!(INVALID_SCHEME) unless scheme == SCHEME
+      setup!(remaining)
     end
 
     # Gets the options hash that needs to be passed to a Mongo::Client on
@@ -150,8 +206,8 @@ module Mongo
     #
     # @since 2.0.0
     def client_options
-      opts = options.merge(:database => database)
-      user ? opts.merge(credentials) : opts
+      opts = uri_options.merge(:database => database)
+      @user ? opts.merge(credentials) : opts
     end
 
     # Get the credentials provided in the URI.
@@ -165,7 +221,7 @@ module Mongo
     #
     # @since 2.0.0
     def credentials
-      { :user => user, :password => password }
+      { :user => @user, :password => @password }
     end
 
     # Get the database provided in the URI.
@@ -177,110 +233,161 @@ module Mongo
     #
     # @since 2.0.0
     def database
-      @match[4].nil? ? Database::ADMIN : @match[4]
+      @database ? @database : Database::ADMIN
     end
 
-    # Get the options provided in the URI.
-    #
-    # @example Get The options.
-    #   uri.options
-    #
-    # @return [Hash] The options.
-    #
-    #   Generic Options
-    #   * :replica_set [String] replica set name
-    #   * :connect_timeout [Fixnum] connect timeout
-    #   * :socket_timeout [Fixnum] socket timeout
-    #   * :ssl [true, false] ssl enabled?
-    #
-    #   Write Options (returned in a hash under the :write key)
-    #   * :w [String, Fixnum] write concern value
-    #   * :j [true, false] journal
-    #   * :fsync [true, false] fsync
-    #   * :timeout [Fixnum] timeout for write operation
-    #
-    #   Read Options (returned in a hash under the :read key)
-    #   * :mode [Symbol]  read mode
-    #   * :tag_sets [Array<Hash>] read tag sets
-    #
-    # @since 2.0.0
-    def options
-      parsed_options = @match[5]
-      return {} unless parsed_options
-      parsed_options.split('&').reduce({}) do |options, option|
-        key, value = option.split('=')
-        strategy = OPTION_MAP[key]
-        raise Error::InvalidURIOption.new(key) if strategy.nil?
-        add_option(strategy, value, options)
-        options
+    private
+
+    def setup!(remaining)
+      creds_hosts, db_opts = extract_db_opts!(remaining)
+      parse_creds_hosts!(creds_hosts)
+      parse_db_opts!(db_opts)
+    end
+
+    def extract_db_opts!(string)
+      db_opts, d, creds_hosts = string.reverse.partition(DATABASE_DELIM)
+      db_opts, creds_hosts = creds_hosts, db_opts if creds_hosts.empty?
+      if db_opts.empty? && creds_hosts.include?(URI_OPTS_DELIM)
+        raise_invalid_error!(INVALID_OPTS_DELIM)
       end
+      [ creds_hosts, db_opts ].map { |s| s.reverse }
     end
 
-    private
+    def parse_creds_hosts!(string)
+      hosts, creds = split_creds_hosts(string)
+      @servers = parse_servers!(hosts)
+      @user = parse_user!(creds)
+      @password = parse_password!(creds)
+    end
+
+    def split_creds_hosts(string)
+      hosts, d, creds = string.reverse.partition(AUTH_DELIM)
+      hosts, creds = creds, hosts if hosts.empty?
+      [ hosts, creds ].map { |s| s.reverse }
+    end
+
+    def parse_db_opts!(string)
+      auth_db, d, uri_opts = string.partition(URI_OPTS_DELIM)
+      @uri_options = Options::Redacted.new(parse_uri_options!(uri_opts))
+      @database = parse_database!(auth_db)
+    end
+
+    def parse_uri_options!(string)
+      return {} unless string
+      string.split(INDIV_URI_OPTS_DELIM).reduce({}) do |uri_options, opt|
+        raise_invalid_error!(INVALID_OPTS_VALUE_DELIM) unless opt.index(URI_OPTS_VALUE_DELIM)
+        key, value = opt.split(URI_OPTS_VALUE_DELIM)
+        strategy = URI_OPTION_MAP[key.downcase]
+        if strategy.nil?
+          log_warn("Unsupported URI option '#{key}' on URI '#{@string}'. It will be ignored.")
+        else
+          add_uri_option(strategy, value, uri_options)
+        end
+        uri_options
+      end
+    end
+
+    def parse_user!(string)
+      if (string && user = string.partition(AUTH_USER_PWD_DELIM)[0])
+        raise_invalid_error!(UNESCAPED_USER_PWD) if user =~ UNSAFE
+        decode(user) if user.length > 0
+      end
+    end
+
+    def parse_password!(string)
+      if (string && pwd = string.partition(AUTH_USER_PWD_DELIM)[2])
+        raise_invalid_error!(UNESCAPED_USER_PWD) if pwd =~ UNSAFE
+        decode(pwd) if pwd.length > 0
+      end
+    end
+
+    def parse_database!(string)
+      raise_invalid_error!(UNESCAPED_DATABASE) if string =~ UNSAFE
+      decode(string) if string.length > 0
+    end
+
+    def validate_port_string!(port)
+      unless port.nil? || (port.length > 0 && port.to_i > 0 && port.to_i <= 65535)
+        raise_invalid_error!(INVALID_PORT)
+      end
+    end
+
+    def parse_servers!(string)
+      raise_invalid_error!(INVALID_HOST) unless string.size > 0
+      string.split(HOST_DELIM).reduce([]) do |servers, host|
+        if host[0] == '['
+          if host.index(']:')
+            h, p = host.split(']:')
+            validate_port_string!(p)
+          end
+        elsif host.index(HOST_PORT_DELIM)
+          h, d, p = host.partition(HOST_PORT_DELIM)
+          raise_invalid_error!(INVALID_HOST) unless h.size > 0
+          validate_port_string!(p)
+        elsif host =~ UNIX_SOCKET
+          raise_invalid_error!(UNESCAPED_UNIX_SOCKET) if host =~ UNSAFE
+        end
+        servers << host
+      end
+    end
+
+    def raise_invalid_error!(details)
+      raise Error::InvalidURI.new(@string, details)
+    end
+
+    def decode(value)
+      ::URI.decode(value)
+    end
 
     # Hash for storing map of URI option parameters to conversion strategies
-    OPTION_MAP = {}
+    URI_OPTION_MAP = {}
 
-    # Simple internal dsl to register a MongoDB URI option in the OPTION_MAP.
+    # Simple internal dsl to register a MongoDB URI option in the URI_OPTION_MAP.
     #
     # @param uri_key [String] The MongoDB URI option to register.
     # @param name [Symbol] The name of the option in the driver.
     # @param extra [Hash] Extra options.
     #   * :group [Symbol] Nested hash where option will go.
     #   * :type [Symbol] Name of function to transform value.
-    def self.option(uri_key, name, extra = {})
-      OPTION_MAP[uri_key] = { :name => name }.merge(extra)
+    def self.uri_option(uri_key, name, extra = {})
+      URI_OPTION_MAP[uri_key] = { :name => name }.merge(extra)
     end
 
     # Replica Set Options
-    option 'replicaSet', :replica_set, :type => :replica_set
+    uri_option 'replicaset', :replica_set, :type => :replica_set
 
     # Timeout Options
-    option 'connectTimeoutMS', :connect_timeout, :type => :ms_convert
-    option 'socketTimeoutMS', :socket_timeout, :type => :ms_convert
-    option 'serverSelectionTimeoutMS', :server_selection_timeout, :type => :ms_convert
-    option 'localThresholdMS', :local_threshold, :type => :ms_convert
+    uri_option 'connecttimeoutms', :connect_timeout, :type => :ms_convert
+    uri_option 'sockettimeoutms', :socket_timeout, :type => :ms_convert
+    uri_option 'serverselectiontimeoutms', :server_selection_timeout, :type => :ms_convert
+    uri_option 'localthresholdms', :local_threshold, :type => :ms_convert
 
     # Write Options
-    option 'w', :w, :group => :write
-    option 'j', :j, :group => :write
-    option 'fsync', :fsync, :group => :write
-    option 'wtimeoutMS', :timeout, :group => :write
+    uri_option 'w', :w, :group => :write
+    uri_option 'journal', :j, :group => :write
+    uri_option 'fsync', :fsync, :group => :write
+    uri_option 'wtimeoutms', :timeout, :group => :write
 
     # Read Options
-    option 'readPreference', :mode, :group => :read, :type => :read_mode
-    option 'readPreferenceTags', :tag_sets, :group => :read, :type => :read_tags
+    uri_option 'readpreference', :mode, :group => :read, :type => :read_mode
+    uri_option 'readpreferencetags', :tag_sets, :group => :read, :type => :read_tags
 
     # Pool options
-    option 'minPoolSize', :min_pool_size
-    option 'maxPoolSize', :max_pool_size
-    option 'waitQueueTimeoutMS', :wait_queue_timeout, :type => :ms_convert
+    uri_option 'minpoolsize', :min_pool_size
+    uri_option 'maxpoolsize', :max_pool_size
+    uri_option 'waitqueuetimeoutms', :wait_queue_timeout, :type => :ms_convert
 
     # Security Options
-    option 'ssl', :ssl
+    uri_option 'ssl', :ssl
 
     # Topology options
-    option 'connect', :connect
+    uri_option 'connect', :connect
 
     # Auth Options
-    option 'authSource', :source, :group => :auth, :type => :auth_source
-    option 'authMechanism', :mechanism, :group => :auth, :type => :auth_mech
-    option 'authMechanismProperties', :auth_mech_properties, :group => :auth,
-           :type => :auth_mech_props
-
-    # Gets the user provided in the URI
-    #
-    # @return [String] The user.
-    def user
-      @match[1]
-    end
-
-    # Gets the password provided in the URI
-    #
-    # @return [String] The password.
-    def password
-      @match[2]
-    end
+    uri_option 'authsource', :source, :group => :auth, :type => :auth_source
+    uri_option 'authmechanism', :auth_mech, :type => :auth_mech
+    uri_option 'authmechanismproperties', :auth_mech_properties, :group => :auth,
+                 :type => :auth_mech_props
 
     # Casts option values that do not have a specifically provided
     # transofrmation to the appropriate type.
@@ -296,7 +403,7 @@ module Mongo
       elsif value =~ /[\d]/
         value.to_i
       else
-        value.to_sym
+        decode(value).to_sym
       end
     end
 
@@ -315,15 +422,15 @@ module Mongo
 
     # Selects the output destination for an option.
     #
-    # @param options [Hash] The base target.
-    # @param group [Symbol] Group subtarget.
+    # @param [Hash] uri_options The base target.
+    # @param [Symbol] group Group subtarget.
     #
     # @return [Hash] The target for the option.
-    def select_target(options, group = nil)
+    def select_target(uri_options, group = nil)
       if group
-        options[group] ||= {}
+        uri_options[group] ||= {}
       else
-        options
+        uri_options
       end
     end
 
@@ -338,15 +445,19 @@ module Mongo
     # @param target [Hash] The destination.
     # @param value [Object] The value to be merged.
     # @param name [Symbol] The name of the option.
-    def merge_option(target, value, name)
+    def merge_uri_option(target, value, name)
       if target.key?(name)
-        target[name] += value
+        if REPEATABLE_OPTIONS.include?(name)
+          target[name] += value
+        else
+          log_warn("Repeated option key: #{name}.")
+        end
       else
         target.merge!(name => value)
       end
     end
 
-    # Adds an option to the options hash via the supplied strategy.
+    # Adds an option to the uri options hash via the supplied strategy.
     #
     #   Acquires a target for the option based on group.
     #   Transforms the value.
@@ -354,11 +465,11 @@ module Mongo
     #
     # @param strategy [Symbol] The strategy for this option.
     # @param value [String] The value of the option.
-    # @param options [Hash] The base option target.
-    def add_option(strategy, value, options)
-      target = select_target(options, strategy[:group])
+    # @param uri_options [Hash] The base option target.
+    def add_uri_option(strategy, value, uri_options)
+      target = select_target(uri_options, strategy[:group])
       value = apply_transform(value, strategy[:type])
-      merge_option(target, value, strategy[:name])
+      merge_uri_option(target, value, strategy[:name])
     end
 
     # Replica set transformation, avoid converting to Symbol.
@@ -367,7 +478,7 @@ module Mongo
     #
     # @return [String] Same value to avoid cast to Symbol.
     def replica_set(value)
-      value
+      decode(value)
     end
 
     # Auth source transformation, either db string or :external.
@@ -377,7 +488,7 @@ module Mongo
     # @return [String] If auth source is database name.
     # @return [:external] If auth source is external authentication.
     def auth_source(value)
-      value == '$external' ? :external : value
+      value == '$external' ? :external : decode(value)
     end
 
     # Authentication mechanism transformation.
@@ -451,7 +562,7 @@ module Mongo
     def hash_extractor(value)
       value.split(',').reduce({}) do |set, tag|
         k, v = tag.split(':')
-        set.merge(k.downcase.to_sym => v)
+        set.merge(decode(k).downcase.to_sym => decode(v))
       end
     end
   end

data/lib/mongo/version.rb

@@ -17,5 +17,5 @@ module Mongo
   # The current version of the driver.
   #
   # @since 2.0.0
-  VERSION = '2.0.6'.freeze
+  VERSION = '2.1.0'.freeze
 end

data/lib/mongo.rb

@@ -15,22 +15,24 @@
 require 'forwardable'
 require 'bson'
 require 'openssl'
+require 'mongo/options'
 require 'mongo/loggable'
+require 'mongo/monitoring'
 require 'mongo/logger'
+require 'mongo/retryable'
+require 'mongo/operation'
 require 'mongo/error'
 require 'mongo/event'
 require 'mongo/address'
 require 'mongo/auth'
-require 'mongo/bulk_write'
 require 'mongo/client'
 require 'mongo/cluster'
 require 'mongo/collection'
 require 'mongo/cursor'
 require 'mongo/database'
+require 'mongo/dbref'
 require 'mongo/grid'
 require 'mongo/index'
-require 'mongo/operation'
-require 'mongo/options'
 require 'mongo/protocol'
 require 'mongo/server'
 require 'mongo/server_selector'

data/spec/mongo/address/unix_spec.rb

@@ -27,7 +27,7 @@ describe Mongo::Address::Unix do
   describe '#socket' do
 
     let(:address) do
-      '/path/to/socket.sock'
+      '/tmp/mongodb-27017.sock'
     end
 
     let(:socket) do

data/spec/mongo/address_spec.rb

@@ -203,4 +203,29 @@ describe Mongo::Address do
       end
     end
   end
+
+  describe "#socket" do
+
+    context 'when providing a DNS entry that resolves to both IPv6 and IPv4' do
+
+      let(:address) do
+        described_class.new(DEFAULT_ADDRESS)
+      end
+
+      let(:host) do
+        DEFAULT_ADDRESS.split(':').first
+      end
+
+      before do
+        allow(::Socket).to receive(:getaddrinfo).and_return(
+          [ ["AF_INET6", 0, '::1', '::1', ::Socket::AF_INET6, 1, 6],
+            ["AF_INET", 0, host, host, ::Socket::AF_INET, 1, 6]]
+        )
+      end
+
+      it "attempts to use IPv6 and fallbacks to IPv4" do
+        expect(address.socket(0.0)).not_to be_nil
+      end
+    end
+  end
 end

data/spec/mongo/auth/cr_spec.rb

@@ -6,8 +6,16 @@ describe Mongo::Auth::CR do
     Mongo::Address.new(DEFAULT_ADDRESS)
   end
 
+  let(:monitoring) do
+    Mongo::Monitoring.new
+  end
+
+  let(:listeners) do
+    Mongo::Event::Listeners.new
+  end
+
   let(:server) do
-    Mongo::Server.new(address, double('cluster'), Mongo::Event::Listeners.new, TEST_OPTIONS)
+    Mongo::Server.new(address, double('cluster'), monitoring, listeners, TEST_OPTIONS)
   end
 
   let(:connection) do

data/spec/mongo/auth/ldap/conversation_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Mongo::Auth::LDAP::Conversation do
+
+  let(:user) do
+    Mongo::Auth::User.new(
+      database: Mongo::Database::ADMIN,
+      user: 'user',
+      password: 'pencil'
+    )
+  end
+
+  let(:conversation) do
+    described_class.new(user)
+  end
+
+  describe '#start' do
+
+    let(:query) do
+      conversation.start
+    end
+
+    let(:selector) do
+      query.selector
+    end
+
+    it 'sets the sasl start flag' do
+      expect(selector[:saslStart]).to eq(1)
+    end
+
+    it 'sets the auto authorize flag' do
+      expect(selector[:autoAuthorize]).to eq(1)
+    end
+
+    it 'sets the mechanism' do
+      expect(selector[:mechanism]).to eq('PLAIN')
+    end
+
+    it 'sets the payload' do
+      expect(selector[:payload].data).to eq("\x00user\x00pencil")
+    end
+  end
+end