How to use the mongodb.Db function in mongodb

// TODO: report errors somewhere?
    if (err) { return ; }
    _db = db;
    arbiter.emit("db_open", db);
  }

  if (db_url) {
    var options = {
      uri_decode_auth: true,
      server: server_options,
      db: db_options
    };
    mongodb.connect(db_url, options, onOpened);
  } else {
    var mongoserver = new mongodb.Server(host, port, server_options);
    var db_connector = new mongodb.Db(db_name, mongoserver, db_options);
    db_connector.open(onOpened);
  }

  return {
    get: function() {
      var cb;
      var args = _.toArray(arguments);
      var last = args.pop();

      if (_.isFunction(last)) {
        cb = last;
      } else {
        args.push(last);
      }

      var db_name = args.join(separator);

if (options.servers && Array.isArray(options.servers)){
      var servers = [];

      options.servers.forEach(function(item){
        if(item.host && item.port) {
          servers.push(new mongo.Server(item.host, item.port, item.options));
        }
      });

      server = new mongo.ReplSetServers(servers);
    } else {
      server = new mongo.Server(options.host, options.port, options.options);
    }

    this.db = new mongo.Db(options.dbName, server, { safe: true });
    this.db.on('close', function() {
      self.emit('disconnect');
    });

    this.db.open(function (err, client) {
      if (err) {
        if (callback) callback(err);
      } else {
        var finish = function (err) {
          self.client = client;
          self.queue = new mongo.Collection(client, options.collectionName);
          // self.queue.ensureIndex({ 'id': 1 }, function() {});
          if (!err) {
            self.emit('connect');
          }
          if (callback) callback(err, self);

//var host1 = 'db1.storm.jaystack.com';
var host1 = 'localhost';
var host2 = 'db2.storm.jaystack.com';
var port = Connection.DEFAULT_PORT;
var server1 = new Server(host1, port, {});
var server2 = new Server(host2, port, {});
var servers = new Array();
//servers[0] = server2;
//servers[1] = server1;
servers[0] = server1;

// username, password mongohoz
var replStat = new ReplSetServers(servers);
//var usersdb = new Db(config.application.id + '-Users', replStat, {native_parser:false});
//var usersdb = new Db('Users', replStat, {native_parser:false});
var usersdb = new Db('ApplicationDB', new Server(host1, port, {}), {native_parser:false});
usersdb.open(function(err, db) {
  console.log('users database opened');
});

function mongoAuthenticate(username, password) {
    var defer = q.defer();
    usersdb.collection('Users', function(err, collection) {
      if (err) defer.reject(err);
      collection.find({Login:username}, function(err, cursor) {
        cursor.toArray(function(err, users) {
          if (err) defer.reject(err);
          if (users.length == 0) defer.reject('No such user');
          else if (users.length > 1) defer.reject('Duplicate user');
          else bcrypt.compare(password, users[0].Password, function(err, ok) {
            if (err) defer.reject(err);
            if (!ok) defer.reject('Invalid password');

NativeConnection.prototype.doOpenSet = function (fn) {
  if (!this.db) {
    var servers = []
      , ports = this.port
      , self = this

    this.host.forEach(function (host, i) {
      servers.push(new mongo.Server(host, Number(ports[i]), self.options.server));
    });

    var server = new ReplSetServers(servers, this.options.replset);
    this.db = new mongo.Db(this.name, server, this.options.db);

    this.db.on('fullsetup', function () {
      self.emit('fullsetup')
    });
  }

  this.db.open(function (err) {
    if (err) return fn(err);
    fn();
    listen(self);
  });

  return this;
};

function setupConnection(config, cb) {
  if (typeof config !== 'object') { throw new TypeError('config must be an object'); }
  if (typeof cb !== 'function') { throw new TypeError('cb must be a function'); }

  var cfg = {};
  cfg = config;
  cfg.db   = program.db || program.args[0] || config.db || 'admin';
  cfg.user = program.user || config.user || '';
  cfg.pass = config.pass || '';
  cfg.host = program.host || config.host || '127.0.0.1';
  cfg.port = program.port || config.port || 27017;

  var db = new mongodb.Db(cfg.db, new mongodb.Server(cfg.host, cfg.port), { w: 1 });

  db.open(function(err) {
    if (err) { return cb(err); }

    if (config.user || config.pass) {
      var authDb = db.db(config.authDb || config.db);
      authDb.authenticate(config.user, config.pass, function(err) {
        cb(err, db);
      });
    } else {
      cb(null, db);
    }
  });
}

var DirtyStorage = function(cProjectName,cBranchName){
    "use strict";
    var cObjects,
        MONGO = require('mongodb'),
        DB = new MONGO.Db(cProjectName, new MONGO.Server(commonUtil.MongoDBLocation, commonUtil.MongoDBPort, {},{}));

    /*public functions*/
    this.get = function(id,cb){
        if(cObjects){
            cObjects.findOne({"_id":id},function(err,result){
                if(err){
                    cb(err);
                }
                else{
                    cb(null,result.object);
                }
            });
        }
        else{
            cb(1);
        }

var mongodb = require('mongodb');
var fs = require('fs');
var breezeMongo = require('breeze-mongodb');

//var MongoQuery = breezeMongo.MongoQuery;
//var MongoSaveHandler = breezeMongo.MongoSaveHandler;

var host = 'localhost';
var port = 27017;
var dbName = 'NorthwindIB';
var dbServer = new mongodb.Server(host, port, { auto_reconnect: true});
var db = new mongodb.Db(dbName, dbServer, { strict:true, w: 1});
db.open(function () {

});

exports.getMetadata = function(req, res, next) {
    var filename = "metadata.json";
    if (!fs.existsSync(filename)) {
        next(new Error("Unable to locate file: " + filename));
    }
    var metadata = fs.readFileSync(filename, 'utf8');
    res.sendfile(filename);
}

exports.get = function (req, res, next) {

    var slug = req.params.slug;

/*
 * 数据库连接配置模块 
 */

var settings = require('../settings'),
    Db = require('mongodb').Db,
    Connection = require('mongodb').Connection,
    Server = require('mongodb').Server;
    
module.exports = new Db(settings.db, new Server(settings.host, Connection.DEFAULT_PORT, {}), {safe: true});

function getConnection(databasename, collectionname, operation, callback) {

    var database = databases[databasename];
    var options = {
        slave_ok: true
    };

    var db = new mongodb.Db(database.name, new mongodb.Server(database.address, database.port, options));
    db.open(function (error, connection) {

        var cnn = {
			connection: connection, 
			db: db,
			databasename: databasename
		};

        if(error) {
            trace("connection failed to " + databasename + ": "+ error);
            getConnection(databasename, collectionname, operation, callback);
            killConnection(cnn, error);
            return;
        }

        if(!database.username && !database.password) {

function getCollectionList(namedb, config){

        var db = new mongo.Db(namedb, new mongo.Server(config.db.host, config.db.port, {'auto_reconnect':true}));
        db.open(function(err, db){
        
            db.authenticate(config.db.username, config.db.password, function callback(){
 
                db.collectionNames(function(err,replies) {
 
                    out=0;
                    replies.forEach(function(document) {
                        if (document.name.indexOf("\.indexes") == -1) {  
                            writeBack(namedb + '/'  + document.name.replace(".","/"));
                        }
                        if(out === (replies.length-1)){
                            setPres();
                        }
                        out++;
                        writeEnd();