class MongoDBConnection:
_instance = None
def __init__(self):
self.connection = Connection(DBNAME, tz_aware=True)
self.admin_db = Database(self.connection, "admin")
self.admin_db.authenticate(USERNAME, PASSWD)
@classmethod
def instance(cls):
if cls._instance == None:
MongoDBConnection._instance = MongoDBConnection()
return MongoDBConnection._instance
def reauthenticate(self):
self.admin_db = Database(self.connection, "admin")
self.admin_db.authenticate(USERNAME, PASSWD)
def reconnect(self):
self.connection = Connection(DBNAME)
self.reauthenticate()
def get_connection(self):
return self.connection
class MongoDB(object):
__instance = None
__db_connection = None
# def __new__(cls, *args, **kwargs):
# if MongoDB.__instance is None:
# MongoDB.__instance = object.__new__(cls, *args, **kwargs)
# return MongoDB.__instance
def __init__(self, **kwargs):
if 'host' not in kwargs or not kwargs['host']:
self.host = MONGODB_HOST
else:
self.host = kwargs['host']
if 'port' not in kwargs or not kwargs['port']:
self.port = MONGODB_PORT
else:
self.port = kwargs['port']
if 'db' not in kwargs or not kwargs['db']:
self.db = MONGODB_DBNAME
else:
self.db = kwargs['db']
# if 'rs' not in kwargs or not kwargs['rs']:
# self.rs = settings.MONGODB_RS
# else:
# self.rs = kwargs['rs']
#
if 'user' not in kwargs or not kwargs['user']:
self.user = MONGODB_USER
else:
self.user = kwargs['user']
#
if 'pwd' not in kwargs or not kwargs['pwd']:
self.pwd = MONGODB_PWD
else:
self.pwd = kwargs['pwd']
def get_database(self):
if self.__db_connection is None:
from pymongo.read_preferences import ReadPreference
# self.__db_connection = Database(Connection(self.host, self.port), self.db)
self.__db_connection = Database(
Connection(self.host, self.port), self.db
) #replicaSet='', read_preference=ReadPreference.SECONDARY_PREFERRED), self.db)
self.__db_connection.authenticate(self.user, self.pwd)
return self.__db_connection
def get_db(is_local_deployed=False):
if is_local_deployed:
#for local launch
connection = Connection()
db = connection.wiki
return db
else:
# for dotcloud launch
mongodb_info = json.load(file("/home/dotcloud/environment.json"))
print mongodb_info
connection = Connection(mongodb_info["DOTCLOUD_DATA_MONGODB_HOST"], int(mongodb_info["DOTCLOUD_DATA_MONGODB_PORT"]))
database = Database(connection, "wiki")
database.authenticate("xinz", "hellopy")
db = connection.wiki
return db
def connect(conf, prod):
log.info('setting up mongo connection')
url = conf.get('mongo', 'url')
port = conf.getint('mongo', 'port')
db = conf.get('mongo', 'db')
conn = Connection(url, port)
db = Database(conn, db)
if (prod):
log.info('authenticating mongo connection')
username = conf.get('mongo', 'username')
pwd = conf.get('mongo', 'password')
db.authenticate(username, pwd)
return db
def init_connection(self):
if hasattr(self, 'app'):
config = self.app.config
else:
config = self._default_config
connection = Connection(
host=config.get('MONGODB_HOST'),
port=config.get('MONGODB_PORT'),
slave_okay=config.get('MONGODB_SLAVE_OKAY')
)
database = Database(connection, config.get('MONGODB_DATABASE'))
if config.get('MONGODB_USERNAME') is not None:
database.authenticate(
config.get('MONGODB_USERNAME'),
config.get('MONGODB_PASSWORD')
)
return connection, database
# -*- encoding: utf-8 -*- ''' Created on 2014-11-7 @author: [email protected] ''' import pymongo from pymongo.database import Database from pymongo.mongo_client import MongoClient from pymongo.collection import Collection from gridfs import GridFS if __name__ == '__main__': con = pymongo.Connection('172.16.10.170', 27017) # con = MongoClient(host='172.16.10.170', port=27017, max_pool_size=200) db = Database(con, 'blog') db.authenticate('admin', 'admin') coll = Collection(db, 'foo') coll.insert({'a':1, 'b':2, 'c':3}) # coll.update({'a':1}, {'$set':{'b':4}}, multi=True) print [x for x in coll.find()] # MongoClient() # print user.find({'id':1}).count() pass
username = sys.argv[1]
password = sys.argv[2]
url = sys.argv[3]
file_list = sys.argv[4:]
print username
print password
print len(file_list)
if (len(url) == 0):
connection = Connection() # Connect to localhost
else:
connection = Connection(url) # Connect to remote db
db = Database(connection, 'zip') # Get zip database
db.authenticate(username, password) # Authenticate
for csv_file in file_list: # Add all the files
add(csv_file)
########NEW FILE########
__FILENAME__ = remove
import sys
import os
import csv
from pymongo import Connection
from pymongo.database import Database
appendix_file = '../appendix/country.txt'
header_file = '../appendix/headers.txt'
record[ headers[ii] ] = unicode( row[ii], 'utf-8' )
erase(record)
pass
def erase( record ):
db['global'].remove(record)
if __name__ == "__main__" :
if ( len(sys.argv) != 4 ):
print "Usage: %s <username> <password> <csv-files>" % sys.argv[0]
username = sys.argv[1]
password = sys.argv[2]
csv_file = sys.argv[3]
print username
print password
print csv_file
connection = Connection() # Replace with mongo-url
db = Database(connection,'zip') # Get zip database
db.authenticate(username,password) # Authenticate
remove( csv_file )
class Mongoop(object):
def __init__(self, mongodb_host, mongodb_port, mongodb_credentials=None,
mongodb_options=None, frequency=0, op_triggers=None,
balancer_triggers=None, threshold_timeout=None, query=None):
try:
# mongodb
self._mongodb_host = mongodb_host
self._mongodb_port = mongodb_port
self._mongodb_credentials = mongodb_credentials or {}
self._mongodb_options = mongodb_options or {}
# mongoop triggers
self._frequency = frequency or 30
self.op_triggers = op_triggers or {}
self.balancer_triggers = balancer_triggers or {}
self._threshold_timeout = threshold_timeout or 60
self._query = query or {}
# NOTE: retrieve the minimum threshold.
if self.op_triggers:
self._threshold_timeout = min([v['threshold'] for v in self.op_triggers.values() if 'threshold' in v])
self._base_op_query = {
'secs_running': {'$gte': self._threshold_timeout},
'op': {'$ne': 'none'}
}
self._base_op_query.update(self._query)
self.conn = MongoClient(
host=self._mongodb_host,
port=self._mongodb_port,
read_preference=ReadPreference.PRIMARY,
**self._mongodb_options
)
self.db = Database(self.conn, 'admin')
if self._mongodb_credentials:
# NOTE: avoid a breaking chance since the version 0.5
username = self._mongodb_credentials.get('name') or self._mongodb_credentials.get('username')
self.db.authenticate(username, self._mongodb_credentials['password'])
# NOTE: add the callable for each trigger
self.cycle_op_triggers = []
self.cycle_balancer_triggers = []
for t_name, t_values in self.op_triggers.items():
_callable = self._get_trigger_callable(t_name, t_values)
if _callable:
self.cycle_op_triggers.append(_callable)
for t_name, t_values in self.balancer_triggers.items():
_callable = self._get_trigger_callable(t_name, t_values, category='balancer')
if _callable:
self.cycle_balancer_triggers.append(_callable)
except TypeError as e:
logging.error('unable to authenticate to admin database :: {}'.format(e))
exit(1)
except OperationFailure as e:
logging.error('authentication failure :: {}'.format(e))
except ConnectionFailure as e:
logging.error('unable to connect to database :: {}'.format(e))
else:
logging.info('start mongoop :: {}'.format(self))
def __str__(self):
return u'{} :: frequency={} :: slow_query={} :: op_triggers={} :: balancer_triggers={}'.format(
self.conn, self._frequency, self._base_op_query, len(self.cycle_op_triggers),
len(self.cycle_balancer_triggers))
def __call__(self):
""" Main function.
"""
while True:
start = time()
self.call_op_triggers()
self.call_balancer_triggers()
exec_time = time() - start
if exec_time < self._frequency:
sleep(self._frequency - exec_time)
def call_op_triggers(self):
""" Main function to run the op triggers.
"""
operations = self._current_op()
for trigger in self.cycle_op_triggers:
trigger.run(operations=operations)
def call_balancer_triggers(self):
""" Main function to run the balancer triggers.
"""
if not self.balancer_triggers:
return True
balancer_state = self._get_balancer_state()
for trigger in self.cycle_balancer_triggers:
trigger.run(balancer_state=balancer_state)
def _get_trigger_callable(self, trigger_name, trigger_params, category='op'):
""" Retrieve the corresponding trigger by name and add into the triggers list.
Args:
"""
try:
trigger_module = import_module('mongoop.triggers.{}'.format(trigger_params['type']))
trigger_class = getattr(trigger_module, 'MongoopTrigger')
trigger = trigger_class(name=trigger_name, params=trigger_params,
mongoop=self, category=category)
except Exception as e:
logging.error('unable to retrieve the trigger callable :: {}'.format(e))
else:
return trigger
def _current_op(self):
""" Get informations on operations currently running.
"""
try:
op_inprog = {}
coll = self.db.get_collection("$cmd.sys.inprog")
result = coll.find_one(self._base_op_query)
op_inprog = result.get('inprog', {})
except Exception as e:
logging.error('unable to retrieve op :: {}'.format(e))
else:
if op_inprog:
logging.info('found {} slow op'.format(len(op_inprog)))
logging.debug('found {} slow op'.format(len(op_inprog)))
finally:
return op_inprog
def _get_balancer_state(self):
""" Return the balancer state.
Returns:
bool: True it's running, False otherwhise.
"""
try:
if self.conn.config.settings.find_one({'_id': 'balancer', 'stopped': True}):
logging.info('balancer state :: stopped')
return False
logging.info('balancer state :: started')
return True
except Exception as e:
logging.error('unable to get the balancer state :: {}'.format(e))
from pymongo.mongo_client import MongoClient
from pymongo.collection import Collection, ObjectId
from pymongo.database import Database
try:
tasks_collection_name = 'tasks'
defect_collection_name = 'defect'
hsegap_collection_name = 'HSE_gaps_pbe_structure'
db_info = {
"aliases": {},
"database": "results_GY",
"host": "marilyn.pcpm.ucl.ac.be",
"port": 27017,
"admin_user": "******",
"admin_password": "******",
"readonly_user": "******",
"readonly_password": "******"
}
clt = MongoClient(host=db_info['host'], port=db_info['port'])
db = Database(clt, db_info['database'])
db.authenticate(db_info['admin_user'], db_info['admin_password'])
except:
print 'Can not connect database'
Created by AFD on 2010-10-14.
Copyright (c) 2010 A. Frederick Dudley. All rights reserved.
"""
from stores.mongo_store import *
from stores.store import *
from pymongo.connection import Connection
from pymongo.database import Database
from binary_tactics.player import Player
from binary_tactics.helpers import *
from binary_tactics.weapons import *
from binary_tactics.units import *
from binary_tactics.stone import *
connection = Connection(host='bt.hipeland.org')
db = Database(connection, 'binary_tactics')
db.authenticate('rix', 'fhpxguvf'.decode('rot13'))
exists = {'$exists': True}
#squads = db.binary_tactics.find({'squad': exists})
#grids = db.binary_tactics.find({'grid': exists})
#squad = [convert_dict(get_dict(db.binary_tactics.find({'squad.value': 1004})[0], db.binary_tactics, db))]
squad = [rand_squad()]
units = [n for n in squad[0]]
weapons = [n.weapon for n in squad[0]]
stones = [rand_comp() for n in xrange(6)]
w = Player('The World', squad, stones, units, weapons, [])
class DatabaseConnection(object):
"""Establishes a connection to the mongodb."""
def __init__(self, database=None, host='localhost', port=27017):
"""
Can be initialized without parameters.
:param database: Str name of database.
:param host: Host.
:param port: Port.
"""
self.timeout = 1
self.host = str(host)
if not isinstance(port, int):
raise ValueError(
'Entered port is "{}"! Must be integer type'.format(port))
self.port = port
self.client = MongoClient(host=self.host,
port=self.port,
serverSelectionTimeoutMS=self.timeout)
try:
if database is not None:
if database in self.client.database_names():
self.database = Database(self.client, database)
if self.database.command("serverStatus")['ok'] == 1.0:
print('connecting to: mongodb://{}:{}'.format(
self.host, self.port))
print('database - "{}"'.format(self.database.name))
else:
pass
else:
raise ValueError
else:
self.database = database
except ServerSelectionTimeoutError as err:
sys.exit('Error! {}'.format(err))
except ValueError:
print('"{}" is not in database names! Please check the name of '
'database!'.format(database))
def use_db(self, database=None):
"""
Switches between databases.
:param database: Str name of database.
"""
try:
if database in self.client.database_names():
self.database = Database(self.client, database)
print('switched to db {}'.format(self.database.name))
else:
raise ValueError
except ServerSelectionTimeoutError as err:
sys.exit('Error! {}'.format(err))
except ValueError:
print('"{}" is not in database names! Please check the name of '
'database!'.format(database))
def authenticate(self, user=None, password=None):
"""
Authenticates the user in the connected database.
:param user: The name of the user.
:param password: The password.
"""
if user is not None and password is not None:
try:
if user in [
user['user'] for user in (
self.database.command('usersInfo'))['users']
]:
try:
if self.database.authenticate(user, password):
self.auth = self.database.authenticate(
user, password)
print('1')
else:
raise OperationFailure
except OperationFailure:
print('Error: Authentication failed.')
print('0')
else:
print('"{}" user is not in "{}" database users!'.format(
user, self.database.name))
except AttributeError:
print('At first you must connect to the database with use '
'method!')
else:
print('Please check entered user and password!')
class Mongoop(object):
def __init__(self,
mongodb_host,
mongodb_port,
mongodb_credentials=None,
mongodb_options=None,
frequency=0,
op_triggers=None,
balancer_triggers=None,
threshold_timeout=None,
query=None):
try:
# mongodb
self._mongodb_host = mongodb_host
self._mongodb_port = mongodb_port
self._mongodb_credentials = mongodb_credentials or {}
self._mongodb_options = mongodb_options or {}
# mongoop triggers
self._frequency = frequency or 30
self.op_triggers = op_triggers or {}
self.balancer_triggers = balancer_triggers or {}
self._threshold_timeout = threshold_timeout or 60
self._query = query or {}
# NOTE: retrieve the minimum threshold.
if self.op_triggers:
self._threshold_timeout = min([
v['threshold'] for v in self.op_triggers.values()
if 'threshold' in v
])
self._base_op_query = {
'secs_running': {
'$gte': self._threshold_timeout
},
'op': {
'$ne': 'none'
}
}
self._base_op_query.update(self._query)
self.conn = MongoClient(host=self._mongodb_host,
port=self._mongodb_port,
read_preference=ReadPreference.PRIMARY,
**self._mongodb_options)
self.db = Database(self.conn, 'admin')
if self._mongodb_credentials:
# NOTE: avoid a breaking chance since the version 0.5
username = self._mongodb_credentials.get(
'name') or self._mongodb_credentials.get('username')
self.db.authenticate(username,
self._mongodb_credentials['password'])
# NOTE: add the callable for each trigger
self.cycle_op_triggers = []
self.cycle_balancer_triggers = []
for t_name, t_values in self.op_triggers.items():
_callable = self._get_trigger_callable(t_name, t_values)
if _callable:
self.cycle_op_triggers.append(_callable)
for t_name, t_values in self.balancer_triggers.items():
_callable = self._get_trigger_callable(t_name,
t_values,
category='balancer')
if _callable:
self.cycle_balancer_triggers.append(_callable)
except TypeError as e:
logging.error(
'unable to authenticate to admin database :: {}'.format(e))
exit(1)
except OperationFailure as e:
logging.error('authentication failure :: {}'.format(e))
except ConnectionFailure as e:
logging.error('unable to connect to database :: {}'.format(e))
else:
logging.info('start mongoop :: {}'.format(self))
def __str__(self):
return u'{} :: frequency={} :: slow_query={} :: op_triggers={} :: balancer_triggers={}'.format(
self.conn, self._frequency, self._base_op_query,
len(self.cycle_op_triggers), len(self.cycle_balancer_triggers))
def __call__(self):
""" Main function.
"""
while True:
start = time()
self.call_op_triggers()
self.call_balancer_triggers()
exec_time = time() - start
if exec_time < self._frequency:
sleep(self._frequency - exec_time)
def call_op_triggers(self):
""" Main function to run the op triggers.
"""
operations = self._current_op()
for trigger in self.cycle_op_triggers:
trigger.run(operations=operations)
def call_balancer_triggers(self):
""" Main function to run the balancer triggers.
"""
if not self.balancer_triggers:
return True
balancer_state = self._get_balancer_state()
for trigger in self.cycle_balancer_triggers:
trigger.run(balancer_state=balancer_state)
def _get_trigger_callable(self,
trigger_name,
trigger_params,
category='op'):
""" Retrieve the corresponding trigger by name and add into the triggers list.
Args:
"""
try:
trigger_module = import_module('mongoop.triggers.{}'.format(
trigger_params['type']))
trigger_class = getattr(trigger_module, 'MongoopTrigger')
trigger = trigger_class(name=trigger_name,
params=trigger_params,
mongoop=self,
category=category)
except Exception as e:
logging.error(
'unable to retrieve the trigger callable :: {}'.format(e))
else:
return trigger
def _current_op(self):
""" Get informations on operations currently running.
"""
try:
op_inprog = {}
coll = self.db.get_collection("$cmd.sys.inprog")
result = coll.find_one(self._base_op_query)
op_inprog = result.get('inprog', {})
except Exception as e:
logging.error('unable to retrieve op :: {}'.format(e))
else:
if op_inprog:
logging.info('found {} slow op'.format(len(op_inprog)))
logging.debug('found {} slow op'.format(len(op_inprog)))
finally:
return op_inprog
def _get_balancer_state(self):
""" Return the balancer state.
Returns:
bool: True it's running, False otherwhise.
"""
try:
if self.conn.config.settings.find_one({
'_id': 'balancer',
'stopped': True
}):
logging.info('balancer state :: stopped')
return False
logging.info('balancer state :: started')
return True
except Exception as e:
logging.error('unable to get the balancer state :: {}'.format(e))
Created by AFD on 2010-10-14.
Copyright (c) 2010 A. Frederick Dudley. All rights reserved.
"""
from stores.mongo_store import *
from stores.store import *
from pymongo.connection import Connection
from pymongo.database import Database
from binary_tactics.player import Player
from binary_tactics.helpers import *
from binary_tactics.weapons import *
from binary_tactics.units import *
from binary_tactics.stone import *
connection = Connection(host='bt.hipeland.org')
db = Database(connection, 'binary_tactics')
db.authenticate('rix', 'fhpxguvf'.decode('rot13'))
exists = {'$exists': True}
#squads = db.binary_tactics.find({'squad': exists})
#grids = db.binary_tactics.find({'grid': exists})
#squad = [convert_dict(get_dict(db.binary_tactics.find({'squad.value': 1004})[0], db.binary_tactics, db))]
squad = [rand_squad()]
units = [n for n in squad[0]]
weapons = [n.weapon for n in squad[0]]
stones = [rand_comp() for n in xrange(6)]
w = Player('The World', squad, stones, units, weapons, [])
