mongoid-braxton 2.0.2

data/lib/mongoid/collections/retry.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Collections #:nodoc:
+
+    # Provides behaviour for retrying commands on connection failure.
+    module Retry
+
+      # Retries command on connection failures.
+      #
+      # This is useful when using replica sets. When a primary server wents
+      # down and a command is issued, the driver will raise a
+      # Mongo::ConnectionFailure. We wait a little bit, because nodes are
+      # electing themselves, and then retry the given command.
+      #
+      # By setting Mongoid.max_retries_on_connection_failure to a value of 0,
+      # no attempt will be made, immediately raising connection failure.
+      # Otherwise it will attempt to make the specified number of retries
+      # and then raising the exception to clients.
+      #
+      # @example Retry the command.
+      #   retry_on_connection_failure do
+      #     collection.send(name, *args)
+      #   end
+      #
+      # @since 2.0.0
+      def retry_on_connection_failure
+        retries = 0
+        begin
+          yield
+        rescue Mongo::ConnectionFailure => ex
+          retries += 1
+          raise ex if retries > Mongoid.max_retries_on_connection_failure
+          Kernel.sleep(0.5)
+          retry
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/components.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Components #:nodoc
+    extend ActiveSupport::Concern
+
+    # All modules that a +Document+ is composed of are defined in this
+    # module, to keep the document class from getting too cluttered.
+    included do
+      extend ActiveModel::Translation
+      extend Mongoid::Finders
+    end
+
+    include ActiveModel::Conversion
+    include ActiveModel::MassAssignmentSecurity
+    include ActiveModel::Naming
+    include ActiveModel::Observing
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+    include Mongoid::Atomicity
+    include Mongoid::Attributes
+    include Mongoid::Collections
+    include Mongoid::Copyable
+    include Mongoid::DefaultScope
+    include Mongoid::Dirty
+    include Mongoid::Extras
+    include Mongoid::Fields
+    include Mongoid::Hierarchy
+    include Mongoid::Indexes
+    include Mongoid::Inspection
+    include Mongoid::JSON
+    include Mongoid::Keys
+    include Mongoid::Matchers
+    include Mongoid::NamedScope
+    include Mongoid::NestedAttributes
+    include Mongoid::Paths
+    include Mongoid::Persistence
+    include Mongoid::Relations
+    include Mongoid::Safety
+    include Mongoid::Serialization
+    include Mongoid::Sharding
+    include Mongoid::State
+    include Mongoid::Validations
+    include Mongoid::Callbacks
+  end
+end

data/lib/mongoid/config.rb

@@ -0,0 +1,349 @@
+# encoding: utf-8
+require "uri"
+require "mongoid/config/database"
+require "mongoid/config/replset_database"
+
+module Mongoid #:nodoc
+
+  # This module defines all the configuration options for Mongoid, including the
+  # database connections.
+  #
+  # @todo Durran: This module needs an overhaul, remove singleton, etc.
+  module Config
+    extend self
+    include ActiveModel::Observing
+
+    attr_accessor :master, :settings
+    @settings = {}
+
+    # Define a configuration option with a default.
+    #
+    # @example Define the option.
+    #   Config.option(:persist_in_safe_mode, :default => false)
+    #
+    # @param [ Symbol ] name The name of the configuration option.
+    # @param [ Hash ] options Extras for the option.
+    #
+    # @option options [ Object ] :default The default value.
+    #
+    # @since 2.0.0.rc.1
+    def option(name, options = {})
+      define_method(name) do
+        settings.has_key?(name) ? settings[name] : options[:default]
+      end
+      define_method("#{name}=") { |value| settings[name] = value }
+      define_method("#{name}?") { send(name) }
+    end
+
+    option :allow_dynamic_fields, :default => true
+    option :autocreate_indexes, :default => false
+    option :binding_defaults, :default => { :binding => false, :continue => true }
+    option :embedded_object_id, :default => true
+    option :include_root_in_json, :default => false
+    option :max_retries_on_connection_failure, :default => 0
+    option :parameterize_keys, :default => true
+    option :persist_in_safe_mode, :default => false
+    option :preload_models, :default => true
+    option :raise_not_found_error, :default => true
+    option :skip_version_check, :default => false
+    option :time_zone, :default => nil
+    option :use_utc, :default => false
+
+    # Adds a new I18n locale file to the load path.
+    #
+    # @example Add a portuguese locale.
+    #   Mongoid::Config.add_language('pt')
+    #
+    # @example Add all available languages.
+    #   Mongoid::Config.add_language('*')
+    #
+    # @param [ String ] language_code The language to add.
+    def add_language(language_code = nil)
+      Dir[
+        File.join(
+          File.dirname(__FILE__), "..", "config", "locales", "#{language_code}.yml"
+      )
+      ].each do |file|
+        I18n.load_path << File.expand_path(file)
+      end
+    end
+
+    # Get any extra databases that have been configured.
+    #
+    # @example Get the extras.
+    #   config.databases
+    #
+    # @return [ Hash ] A hash of secondary databases.
+    def databases
+      configure_extras(@settings["databases"]) unless @databases || !@settings
+      @databases || {}
+    end
+
+    # @todo Durran: There were no tests around the databases setter, not sure
+    # what the exact expectation was. Set with a hash?
+    def databases=(databases)
+    end
+
+    # Return field names that could cause destructive things to happen if
+    # defined in a Mongoid::Document.
+    #
+    # @example Get the destructive fields.
+    #   config.destructive_fields
+    #
+    # @return [ Array<String> ] An array of bad field names.
+    def destructive_fields
+      @destructive_fields ||= lambda {
+        klass = Class.new do
+          include Mongoid::Document
+        end
+        klass.instance_methods(true).collect { |method| method.to_s }
+      }.call
+    end
+
+    # Configure mongoid from a hash. This is usually called after parsing a
+    # yaml config file such as mongoid.yml.
+    #
+    # @example Configure Mongoid.
+    #   config.from_hash({})
+    #
+    # @param [ Hash ] options The settings to use.
+    def from_hash(options = {})
+      options.except("database", "slaves", "databases").each_pair do |name, value|
+        send("#{name}=", value) if respond_to?("#{name}=")
+      end
+      @master, @slaves = configure_databases(options)
+      configure_extras(options["databases"])
+    end
+
+    # Load the settings from a compliant mongoid.yml file. This can be used for
+    # easy setup with frameworks other than Rails.
+    #
+    # @example Configure Mongoid.
+    #   Mongoid.load!("/path/to/mongoid.yml")
+    #
+    # @param [ String ] path The path to the file.
+    #
+    # @since 2.0.1
+    def load!(path)
+      environment = defined?(Rails) ? Rails.env : ENV["RACK_ENV"]
+      settings = YAML.load(ERB.new(File.new(path).read).result)[environment]
+      if settings.present?
+        from_hash(settings)
+      end
+    end
+
+    # Returns the default logger, which is either a Rails logger of stdout logger
+    #
+    # @example Get the default logger
+    #   config.default_logger
+    #
+    # @return [ Logger ] The default Logger instance.
+    def default_logger
+      defined?(Rails) ? Rails.logger : ::Logger.new($stdout)
+    end
+
+    # Returns the logger, or defaults to Rails logger or stdout logger.
+    #
+    # @example Get the logger.
+    #   config.logger
+    #
+    # @return [ Logger ] The configured logger or a default Logger instance.
+    def logger
+      @logger = default_logger unless defined?(@logger)
+      @logger
+    end
+
+    # Sets the logger for Mongoid to use.
+    #
+    # @example Set the logger.
+    #   config.logger = Logger.new($stdout, :warn)
+    #
+    # @return [ Logger ] The newly set logger.
+    def logger=(logger)
+      @logger = logger
+    end
+
+    # Purge all data in all collections, including indexes.
+    #
+    # @example Purge all data.
+    #   Mongoid::Config.purge!
+    #
+    # @since 2.0.2
+    def purge!
+      master.collections.map do |collection|
+        collection.drop if collection.name !~ /system/
+      end
+    end
+
+    # Sets whether the times returned from the database use the ruby or
+    # the ActiveSupport time zone.
+    # If you omit this setting, then times will use the ruby time zone.
+    #
+    # Example:
+    #
+    # <tt>Config.use_activesupport_time_zone = true</tt>
+    #
+    # Returns:
+    #
+    # A boolean
+    def use_activesupport_time_zone=(value)
+      @use_activesupport_time_zone = value || false
+    end
+
+    # Sets whether the times returned from the database use the ruby or
+    # the ActiveSupport time zone.
+    # If the setting is false, then times will use the ruby time zone.
+    #
+    # Example:
+    #
+    # <tt>Config.use_activesupport_time_zone</tt>
+    #
+    # Returns:
+    #
+    # A boolean
+    attr_reader :use_activesupport_time_zone
+    alias_method :use_activesupport_time_zone?, :use_activesupport_time_zone
+
+    # Sets the Mongo::DB master database to be used. If the object trying to be
+    # set is not a valid +Mongo::DB+, then an error will be raised.
+    #
+    # @example Set the master database.
+    #   config.master = Mongo::Connection.db("test")
+    #
+    # @param [ Mongo::DB ] db The master database.
+    #
+    # @raise [ Errors::InvalidDatabase ] If the master isnt a valid object.
+    #
+    # @return [ Mongo::DB ] The master instance.
+    def master=(db)
+      check_database!(db)
+      @master = db
+    end
+    alias :database= :master=
+
+    # Returns the master database, or if none has been set it will raise an
+    # error.
+    #
+    # @example Get the master database.
+    #   config.master
+    #
+    # @raise [ Errors::InvalidDatabase ] If the database was not set.
+    #
+    # @return [ Mongo::DB ] The master database.
+    def master
+      unless @master
+        @master, @slaves = configure_databases(@settings) unless @settings.blank?
+        raise Errors::InvalidDatabase.new(nil) unless @master
+      end
+      if @reconnect
+        @reconnect = false
+        reconnect!
+      end
+      @master
+    end
+    alias :database :master
+
+    # Convenience method for connecting to the master database after forking a
+    # new process.
+    #
+    # @example Reconnect to the master.
+    #   Mongoid.reconnect!
+    #
+    # @param [ true, false ] now Perform the reconnection immediately?
+    def reconnect!(now = true)
+      if now
+        master.connection.connect
+      else
+        # We set a @reconnect flag so that #master knows to reconnect the next
+        # time the connection is accessed.
+        @reconnect = true
+      end
+    end
+
+    # Reset the configuration options to the defaults.
+    #
+    # @example Reset the configuration options.
+    #   config.reset
+    def reset
+      settings.clear
+    end
+
+    # @deprecated User replica sets instead.
+    def slaves
+      slave_warning!
+    end
+
+    # @deprecated User replica sets instead.
+    def slaves=(dbs)
+      slave_warning!
+    end
+
+    protected
+
+    # Check if the database is valid and the correct version.
+    #
+    # @example Check if the database is valid.
+    #   config.check_database!
+    #
+    # @param [ Mongo::DB ] database The db to check.
+    #
+    # @raise [ Errors::InvalidDatabase ] If the object is not valid.
+    # @raise [ Errors::UnsupportedVersion ] If the db version is too old.
+    def check_database!(database)
+      raise Errors::InvalidDatabase.new(database) unless database.kind_of?(Mongo::DB)
+      unless skip_version_check
+        version = database.connection.server_version
+        raise Errors::UnsupportedVersion.new(version) if version < Mongoid::MONGODB_VERSION
+      end
+    end
+
+    # Get a database from settings.
+    #
+    # @example Configure the master and slave dbs.
+    #   config.configure_databases("database" => "mongoid")
+    #
+    # @param [ Hash ] options The options to use.
+    #
+    # @option options [ String ] :database The database name.
+    # @option options [ String ] :host The database host.
+    # @option options [ String ] :password The password for authentication.
+    # @option options [ Integer ] :port The port for the database.
+    # @option options [ Array<Hash> ] :slaves The slave db options.
+    # @option options [ String ] :uri The uri for the database.
+    # @option options [ String ] :username The user for authentication.
+    #
+    # @since 2.0.0.rc.1
+    def configure_databases(options)
+      if options.has_key?('hosts')
+        ReplsetDatabase.new(options).configure
+      else
+        Database.new(options).configure
+      end
+    end
+
+    # Get the secondary databases from settings.
+    #
+    # @example Configure the master and slave dbs.
+    #   config.configure_extras("databases" => settings)
+    #
+    # @param [ Hash ] options The options to use.
+    #
+    # @since 2.0.0.rc.1
+    def configure_extras(extras)
+      @databases = (extras || []).inject({}) do |dbs, (name, options)|
+        dbs.tap do |extra|
+        dbs[name], dbs["#{name}_slaves"] = configure_databases(options)
+        end
+      end
+    end
+
+    # Temporarily here so people can move to replica sets.
+    def slave_warning!
+      warn(
+        "Using Mongoid for traditional slave databases will be removed in the " +
+        "next release in preference of replica sets. Please change your setup " +
+        "accordingly."
+      )
+    end
+  end
+end

data/lib/mongoid/config/database.rb

@@ -0,0 +1,167 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Config #:nodoc:
+
+    # This class handles the configuration and initialization of a mongodb
+    # database from options.
+    class Database < Hash
+
+      # Configure the database connections. This will return an array
+      # containing the master and an array of slaves.
+      #
+      # @example Configure the connection.
+      #   db.configure
+      #
+      # @return [ Array<Mongo::DB, Array<Mongo:DB>> ] The Mongo databases.
+      #
+      # @since 2.0.0.rc.1
+      def configure
+        [ master.db(name), slaves.map { |slave| slave.db(name) } ]
+      end
+
+      # Create the new db configuration class.
+      #
+      # @example Initialize the class.
+      #   Config::Database.new(
+      #     false, "uri" => { "mongodb://durran:password@localhost:27017/mongoid" }
+      #   )
+      #
+      # @param [ Hash ] options The configuration options.
+      #
+      # @option options [ String ] :database The database name.
+      # @option options [ String ] :host The database host.
+      # @option options [ String ] :password The password for authentication.
+      # @option options [ Integer ] :port The port for the database.
+      # @option options [ String ] :uri The uri for the database.
+      # @option options [ String ] :username The user for authentication.
+      #
+      # @since 2.0.0.rc.1
+      def initialize(options = {})
+        merge!(options)
+      end
+
+      private
+
+      # Do we need to authenticate against the database?
+      #
+      # @example Are we authenticating?
+      #   db.authenticating?
+      #
+      # @return [ true, false ] True if auth is needed, false if not.
+      #
+      # @since 2.0.0.rc.1
+      def authenticating?
+        username || password
+      end
+
+      # Takes the supplied options in the hash and created a URI from them to
+      # pass to the Mongo connection object.
+      #
+      # @example Build the URI.
+      #   db.build_uri
+      #
+      # @param [ Hash ] options The options to build with.
+      #
+      # @return [ String ] A mongo compliant URI string.
+      #
+      # @since 2.0.0.rc.1
+      def build_uri(options = {})
+        "mongodb://".tap do |base|
+          base << "#{username}:#{password}@" if authenticating?
+          base << "#{options["host"] || "localhost"}:#{options["port"] || 27017}"
+          base << "/#{self["database"]}" if authenticating?
+        end
+      end
+
+      # Create the mongo master connection from either the supplied URI
+      # or a generated one, while setting pool size and logging.
+      #
+      # @example Create the connection.
+      #   db.connection
+      #
+      # @return [ Mongo::Connection ] The mongo connection.
+      #
+      # @since 2.0.0.rc.1
+      def master
+        Mongo::Connection.from_uri(uri(self), optional).tap do |conn|
+          conn.apply_saved_authentication
+        end
+      end
+
+      # Create the mongo slave connections from either the supplied URI
+      # or a generated one, while setting pool size and logging.
+      #
+      # @example Create the connection.
+      #   db.connection
+      #
+      # @return [ Array<Mongo::Connection> ] The mongo slave connections.
+      #
+      # @since 2.0.0.rc.1
+      def slaves
+        (self["slaves"] || []).map do |options|
+          Mongo::Connection.from_uri(uri(options), optional(true)).tap do |conn|
+            conn.apply_saved_authentication
+          end
+        end
+      end
+
+      # Convenience for accessing the hash via dot notation.
+      #
+      # @example Access a value in alternate syntax.
+      #   db.host
+      #
+      # @return [ Object ] The value in the hash.
+      #
+      # @since 2.0.0.rc.1
+      def method_missing(name, *args, &block)
+        self[name.to_s]
+      end
+
+      # Get the name of the database, from either the URI supplied or the
+      # database value in the options.
+      #
+      # @example Get the database name.
+      #   db.name
+      #
+      # @return [ String ] The database name.
+      #
+      # @since 2.0.0.rc.1
+      def name
+        db_name = URI.parse(uri(self)).path.to_s.sub("/", "")
+        db_name.blank? ? database : db_name
+      end
+
+      # Get the options used in creating the database connection.
+      #
+      # @example Get the options.
+      #   db.options
+      #
+      # @param [ true, false ] slave Are the options for a slave db?
+      #
+      # @return [ Hash ] The hash of configuration options.
+      #
+      # @since 2.0.0.rc.1
+      def optional(slave = false)
+        {
+          :pool_size => pool_size,
+          :logger => Mongoid::Logger.new,
+          :slave_ok => slave
+        }
+      end
+
+      # Get a Mongo compliant URI for the database connection.
+      #
+      # @example Get the URI.
+      #   db.uri
+      #
+      # @param [ Hash ] options The options hash.
+      #
+      # @return [ String ] The URI for the connection.
+      #
+      # @since 2.0.0.rc.1
+      def uri(options = {})
+        options["uri"] || build_uri(options)
+      end
+    end
+  end
+end