def get_mongo_objs(host, port, dbname, username=None, passwd=None): """ :return: Database connection, database instance and collection instance. """ connection = Connection(host=host, port=port, read_preference=ReadPreference.NEAREST) connection.register([BenchmarkResult]) benchresult = getattr(connection, dbname).benchresults.BenchmarkResult db = Database(connection, dbname) if username is not None: db.authenticate(username, password=passwd) return connection, db, benchresult
class MongoKit(object): """This class is used to integrate `MongoKit`_ into a Flask application. :param app: The Flask application will be bound to this MongoKit instance. If an app is not provided at initialization time than it must be provided later by calling :meth:`init_app` manually. .. _MongoKit: http://namlook.github.com/mongokit/ """ def __init__(self, app=None, database=None): #: :class:`list` of :class:`mongokit.Document` #: which will be automated registed at connection self.registered_documents = [] self.mongokit_connection = None self.database = database if app is not None: self.app = app self.init_app(self.app) else: self.app = None def init_app(self, app): """Also it registers the :class:`flask.ext.mongokit.BSONObjectIdConverter` as a converter with the key word **ObjectId**. :param app: The Flask application will be bound to this MongoKit instance. """ app.config.setdefault('MONGODB_HOST', '127.0.0.1') app.config.setdefault('MONGODB_PORT', 27017) app.config.setdefault('MONGODB_DATABASE', 'flask') app.config.setdefault('MONGODB_SLAVE_OKAY', False) app.config.setdefault('MONGODB_USERNAME', None) app.config.setdefault('MONGODB_PASSWORD', None) app.config.setdefault('MONGODB_MAX_POOL_SIZE', 10) # register extension with app app.extensions = getattr(app, 'extensions', {}) app.extensions['mongokit'] = self app.url_map.converters['ObjectId'] = BSONObjectIdConverter self.app = app def register(self, documents): """Register one or more :class:`mongokit.Document` instances to the connection. Can be also used as a decorator on documents: .. code-block:: python db = MongoKit(app) @db.register class Task(Document): structure = { 'title': unicode, 'text': unicode, 'creation': datetime, } :param documents: A :class:`list` of :class:`mongokit.Document`. """ #enable decorator usage as in mongokit.Connection decorator = None if not isinstance(documents, (list, tuple, set, frozenset)): # we assume that the user used this as a decorator # using @register syntax or using db.register(SomeDoc) # we stock the class object in order to return it later decorator = documents documents = [documents] for document in documents: if document not in self.registered_documents: self.registered_documents.append(document) if decorator is None: return self.registered_documents else: return decorator def connect(self): """Connect to the MongoDB server and register the documents from :attr:`registered_documents`. If you set ``MONGODB_USERNAME`` and ``MONGODB_PASSWORD`` then you will be authenticated at the ``MONGODB_DATABASE``. """ self.mongokit_connection = Connection( host=self.app.config.get('MONGODB_HOST'), port=self.app.config.get('MONGODB_PORT'), max_pool_size=self.app.config.get('MONGODB_MAX_POOL_SIZE'), slave_okay=self.app.config.get('MONGODB_SLAVE_OKAY') ) self.mongokit_connection.register(self.registered_documents) if self.database: self.mongokit_db = Database(self.mongokit_connection, self.database) else: self.mongokit_db = Database(self.mongokit_connection, self.app.config.get('MONGODB_DATABASE')) if self.app.config.get('MONGODB_USERNAME') is not None: self.mongokit_db.authenticate( self.app.config.get('MONGODB_USERNAME'), self.app.config.get('MONGODB_PASSWORD') ) @property def connected(self): """Connection status to your MongoDB.""" return self.mongokit_connection is not None def disconnect(self): """Close the connection to your MongoDB.""" if self.connected: self.mongokit_connection.disconnect() self.mongokit_connection = None del self.mongokit_db def __getattr__(self, name, **kwargs): if not self.connected: self.connect() return getattr(self.mongokit_db, name)
def word_validator(value): word = re.compile(r'^[-A-Za-z0-9_]+(?: +[-A-Za-z0-9_]+)*$') return bool(word.match(value)) class Word(Document): structure = { 'word': basestring, 'content': basestring, 'related': basestring, 'word_info': { 'word_class': basestring, 'phonetic': unicode, 'definition': [{ 'explain': basestring, 'example': [basestring], }], }, } required = ['word'] validators = { 'word': word_validator, } conn = Connection(host=settings.HOST, port=int(settings.PORT)) conn.register([Word]) db = Database(conn, 't') db.authenticate('admin', 'fk5es-3PTd8c')
class MongoKit(object): """This class is used to integrate `MongoKit`_ into a Flask application. :param app: The Flask application will be bound to this MongoKit instance. If an app is not provided at initialization time than it must be provided later by calling :meth:`init_app` manually. .. _MongoKit: http://namlook.github.com/mongokit/ """ def __init__(self, app=None): #: :class:`list` of :class:`mongokit.Document` #: which will be automated registed at connection self.registered_documents = [] if app is not None: self.app = app self.init_app(self.app) else: self.app = None def init_app(self, app): """This method connect your ``app`` with this extension. Flask- MongoKit will now take care about to open and close the connection to your MongoDB. Also it registers the :class:`flask.ext.mongokit.BSONObjectIdConverter` as a converter with the key word **ObjectId**. :param app: The Flask application will be bound to this MongoKit instance. """ app.config.setdefault('MONGODB_HOST', '127.0.0.1') app.config.setdefault('MONGODB_PORT', 27017) app.config.setdefault('MONGODB_DATABASE', 'flask') app.config.setdefault('MONGODB_USERNAME', None) app.config.setdefault('MONGODB_PASSWORD', None) app.config.setdefault('MONGODB_URL', 'mongodb://127.0.0.1:27071/') app.config.setdefault('MONGODB_CONNECTION_OPTIONS', { 'auto_start_request': False }) app.before_first_request(self._before_first_request) # 0.9 and later # no coverage check because there is everytime only one if hasattr(app, 'teardown_appcontext'): # pragma: no cover app.teardown_appcontext(self._teardown_request) # 0.7 to 0.8 elif hasattr(app, 'teardown_request'): # pragma: no cover app.teardown_request(self._teardown_request) # Older Flask versions else: # pragma: no cover app.after_request(self._teardown_request) # register extension with app only to say "I'm here" app.extensions = getattr(app, 'extensions', {}) app.extensions['mongokit'] = self app.url_map.converters['ObjectId'] = BSONObjectIdConverter self.app = app self.mongokit_connection = Connection( host=app.config.get('MONGODB_HOST'), port=app.config.get('MONGODB_PORT'), **app.config.get('MONGODB_CONNECTION_OPTIONS', {}) ) self.mongokit_database = Database(self.mongokit_connection, app.config.get('MONGODB_DATABASE')) if app.config.get('MONGODB_USERNAME') is not None: auth_success = self.mongokit_database.authenticate( app.config.get('MONGODB_USERNAME'), app.config.get('MONGODB_PASSWORD') ) if not auth_success: raise AuthenticationIncorrect('Server authentication failed') @property def connected(self): """Connection status to your MongoDB.""" ctx = ctx_stack.top return getattr(ctx, 'mongokit_connection', None) is not None def _before_first_request(self): self.mongokit_connection.start_request() def _teardown_request(self, response): self.mongokit_connection.end_request() return response def __getattr__(self, name, **kwargs): return getattr(self._get_mongo_database(), name) def __getitem__(self, name): return self._get_mongo_database()[name] def _get_mongo_database(self): return self.mongokit_database