mongo 1.12.5 → 2.0.0.beta

data/lib/mongo/functional/uri_parser.rb

@@ -1,409 +0,0 @@
-# Copyright (C) 2009-2013 MongoDB, 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.
-
-require 'cgi'
-require 'uri'
-
-module Mongo
-  class URIParser
-
-    AUTH_REGEX = /((.+)@)?/
-
-    HOST_REGEX = /([-.\w]+)|(\[[^\]]+\])/
-    PORT_REGEX = /(?::(\w+))?/
-    UNIX_SOCK_REGEX = /([\S]+.sock)/
-    NODE_REGEX = /((#{HOST_REGEX}#{PORT_REGEX},?)+|#{UNIX_SOCK_REGEX}{1})/
-
-    PATH_REGEX = /(?:\/([-\w]+))?/
-
-    MONGODB_URI_MATCHER = /#{AUTH_REGEX}#{NODE_REGEX}#{PATH_REGEX}/
-    MONGODB_URI_SPEC = "mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database][?options]]"
-
-    SPEC_ATTRS = [:nodes, :auths]
-
-    READ_PREFERENCES = {
-      'primary'            => :primary,
-      'primarypreferred'   => :primary_preferred,
-      'secondary'          => :secondary,
-      'secondarypreferred' => :secondary_preferred,
-      'nearest'            => :nearest
-    }
-
-    OPT_ATTRS  = [
-      :authmechanism,
-      :authmechanismproperties,
-      :authsource,
-      :connect,
-      :connecttimeoutms,
-      :fsync,
-      :journal,
-      :pool_size,
-      :readpreference,
-      :readpreferencetags,
-      :replicaset,
-      :safe,
-      :slaveok,
-      :sockettimeoutms,
-      :ssl,
-      :w,
-      :wtimeout,
-      :wtimeoutms
-    ]
-
-    OPT_VALID = {
-      :authmechanism           => lambda { |arg| Mongo::Authentication.validate_mechanism(arg) },
-      :authmechanismproperties => lambda { |arg| arg.length > 0 },
-      :authsource              => lambda { |arg| arg.length > 0 },
-      :connect                 => lambda { |arg| [ 'direct', 'replicaset', 'true', 'false', true, false ].include?(arg) },
-      :connecttimeoutms        => lambda { |arg| arg =~ /^\d+$/ },
-      :fsync                   => lambda { |arg| ['true', 'false'].include?(arg) },
-      :journal                 => lambda { |arg| ['true', 'false'].include?(arg) },
-      :pool_size               => lambda { |arg| arg.to_i > 0 },
-      :readpreference          => lambda { |arg| READ_PREFERENCES.keys.include?(arg) },
-      :readpreferencetags      => lambda { |arg| arg.none? { |tags| tags.scan(/(\w+:\w+),?/).empty? } },
-      :replicaset              => lambda { |arg| arg.length > 0 },
-      :safe                    => lambda { |arg| ['true', 'false'].include?(arg) },
-      :slaveok                 => lambda { |arg| ['true', 'false'].include?(arg) },
-      :sockettimeoutms         => lambda { |arg| arg =~ /^\d+$/ },
-      :ssl                     => lambda { |arg| ['true', 'false'].include?(arg) },
-      :w                       => lambda { |arg| arg =~ /^\w+$/ },
-      :wtimeout                => lambda { |arg| arg =~ /^\d+$/ },
-      :wtimeoutms              => lambda { |arg| arg =~ /^\d+$/ }
-     }
-
-    OPT_ERR = {
-      :authmechanism           => Mongo::Authentication::MECHANISM_ERROR,
-      :authmechanismproperties => "must meet the format requirements of the authentication mechanism's properties",
-      :authsource              => "must be a string containing the name of the database being used for authentication",
-      :connect                 => "must be 'direct', 'replicaset', 'true', or 'false'",
-      :connecttimeoutms        => "must be an integer specifying milliseconds",
-      :fsync                   => "must be 'true' or 'false'",
-      :journal                 => "must be 'true' or 'false'",
-      :pool_size               => "must be an integer greater than zero",
-      :readpreference          => "must be one of #{READ_PREFERENCES.keys.map(&:inspect).join(",")}",
-      :readpreferencetags      => "must be a comma-separated list of one or more key:value pairs",
-      :replicaset              => "must be a string containing the name of the replica set to connect to",
-      :safe                    => "must be 'true' or 'false'",
-      :slaveok                 => "must be 'true' or 'false'",
-      :settimeoutms            => "must be an integer specifying milliseconds",
-      :ssl                     => "must be 'true' or 'false'",
-      :w                       => "must be an integer indicating number of nodes to replicate to or a string " +
-                                  "specifying that replication is required to the majority or nodes with a " +
-                                  "particilar getLastErrorMode.",
-      :wtimeout                => "must be an integer specifying milliseconds",
-      :wtimeoutms              => "must be an integer specifying milliseconds"
-    }
-
-    OPT_CONV = {
-      :authmechanism           => lambda { |arg| arg.upcase },
-      :authmechanismproperties => lambda { |arg| arg },
-      :authsource              => lambda { |arg| arg },
-      :connect                 => lambda { |arg| arg == 'false' ? false : arg }, # convert 'false' to FalseClass
-      :connecttimeoutms        => lambda { |arg| arg.to_f / 1000 }, # stored as seconds
-      :fsync                   => lambda { |arg| arg == 'true' ? true : false },
-      :journal                 => lambda { |arg| arg == 'true' ? true : false },
-      :pool_size               => lambda { |arg| arg.to_i },
-      :readpreference          => lambda { |arg| READ_PREFERENCES[arg] },
-      :readpreferencetags      => lambda { |arg| arg.map do |tags|
-                                                   tags.scan(/(\w+:\w+),?/).reduce({}) do |tags, pair|
-                                                     key, value = pair.first.split(":")
-                                                     tags.merge!(key => value)
-                                                   end
-                                                 end },
-      :replicaset              => lambda { |arg| arg },
-      :safe                    => lambda { |arg| arg == 'true' ? true : false },
-      :slaveok                 => lambda { |arg| arg == 'true' ? true : false },
-      :sockettimeoutms         => lambda { |arg| arg.to_f / 1000 }, # stored as seconds
-      :ssl                     => lambda { |arg| arg == 'true' ? true : false },
-      :w                       => lambda { |arg| Mongo::Support.is_i?(arg) ? arg.to_i : arg.to_sym },
-      :wtimeout                => lambda { |arg| arg.to_i },
-      :wtimeoutms              => lambda { |arg| arg.to_i }
-    }
-
-    OPT_CASE_SENSITIVE = [ :authsource,
-                           :authmechanismproperties,
-                           :replicaset,
-                           :w
-                         ]
-
-    OPT_NOT_STRING = [ :readpreferencetags ]
-
-    attr_reader :auths,
-                :authmechanism,
-                :authmechanismproperties,
-                :authsource,
-                :connect,
-                :connecttimeoutms,
-                :db_name,
-                :fsync,
-                :journal,
-                :nodes,
-                :pool_size,
-                :readpreference,
-                :readpreferencetags,
-                :replicaset,
-                :safe,
-                :slaveok,
-                :sockettimeoutms,
-                :ssl,
-                :w,
-                :wtimeout,
-                :wtimeoutms
-
-    # Parse a MongoDB URI. This method is used by MongoClient.from_uri.
-    # Returns an array of nodes and an array of db authorizations, if applicable.
-    #
-    # @note Passwords can contain any character except for ','
-    #
-    # @param [String] uri The MongoDB URI string.
-    def initialize(uri)
-      if uri.start_with?('mongodb://')
-        uri = uri[10..-1]
-      else
-        raise MongoArgumentError, "MongoDB URI must match this spec: #{MONGODB_URI_SPEC}"
-      end
-
-      hosts, opts = uri.split('?')
-      parse_options(opts)
-      parse_hosts(hosts)
-      validate_connect
-    end
-
-    # Create a Mongo::MongoClient or a Mongo::MongoReplicaSetClient based on the URI.
-    #
-    # @note Don't confuse this with attribute getter method #connect.
-    #
-    # @return [MongoClient,MongoReplicaSetClient]
-    def connection(extra_opts={}, legacy = false, sharded = false)
-      opts = connection_options.merge!(extra_opts)
-      if(legacy)
-        if replicaset?
-          ReplSetConnection.new(node_strings, opts)
-        else
-          Connection.new(host, port, opts)
-        end
-      else
-        if sharded
-          MongoShardedClient.new(node_strings, opts)
-        elsif replicaset?
-          MongoReplicaSetClient.new(node_strings, opts)
-        else
-          MongoClient.new(host, port, opts)
-        end
-      end
-    end
-
-    # Whether this represents a replica set.
-    # @return [true,false]
-    def replicaset?
-      replicaset.is_a?(String) || nodes.length > 1
-    end
-
-    # Whether to immediately connect to the MongoDB node[s]. Defaults to true.
-    # @return [true, false]
-    def connect?
-      connect != false
-    end
-
-    # Whether this represents a direct connection.
-    #
-    # @note Specifying :connect => 'direct' has no effect... other than to raise an exception if other variables suggest a replicaset.
-    #
-    # @return [true,false]
-    def direct?
-      !replicaset?
-    end
-
-    # For direct connections, the host of the (only) node.
-    # @return [String]
-    def host
-      nodes[0][0]
-    end
-
-    # For direct connections, the port of the (only) node.
-    # @return [Integer]
-    def port
-      nodes[0][1].to_i
-    end
-
-    # Options that can be passed to MongoClient.new or MongoReplicaSetClient.new
-    # @return [Hash]
-    def connection_options
-      opts = {}
-
-      if @wtimeout
-        warn "Using wtimeout in a URI is deprecated, please use wtimeoutMS. It will be removed in v2.0."
-        opts[:wtimeout] = @wtimeout
-      end
-      opts[:wtimeout] = @wtimeoutms if @wtimeoutms
-
-      opts[:w]     = 1 if @safe
-      opts[:w]     = @w if @w
-      opts[:j]     = @journal if @journal
-      opts[:fsync] = @fsync if @fsync
-
-      opts[:connect_timeout] = @connecttimeoutms if @connecttimeoutms
-      opts[:op_timeout]      = @sockettimeoutms if @sockettimeoutms
-      opts[:pool_size]       = @pool_size if @pool_size
-      opts[:read]            = @readpreference if @readpreference
-      opts[:tag_sets]        = @readpreferencetags if @readpreferencetags
-
-      if @slaveok && !@readpreference
-        unless replicaset?
-          opts[:slave_ok] = true
-        else
-          opts[:read] = :secondary_preferred
-        end
-      end
-
-      if replicaset.is_a?(String)
-        opts[:name] = replicaset
-      end
-
-      opts[:db_name] = @db_name if @db_name
-      opts[:auths]   = @auths if @auths
-      opts[:ssl]     = @ssl if @ssl
-      opts[:connect] = connect?
-
-      opts
-    end
-
-    def node_strings
-      nodes.map { |node| node.join(':') }
-    end
-
-    private
-
-    def parse_hosts(uri_without_protocol)
-      @nodes = []
-      @auths = Set.new
-
-      unless matches = MONGODB_URI_MATCHER.match(uri_without_protocol)
-        raise MongoArgumentError,
-          "MongoDB URI must match this spec: #{MONGODB_URI_SPEC}"
-      end
-
-      user_info = matches[2].split(':') if matches[2]
-      host_info = matches[3].split(',')
-      @db_name  = matches[9]
-
-      if host_info.first.end_with?('.sock')
-        @nodes << [ host_info.first ]
-      else
-        host_info.each do |host|
-          if host[0,1] == '['
-            host, port = host.split(']:') << MongoClient::DEFAULT_PORT
-            host = host.end_with?(']') ? host[1...-1] : host[1..-1]
-          else
-            host, port = host.split(':') << MongoClient::DEFAULT_PORT
-          end
-          unless port.to_s =~ /^\d+$/
-            raise MongoArgumentError,
-              "Invalid port #{port}; port must be specified as digits."
-          end
-          @nodes << [host, port.to_i]
-        end
-      end
-
-      if @nodes.empty?
-        raise MongoArgumentError,
-          "No nodes specified. Please ensure that you've provided at " +
-          "least one node."
-      end
-
-      # no user info to parse, exit here
-      return unless user_info
-
-      # check for url encoding for username and password
-      username, password = user_info
-      if user_info.size > 2 ||
-         (username && username.include?('@')) ||
-         (password && password.include?('@'))
-
-        raise MongoArgumentError,
-          "The characters ':' and '@' in a username or password " +
-          "must be escaped (RFC 2396)."
-      end
-
-      # if username exists, proceed adding to auth set
-      unless username.nil? || username.empty?
-        auth = Authentication.validate_credentials({
-          :db_name   => @db_name,
-          :username  => URI.unescape(username),
-          :password  => password ? URI.unescape(password) : nil,
-          :source    => @authsource,
-          :mechanism => @authmechanism,
-          :extra     => @authmechanismproperties || {}
-        })
-
-        @auths << auth
-      end
-    end
-
-    # This method uses the lambdas defined in OPT_VALID and OPT_CONV to validate
-    # and convert the given options.
-    def parse_options(string_opts)
-      # initialize instance variables for available options
-      OPT_VALID.keys.each { |k| instance_variable_set("@#{k}", nil) }
-
-      string_opts ||= ''
-
-      return if string_opts.empty?
-
-      if string_opts.include?(';') and string_opts.include?('&')
-        raise MongoArgumentError, 'must not mix URL separators ; and &'
-      end
-
-      opts = CGI.parse(string_opts).inject({}) do |memo, (key, value)|
-        key_sym = key.downcase.to_sym
-        if OPT_NOT_STRING.include?(key_sym)
-          memo[key_sym] = value
-        else
-          value = value.first
-          memo[key_sym] = OPT_CASE_SENSITIVE.include?(key_sym) ? value.strip : value.strip.downcase
-        end
-        memo
-      end
-
-      opts.each do |key, value|
-        if !OPT_ATTRS.include?(key)
-          raise MongoArgumentError, "Invalid Mongo URI option #{key}"
-        end
-        if OPT_VALID[key].call(value)
-          instance_variable_set("@#{key}", OPT_CONV[key].call(value))
-        else
-          raise MongoArgumentError, "Invalid value #{value.inspect} for #{key}: #{OPT_ERR[key]}"
-        end
-      end
-
-      if @authmechanismproperties
-        @authmechanismproperties = @authmechanismproperties.split(',').reduce({}) do |prop, pair|
-          key, value = pair.split(':')
-          if ["true", "false"].include?(value.downcase)
-            value = value.downcase == "true"
-          end
-          prop[key.downcase.to_sym] = value
-          prop
-        end
-      end
-    end
-
-    def validate_connect
-      if replicaset? and @connect == 'direct'
-        # Make sure the user doesn't specify something contradictory
-        raise MongoArgumentError, "connect=direct conflicts with setting a replicaset name"
-      end
-    end
-  end
-end

data/lib/mongo/functional/write_concern.rb

@@ -1,66 +0,0 @@
-# Copyright (C) 2009-2013 MongoDB, 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 Mongo
-  module WriteConcern
-    VALID_KEYS = [:w, :j, :fsync, :wtimeout]
-    DEFAULT_WRITE_CONCERN = {:w => 1}
-
-    attr_reader :legacy_write_concern
-
-    @@safe_warn = nil
-    def write_concern_from_legacy(opts)
-      # Warn if 'safe' parameter is being used,
-      if opts.key?(:safe) && !@@safe_warn && !ENV['TEST_MODE']
-        warn "[DEPRECATED] The 'safe' write concern option has been deprecated in favor of 'w'."
-        @@safe_warn = true
-      end
-
-      # nil:   set :w => 0
-      # false: set :w => 0
-      # true:  set :w => 1
-      # hash:  set :w => 0 and merge with opts
-
-      unless opts.has_key?(:w)
-        opts[:w] = 0 # legacy default, unacknowledged
-        safe     = opts.delete(:safe)
-        if(safe && safe.is_a?(Hash))
-          opts.merge!(safe)
-        elsif(safe == true)
-          opts[:w] = 1
-        end
-      end
-    end
-
-    # todo: throw exception for conflicting write concern options
-    def get_write_concern(opts, parent=nil)
-      write_concern_from_legacy(opts) if opts.key?(:safe) || legacy_write_concern
-      write_concern = DEFAULT_WRITE_CONCERN.dup
-      write_concern.merge!(parent.write_concern) if parent
-      write_concern.merge!(opts.reject {|k,v| !VALID_KEYS.include?(k)})
-      write_concern[:w] = write_concern[:w].to_s if write_concern[:w].is_a?(Symbol)
-      write_concern
-    end
-
-    def self.gle?(write_concern)
-      (write_concern[:w].is_a? Symbol) ||
-      (write_concern[:w].is_a? String) ||
-      write_concern[:w] > 0 ||
-      write_concern[:j] ||
-      write_concern[:fsync] ||
-      write_concern[:wtimeout]
-    end
-
-  end
-end