mongo 1.12.5 → 2.0.0

data/lib/mongo/grid/fs.rb

@@ -0,0 +1,149 @@
+# Copyright (C) 2014-2015 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 Grid
+
+    # Represents a view of the GridFS in the database.
+    #
+    # @since 2.0.0
+    class FS
+      extend Forwardable
+
+      # The default root prefix.
+      #
+      # @since 2.0.0
+      DEFAULT_ROOT = 'fs'.freeze
+
+      # The specification for the chunks index.
+      #
+      # @since 2.0.0
+      INDEX_SPEC = { :files_id => 1, :n => 1 }.freeze
+
+      # @return [ Collection ] chunks_collection The chunks collection.
+      attr_reader :chunks_collection
+
+      # @return [ Database ] database The database.
+      attr_reader :database
+
+      # @return [ Collection ] files_collection The files collection.
+      attr_reader :files_collection
+
+      # Get write concern from database.
+      def_delegators :database, :write_concern
+
+      # Find a file in the GridFS.
+      #
+      # @example Find a file by it's id.
+      #   fs.find_one(_id: id)
+      #
+      # @example Find a file by it's filename.
+      #   fs.find_one(filename: 'test.txt')
+      #
+      # @param [ Hash ] selector The selector.
+      #
+      # @return [ Grid::File ] The file.
+      #
+      # @since 2.0.0
+      def find_one(selector = nil)
+        metadata = files_collection.find(selector).first
+        return nil unless metadata
+        chunks = chunks_collection.find(:files_id => metadata[:_id]).sort(:n => 1)
+        Grid::File.new(chunks.to_a, metadata)
+      end
+
+      # Insert a single file into the GridFS.
+      #
+      # @example Insert a single file.
+      #   fs.insert_one(file)
+      #
+      # @param [ Grid::File ] file The file to insert.
+      #
+      # @return [ Result ] The result of the insert.
+      #
+      # @since 2.0.0
+      def insert_one(file)
+        files_collection.insert_one(file.metadata)
+        result = chunks_collection.insert_many(file.chunks)
+        if write_concern.get_last_error
+          validate_md5!(file)
+        else
+          result
+        end
+      end
+
+      # Create the GridFS.
+      #
+      # @example Create the GridFS.
+      #   Grid::FS.new(database)
+      #
+      # @param [ Database ] database The database the files reside in.
+      # @param [ Hash ] options The GridFS options.
+      #
+      # @option options [ String ] :fs_name The prefix for the files and chunks
+      #   collections.
+      #
+      # @since 2.0.0
+      def initialize(database, options = {})
+        @database = database
+        @options = options
+        @chunks_collection = database[chunks_name]
+        @files_collection = database[files_name]
+        chunks_collection.indexes.create_one(INDEX_SPEC, :unique => true)
+      end
+
+      # Get the prefix for the GridFS
+      #
+      # @example Get the prefix.
+      #   fs.prefix
+      #
+      # @return [ String ] The GridFS prefix.
+      #
+      # @since 2.0.0
+      def prefix
+        @options[:fs_name] || DEFAULT_ROOT
+      end
+
+      # Remove a single file from the GridFS.
+      #
+      # @example Remove a file from the GridFS.
+      #   fs.delete_one(file)
+      #
+      # @param [ Grid::File ] file The file to remove.
+      #
+      # @return [ Result ] The result of the remove.
+      #
+      # @since 2.0.0
+      def delete_one(file)
+        files_collection.find(:_id => file.id).delete_one
+        chunks_collection.find(:files_id => file.id).delete_many
+      end
+
+      private
+
+      def chunks_name
+        "#{prefix}.#{Grid::File::Chunk::COLLECTION}"
+      end
+
+      def files_name
+        "#{prefix}.#{Grid::File::Metadata::COLLECTION}"
+      end
+
+      def validate_md5!(file)
+        md5 = database.command(:filemd5 => file.id, :root => prefix).documents[0][:md5]
+        raise Error::InvalidFile.new(file.md5, md5) unless file.md5 == md5
+      end
+    end
+  end
+end

data/lib/mongo/{gridfs.rb → grid.rb}

@@ -1,4 +1,4 @@
-# Copyright (C) 2009-2013 MongoDB, Inc.
+# Copyright (C) 2014-2015 MongoDB, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,7 +12,5 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'mongo/gridfs/grid_ext'
-require 'mongo/gridfs/grid'
-require 'mongo/gridfs/grid_file_system'
-require 'mongo/gridfs/grid_io'
+require 'mongo/grid/file'
+require 'mongo/grid/fs'

data/lib/mongo/index/view.rb

@@ -0,0 +1,261 @@
+# Copyright (C) 2014-2015 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 Index
+
+    # A class representing a view of indexes.
+    #
+    # @since 2.0.0
+    class View
+      extend Forwardable
+      include Enumerable
+
+      # @return [ Collection ] collection The indexes collection.
+      attr_reader :collection
+
+      # @return [ Integer ] batch_size The size of the batch of results
+      #   when sending the listIndexes command.
+      attr_reader :batch_size
+
+      def_delegators :@collection, :cluster, :database, :read_preference
+      def_delegators :cluster, :next_primary
+
+      # The index key field.
+      #
+      # @since 2.0.0
+      KEY = 'key'.freeze
+
+      # The index name field.
+      #
+      # @since 2.0.0
+      NAME = 'name'.freeze
+
+      # The mappings of Ruby index options to server options.
+      #
+      # @since 2.0.0
+      OPTIONS = {
+        :background => :background,
+        :bits => :bits,
+        :bucket_size => :bucketSize,
+        :default_language => :default_language,
+        :expire_after => :expireAfterSeconds,
+        :key => :key,
+        :language_override => :language_override,
+        :max => :max,
+        :min => :min,
+        :name => :name,
+        :sparse => :sparse,
+        :sphere_version => :'2dsphereIndexVersion',
+        :storage_engine => :storageEngine,
+        :text_version => :textIndexVersion,
+        :unique => :unique,
+        :version => :v,
+        :weights => :weights
+      }.freeze
+
+      # Drop an index by its name.
+      #
+      # @example Drop an index by its name.
+      #   view.drop_one('name_1')
+      #
+      # @param [ String ] name The name of the index.
+      #
+      # @return [ Result ] The response.
+      #
+      # @since 2.0.0
+      def drop_one(name)
+        raise Error::MultiIndexDrop.new if name == '*'
+        drop_by_name(name)
+      end
+
+      # Drop all indexes on the collection.
+      #
+      # @example Drop all indexes on the collection.
+      #   view.drop_all
+      #
+      # @return [ Result ] The response.
+      #
+      # @since 2.0.0
+      def drop_all
+        drop_by_name('*')
+      end
+
+      # Creates an index on the collection.
+      #
+      # @example Create a unique index on the collection.
+      #   view.create_one({ name: 1 }, { unique: true })
+      #
+      # @param [ Hash ] keys A hash of field name/direction pairs.
+      # @param [ Hash ] options Options for this index.
+      #
+      # @option options [ true, false ] :unique (false) If true, this index will enforce
+      #   a uniqueness constraint on that field.
+      # @option options [ true, false ] :background (false) If true, the index will be built
+      #   in the background (only available for server versions >= 1.3.2 )
+      # @option options [ true, false ] :drop_dups (false) If creating a unique index on
+      #   this collection, this option will keep the first document the database indexes
+      #   and drop all subsequent documents with duplicate values on this field.
+      # @option options [ Integer ] :bucket_size (nil) For use with geoHaystack indexes.
+      #   Number of documents to group together within a certain proximity to a given
+      #   longitude and latitude.
+      # @option options [ Integer ] :max (nil) Specify the max latitude and longitude for
+      #   a geo index.
+      # @option options [ Integer ] :min (nil) Specify the min latitude and longitude for
+      #   a geo index.
+      #
+      # @note Note that the options listed may be subset of those available.
+      # See the MongoDB documentation for a full list of supported options by server version.
+      #
+      # @return [ Result ] The response.
+      #
+      # @since 2.0.0
+      def create_one(keys, options = {})
+        create_many({ key: keys }.merge(options))
+      end
+
+      # Creates multiple indexes on the collection.
+      #
+      # @example Create multiple indexes.
+      #   view.create_many([
+      #     { key: { name: 1 }, unique: true },
+      #     { key: { age: -1 }, background: true }
+      #   ])
+      #
+      # @note On MongoDB 3.0.0 and higher, the indexes will be created in
+      #   parallel on the server.
+      #
+      # @param [ Array<Hash> ] models The index specifications. Each model MUST
+      #   include a :key option.
+      #
+      # @return [ Result ] The result of the command.
+      #
+      # @since 2.0.0
+      def create_many(*models)
+        Operation::Write::CreateIndex.new(
+          indexes: normalize_models(models.flatten),
+          db_name: database.name,
+          coll_name: collection.name,
+        ).execute(next_primary.context)
+      end
+
+      # Convenience method for getting index information by a specific name or
+      # spec.
+      #
+      # @example Get index information by name.
+      #   view.get('name_1')
+      #
+      # @example Get index information by the keys.
+      #   view.get(name: 1)
+      #
+      # @param [ Hash, String ] keys_or_name The index name or spec.
+      #
+      # @return [ Hash ] The index information.
+      #
+      # @since 2.0.0
+      def get(keys_or_name)
+        find do |index|
+          (index[NAME] == keys_or_name) || (index[KEY] == normalize_keys(keys_or_name))
+        end
+      end
+
+      # Iterate over all indexes for the collection.
+      #
+      # @example Get all the indexes.
+      #   view.each do |index|
+      #     ...
+      #   end
+      #
+      # @since 2.0.0
+      def each(&block)
+        server = next_primary
+        cursor = Cursor.new(self, send_initial_query(server), server).to_enum
+        cursor.each do |doc|
+          yield doc
+        end if block_given?
+        cursor
+      end
+
+      # Create the new index view.
+      #
+      # @example Create the new index view.
+      #   View::Index.new(collection)
+      #
+      # @param [ Collection ] collection The collection.
+      # @param [ Hash ] options Options for getting a list of indexes.
+      #   Only relevant for when the listIndexes command is used with server
+      #   versions >=2.8.
+      #
+      # @option options [ Integer ] :batch_size The batch size for results
+      #   returned from the listIndexes command.
+      #
+      # @since 2.0.0
+      def initialize(collection, options = {})
+        @collection = collection
+        @batch_size = options[:batch_size]
+      end
+
+      private
+
+      def drop_by_name(name)
+        Operation::Write::DropIndex.new(
+          db_name: database.name,
+          coll_name: collection.name,
+          index_name: name
+        ).execute(next_primary.context)
+      end
+
+      def index_name(spec)
+        spec.to_a.join('_')
+      end
+
+      def indexes_spec
+        { selector: {
+            listIndexes: collection.name,
+            cursor: batch_size ? { batchSize: batch_size } : {} },
+          coll_name: collection.name,
+          db_name: database.name }
+      end
+
+      def initial_query_op
+        Operation::Read::Indexes.new(indexes_spec)
+      end
+
+      def limit; -1; end
+
+      def normalize_keys(spec)
+        return false if spec.is_a?(String)
+        Options::Mapper.transform_keys_to_strings(spec)
+      end
+
+      def normalize_models(models)
+        with_generated_names(models).map do |model|
+          Options::Mapper.transform(model, OPTIONS)
+        end
+      end
+
+      def send_initial_query(server)
+        initial_query_op.execute(server.context)
+      end
+
+      def with_generated_names(models)
+        models.dup.each do |model|
+          unless model[:name]
+            model[:name] = index_name(model[:key])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongo/index.rb

@@ -0,0 +1,64 @@
+# Copyright (C) 2014-2015 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 'mongo/index/view'
+
+module Mongo
+
+  # Contains constants for indexing purposes.
+  #
+  # @since 2.0.0
+  module Index
+
+    # Specify ascending order for an index.
+    #
+    # @since 2.0.0
+    ASCENDING = 1
+
+    # Specify descending order for an index.
+    #
+    # @since 2.0.0
+    DESCENDING = -1
+
+    # Specify a 2d Geo index.
+    #
+    # @since 2.0.0
+    GEO2D = '2d'.freeze
+
+    # Specify a 2d sphere Geo index.
+    #
+    # @since 2.0.0
+    GEO2DSPHERE = '2dsphere'.freeze
+
+    # Specify a geoHaystack index.
+    #
+    # @since 2.0.0
+    GEOHAYSTACK = 'geoHaystack'.freeze
+
+    # Encodes a text index.
+    #
+    # @since 2.0.0
+    TEXT = 'text'.freeze
+
+    # Specify a hashed index.
+    #
+    # @since 2.0.0
+    HASHED = 'hashed'.freeze
+
+    # Constant for the indexes collection.
+    #
+    # @since 2.0.0
+    COLLECTION = 'system.indexes'.freeze
+  end
+end

data/lib/mongo/loggable.rb

@@ -0,0 +1,126 @@
+# Copyright (C) 2014-2015 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
+
+  # Allows objects to easily log operations.
+  #
+  # @since 2.0.0
+  module Loggable
+
+    # The standard MongoDB log prefix.
+    #
+    # @since 2.0.0
+    PREFIX = 'MONGODB'.freeze
+
+    # Log the operations. If a block is provided it will be yielded to,
+    # otherwise only the logging will take place.
+    #
+    # @example Log a query operation.
+    #   loggable.log(:debug, "MONGO.query", operations)
+    #
+    # @param [ Symbol ] level The log level.
+    # @param [ String ] prefix The prefix for the log line.
+    # @param [ Array<Object> ] operations The operations to log. The must
+    #   respond to #log_message.
+    #
+    # @return [ Object ] The result of the block or nil if no block given.
+    #
+    # @since 2.0.0
+    def log(level, prefix, operations)
+      started = Time.new
+      begin
+        yield(operations) if block_given?
+      rescue Exception => e
+        raise e
+      ensure
+        runtime = ("%.4fms" % (1000 * (Time.now.to_f - started.to_f)))
+        operations.each do |operation|
+          Logger.send(level, prefix, log_inspect(operation), runtime)
+        end
+      end
+    end
+
+    # Convenience method to log debug messages with the standard prefix.
+    #
+    # @example Log a debug message.
+    #   log_debug([ 'Message' ])
+    #
+    # @param [ Array<Operation, String> ] operations The operations or messages
+    #   to log.
+    #
+    # @since 2.0.0
+    def log_debug(operations, &block)
+      log(:debug, PREFIX, operations, &block)
+    end
+
+    # Convenience method to log error messages with the standard prefix.
+    #
+    # @example Log a error message.
+    #   log_error([ 'Message' ])
+    #
+    # @param [ Array<Operation, String> ] operations The operations or messages
+    #   to log.
+    #
+    # @since 2.0.0
+    def log_error(operations, &block)
+      log(:error, PREFIX, operations, &block)
+    end
+
+    # Convenience method to log fatal messages with the standard prefix.
+    #
+    # @example Log a fatal message.
+    #   log_fatal([ 'Message' ])
+    #
+    # @param [ Array<Operation, String> ] operations The operations or messages
+    #   to log.
+    #
+    # @since 2.0.0
+    def log_fatal(operations, &block)
+      log(:fatal, PREFIX, operations, &block)
+    end
+
+    # Convenience method to log info messages with the standard prefix.
+    #
+    # @example Log a info message.
+    #   log_info([ 'Message' ])
+    #
+    # @param [ Array<Operation, String> ] operations The operations or messages
+    #   to log.
+    #
+    # @since 2.0.0
+    def log_info(operations, &block)
+      log(:info, PREFIX, operations, &block)
+    end
+
+    # Convenience method to log warn messages with the standard prefix.
+    #
+    # @example Log a warn message.
+    #   log_warn([ 'Message' ])
+    #
+    # @param [ Array<Operation, String> ] operations The operations or messages
+    #   to log.
+    #
+    # @since 2.0.0
+    def log_warn(operations, &block)
+      log(:warn, PREFIX, operations, &block)
+    end
+
+    private
+
+    def log_inspect(operation)
+      operation.respond_to?(:log_message) ? operation.log_message : operation
+    end
+  end
+end