Class: EM::Mongo::Database

Inherits:
Object
  • Object
show all
Defined in:
lib/em-mongo/database.rb

Constant Summary collapse

SYSTEM_NAMESPACE_COLLECTION = 
"system.namespaces"
SYSTEM_INDEX_COLLECTION = 
"system.indexes"
SYSTEM_PROFILE_COLLECTION = 
"system.profile"
SYSTEM_USER_COLLECTION = 
"system.users"
SYSTEM_JS_COLLECTION = 
"system.js"
SYSTEM_COMMAND_COLLECTION = 
"$cmd"

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(name = DEFAULT_DB, connection = nil) ⇒ Database

Returns a new instance of Database.

Parameters:

  • name (String) (defaults to: DEFAULT_DB) —

    the database name.

  • connection (EM::Mongo::Connection) (defaults to: nil) —

    a connection object pointing to MongoDB. Note that databases are usually instantiated via the Connection class. See the examples below.



19
20
21
22
23
24
25
 
# File 'lib/em-mongo/database.rb', line 19

def initialize(name = DEFAULT_DB, connection = nil)
  @db_name = name
  @em_connection = connection || EM::Mongo::Connection.new
  @collection = nil
  @collections = {}
  @cache_time = 300 #5 minutes.
end

Instance Attribute Details

#cache_time ⇒ Object

The length of time that Collection.ensure_index should cache index calls



12
13
14
 
# File 'lib/em-mongo/database.rb', line 12

def cache_time
  @cache_time
end

Instance Method Details

#add_user(username, password) ⇒ EM::Mongo::RequestResponse

Adds a user to this database for use with authentication. If the user already exists in the system, the password will be updated.

Parameters:

Returns:



375
376
377
378
379
380
381
382
383
384
385
 
# File 'lib/em-mongo/database.rb', line 375

def add_user(username, password)
  response = RequestResponse.new
  user_resp = self.collection(SYSTEM_USER_COLLECTION).first({:user => username})
  user_resp.callback do |res|
    user = res || {:user => username}
    user['pwd'] = EM::Mongo::Support.hash_password(username, password)
    response.succeed self.collection(SYSTEM_USER_COLLECTION).save(user)
  end
  user_resp.errback { |err| response.fail err }
  response
end

#authenticate(username, password) ⇒ EM::Mongo::RequestResponse

Authenticate with the given username and password. Note that mongod must be started with the –auth option for authentication to be enabled.

Parameters:

Returns:

Raises:



340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
 
# File 'lib/em-mongo/database.rb', line 340

def authenticate(username, password)
  response = RequestResponse.new
  auth_resp = self.collection(SYSTEM_COMMAND_COLLECTION).first({'getnonce' => 1})
  auth_resp.callback do |res|
    if not res or not res['nonce']
      response.succeed false
    else
      auth                 = BSON::OrderedHash.new
      auth['authenticate'] = 1
      auth['user']         = username
      auth['nonce']        = res['nonce']
      auth['key']          = EM::Mongo::Support.auth_key(username, password, res['nonce'])

      auth_resp2 = self.collection(SYSTEM_COMMAND_COLLECTION).first(auth)
      auth_resp2.callback do |res|
        if EM::Mongo::Support.ok?(res)
          response.succeed true
        else
          response.fail res
        end
      end
      auth_resp2.errback { |err| response.fail err }
    end
  end
  auth_resp.errback { |err| response.fail err }
  response
end

#collection(name = EM::Mongo::DEFAULT_NS) ⇒ EM::Mongo::Collection

Get a collection by name.

Parameters:

  • name (String, Symbol) (defaults to: EM::Mongo::DEFAULT_NS) —

    the collection name.

Returns:



32
33
34
 
# File 'lib/em-mongo/database.rb', line 32

def collection(name = EM::Mongo::DEFAULT_NS)
  @collections[name] ||= EM::Mongo::Collection.new(@db_name, name, @em_connection)
end

#collection_names ⇒ EM::Mongo::RequestResponse

Get an array of collection names in this database.

Returns:



53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/em-mongo/database.rb', line 53

def collection_names
  response = RequestResponse.new
  name_resp = collections_info.defer_as_a
  name_resp.callback do |docs|
    names = docs.collect{ |doc| doc['name'] || '' }
    names = names.delete_if {|name| name.index(self.name).nil? || name.index('$')}
    names = names.map{ |name| name.sub(self.name + '.','')}
    response.succeed(names)
  end
  name_resp.errback { |err| response.fail err }
  response
end

#collections ⇒ EM::Mongo::RequestResponse

Get an array of Collection instances, one for each collection in this database.

Returns:



69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/em-mongo/database.rb', line 69

def collections
  response = RequestResponse.new
  name_resp = collection_names
  name_resp.callback do |names|
    collections = names.map do |name|
      EM::Mongo::Collection.new(@db_name, name, @em_connection)
    end
    response.succeed collections
  end
  name_resp.errback { |err| response.fail err }
  response
end

#collections_info(coll_name = nil) ⇒ EM::Mongo::Cursor

Get info on system namespaces (collections). This method returns a cursor which can be iterated over. For each collection, a hash will be yielded containing a ‘name’ string and, optionally, an ‘options’ hash.

Parameters:

  • coll_name (String) (defaults to: nil) —

    return info for the specifed collection only.

Returns:



89
90
91
92
93
 
# File 'lib/em-mongo/database.rb', line 89

def collections_info(coll_name=nil)
  selector = {}
  selector[:name] = full_collection_name(coll_name) if coll_name
  Cursor.new(EM::Mongo::Collection.new(@db_name, SYSTEM_NAMESPACE_COLLECTION, @em_connection), :selector => selector)
end

#command(selector, opts = {}) ⇒ EM::Mongo::RequestResponse

Send a command to the database.

Note: DB commands must start with the “command” key. For this reason, any selector containing more than one key must be an OrderedHash.

Note also that a command in MongoDB is just a kind of query that occurs on the system command collection ($cmd). Examine this method’s implementation to see how it works.

key, specifying the command to be performed. In Ruby 1.9, OrderedHash isn’t necessary since hashes are ordered by default.

command fails.

Parameters:

  • selector (OrderedHash, Hash) —

    an OrderedHash, or a standard Hash with just one

  • opts (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (opts):

  • :check_response (Boolean) — default: true —

    If true, raises an exception if the

  • :socket (Socket) —

    a socket to use for sending the command. This is mainly for internal use.

Returns:

Raises:



301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
 
# File 'lib/em-mongo/database.rb', line 301

def command(selector, opts={})
  check_response = opts.fetch(:check_response, true)
  raise MongoArgumentError, "command must be given a selector" unless selector.is_a?(Hash) && !selector.empty?

  if selector.keys.length > 1 && RUBY_VERSION < '1.9' && selector.class != BSON::OrderedHash
    raise MongoArgumentError, "DB#command requires an OrderedHash when hash contains multiple keys"
  end

  response = RequestResponse.new
  cmd_resp = Cursor.new(self.collection(SYSTEM_COMMAND_COLLECTION), :limit => -1, :selector => selector).next_document

  cmd_resp.callback do |doc|
    if doc.nil?
      response.fail([OperationFailure, "Database command '#{selector.keys.first}' failed: returned null."])
    elsif (check_response && !EM::Mongo::Support.ok?(doc))
      response.fail([OperationFailure, "Database command '#{selector.keys.first}' failed: #{doc.inspect}"])
    else
      response.succeed(doc)
    end
  end

  cmd_resp.errback do |err|
    response.fail([OperationFailure, "Database command '#{selector.keys.first}' failed: #{err[1]}"])
  end

  response
end

#connection ⇒ EM::Mongo::Connection

Get the connection associated with this database

Returns:



39
40
41
 
# File 'lib/em-mongo/database.rb', line 39

def connection
  @em_connection
end

#create_collection(name) ⇒ EM::Mongo::RequestResponse

Create a collection.

new collection. If strict is true, will raise an error if collection name already exists.

Parameters:

  • name (String, Symbol) —

    the name of the new collection.

  • opts (Hash) —

    a customizable set of options

Returns:

Raises:

  • (MongoDBError) —

    raised under two conditions: either we’re in strict mode and the collection already exists or collection creation fails on the server.



117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
 
# File 'lib/em-mongo/database.rb', line 117

def create_collection(name)
  response = RequestResponse.new
  names_resp = collection_names
  names_resp.callback do |names|
    if names.include?(name.to_s)
      response.succeed EM::Mongo::Collection.new(@db_name, name, @em_connection)
    end

    # Create a new collection.
    oh = BSON::OrderedHash.new
    oh[:create] = name
    cmd_resp = command(oh)
    cmd_resp.callback do |doc|
      if EM::Mongo::Support.ok?(doc)
        response.succeed EM::Mongo::Collection.new(@db_name, name, @em_connection)
      else
        response.fail [MongoDBError, "Error creating collection: #{doc.inspect}"]
      end
    end
    cmd_resp.errback { |err| response.fail err }
  end
  names_resp.errback { |err| response.fail err }
  response
end

#drop_collection(name) ⇒ EM::Mongo::RequestResponse

Drop a collection by name.

Parameters:

Returns:



147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
 
# File 'lib/em-mongo/database.rb', line 147

def drop_collection(name)
  response = RequestResponse.new
  names_resp = collection_names
  names_resp.callback do |names|
    if names.include?(name.to_s)
      cmd_resp = command(:drop=>name)
      cmd_resp.callback do |doc|
        response.succeed EM::Mongo::Support.ok?(doc)
      end
      cmd_resp.errback { |err| response.fail err }
    else
      response.succeed false
    end
  end
  names_resp.errback { |err| response.fail err }
  response
end

#drop_index(collection_name, index_name) ⇒ EM::Mongo::RequestResponse

Drop an index from a given collection. Normally called from Collection#drop_index or Collection#drop_indexes.

Parameters:

Returns:

Raises:

  • MongoDBError if there’s an error renaming the collection.



174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
 
# File 'lib/em-mongo/database.rb', line 174

def drop_index(collection_name, index_name)
  response = RequestResponse.new
  oh = BSON::OrderedHash.new
  oh[:deleteIndexes] = collection_name
  oh[:index] = index_name.to_s
  cmd_resp = command(oh, :check_response => false)
  cmd_resp.callback do |doc|
    if EM::Mongo::Support.ok?(doc)
      response.succeed(true)
    else
      response.fail [MongoDBError, "Error with drop_index command: #{doc.inspect}"]
    end
  end
  cmd_resp.errback do |err|
    response.fail err
  end
  response
end

#error? ⇒ EM::Mongo::RequestResponse

Return true if an error was caused by the most recently executed database operation.

Returns:



247
248
249
250
251
252
253
254
255
256
257
 
# File 'lib/em-mongo/database.rb', line 247

def error?
  response = RequestResponse.new
  err_resp = get_last_error
  err_resp.callback do |doc|
    response.succeed doc['err'] != nil
  end
  err_resp.errback do |err|
    response.fail err
  end
  response
end

#full_collection_name(collection_name) ⇒ String

A shortcut returning db plus dot plus collection name.

Parameters:

Returns:



275
276
277
 
# File 'lib/em-mongo/database.rb', line 275

def full_collection_name(collection_name)
  "#{name}.#{collection_name}"
end

#get_last_error(opts = {}) ⇒ EM::Mongo::RequestResponse

Run the getlasterror command with the specified replication options.

Parameters:

  • opts (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (opts):

  • :fsync (Boolean) — default: false
  • :w (Integer) — default: nil
  • :wtimeout (Integer) — default: nil

Returns:

Raises:



226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
 
# File 'lib/em-mongo/database.rb', line 226

def get_last_error(opts={})
  response = RequestResponse.new
  cmd = BSON::OrderedHash.new
  cmd[:getlasterror] = 1
  cmd.merge!(opts)
  cmd_resp = command(cmd, :check_response => false)
  cmd_resp.callback do |doc|
    if EM::Mongo::Support.ok?(doc)
      response.succeed doc
    else
      response.fail [MongoDBError, "error retrieving last error: #{doc.inspect}"]
    end
  end
  cmd_resp.errback { |err| response.fail err }
  response
end

#index_information(collection_name) ⇒ EM::Mongo::RequestResponse

Get information on the indexes for the given collection. Normally called by Collection#index_information.

Parameters:

Returns:

  • (EM::Mongo::RequestResponse) —

    Calls back with a hash where keys are index names and the values are lists of [key, direction] pairs defining the index.



200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
 
# File 'lib/em-mongo/database.rb', line 200

def index_information(collection_name)
  response = RequestResponse.new
  sel  = {:ns => full_collection_name(collection_name)}
  idx_resp = Cursor.new(self.collection(SYSTEM_INDEX_COLLECTION), :selector => sel).defer_as_a
  idx_resp.callback do |indexes|
    info = indexes.inject({}) do |info, index|
      info[index['name']] = index
      info
    end
    response.succeed info
  end
  idx_resp.errback do |err|
    fail err
  end
  response
end

#name ⇒ String

Get the name of this database

Returns:



46
47
48
 
# File 'lib/em-mongo/database.rb', line 46

def name
  @db_name
end

#reset_error_history ⇒ EM::Mongo::RequestResponse

Reset the error history of this database

Calls to DB#previous_error will only return errors that have occurred since the most recent call to this method.

Returns:



265
266
267
 
# File 'lib/em-mongo/database.rb', line 265

def reset_error_history
  command(:reseterror => 1)
end