def get_backend(self, engine): """ Load DATABASES[engine]['ENGINE'] directly because oracle can end up with oraclepool as the engine and your testing oraclepool speed against itself! """ if engine == 'oracle': try: return load_backend('django.db.backends.oracle') except: # django 1.2 return load_backend('oracle') else: return load_backend('oraclepool')
def db_type(self, connection): try: for backend, db_type in self.CREATION_DATA.items(): try: module = load_backend(backend) DatabaseWrapper = getattr(module, 'DatabaseWrapper') if isinstance(connection, DatabaseWrapper): return db_type elif DJANGO_VERSION >= (1, 7): from django.db import ( DefaultConnectionProxy, connections, ) from django.db.utils import DEFAULT_DB_ALIAS if (isinstance(connection, DefaultConnectionProxy) and isinstance(connections[DEFAULT_DB_ALIAS], DatabaseWrapper)): return db_type except (ImportError, exceptions.ImproperlyConfigured): pass except (KeyError, AttributeError): pass raise exceptions.ImproperlyConfigured( 'BigAutoField does not support the "%s" database ' 'backend' % connection.settings_dict["ENGINE"])
def getConnection(banco): engine = settings.SECONDARY_DB[banco]['DATABASE_ENGINE'] if engine == "sql_server.pyodbc": return base.DatabaseWrapper(settings.SECONDARY_DB[banco]) else: bckend = load_backend(engine) return bckend.DatabaseWrapper(settings.SECONDARY_DB[banco])
def setUp(self): if not __django_12__: # Ugly but necessary from django.db import load_backend backend = load_backend('django_mongokit.mongodb') def get(key): return getattr(settings, key, None) self.connection = backend.DatabaseWrapper({ 'DATABASE_HOST': get('MONGO_DATABASE_HOST'), 'DATABASE_NAME': settings.MONGO_DATABASE_NAME, 'DATABASE_OPTIONS': get('MONGO_DATABASE_OPTIONS'), 'DATABASE_PASSWORD': get('MONGO_DATABASE_PASSWORD'), 'DATABASE_PORT': get('MONGO_DATABASE_PORT'), 'DATABASE_USER': get('MONGO_DATABASE_USER'), 'TIME_ZONE': settings.TIME_ZONE, }) self.old_database_name = settings.MONGO_DATABASE_NAME self.connection.creation.create_test_db() db = get_database() assert 'test_' in db.name, db.name
def take_snapshot(ec2_conn, vol_id, freeze_dir, lock_db=True, fs='xfs'): """ Take a snapshot of the given volume, handling the freezing and unfreezing of the file system and locking and unlocking the db (useful for non-transactional databases like MyISAM mysql). """ if fs != 'xfs': raise NotImplementedError("Support for snapshots across file systems other than xfs not currently supported") if lock_db: try: from django.db import load_backend backend = load_backend(settings.DATABASE_ENGINE) connection = backend.DatabaseWrapper({ 'DATABASE_HOST': settings.DATABASE_HOST, 'DATABASE_NAME': settings.DATABASE_NAME, 'DATABASE_OPTIONS': settings.DATABASE_OPTIONS, 'DATABASE_PASSWORD': DATABASE_BACKUP_PASSWORD, 'DATABASE_PORT': settings.DATABASE_PORT, 'DATABASE_USER': DATABASE_BACKUP_USER, 'TIME_ZONE': settings.TIME_ZONE, }) except ImportError: # Pre Django 1.1 backend = __import__('django.db.backends.' + settings.DATABASE_ENGINE + ".base", {}, {}, ['base']) backup = {} # Save the 'real' db settings so we can restore them prev_user = settings.DATABASE_USER prev_pw = settings.DATABASE_PASSWORD settings.DATABASE_USER = DATABASE_BACKUP_USER settings.DATABASE_PASSWORD = DATABASE_BACKUP_PASSWORD connection = backend.DatabaseWrapper() connection._cursor(settings) # Restore the db settings settings.DATABASE_USER = prev_user settings.DATABASE_PASSWORD = prev_pw try: if lock_db: cursor = connection.cursor() cursor.execute('FLUSH TABLES WITH READ LOCK;') # Freeze the xfs file system call([XFS_FREEZE_CMD, '-f', freeze_dir]) snapshot = ec2_conn.create_snapshot(vol_id) finally: # Unfreeze the xfs file system even if our snapshot threw an error call([XFS_FREEZE_CMD, '-u', freeze_dir]) logging.info("Created snapshot with id: %s" % snapshot.id) return snapshot.id
def setUp(self): if not __django_12__: # Ugly but necessary from django.db import load_backend backend = load_backend('django_mongokit.mongodb') self.connection = backend.DatabaseWrapper({ 'DATABASE_HOST': getattr(settings, 'MONGO_DATABASE_HOST', None), 'DATABASE_NAME': settings.MONGO_DATABASE_NAME, 'DATABASE_OPTIONS': getattr(settings, 'MONGO_DATABASE_OPTIONS', None), 'DATABASE_PASSWORD': getattr(settings, 'MONGO_DATABASE_PASSWORD', None), 'DATABASE_PORT': getattr(settings, 'MONGO_DATABASE_PORT', None), 'DATABASE_USER': getattr(settings, 'MONGO_DATABASE_USER', None), 'TIME_ZONE': settings.TIME_ZONE, }) self.old_database_name = settings.MONGO_DATABASE_NAME self.connection.creation.create_test_db() db = get_database() assert 'test_' in db.name, db.name
def handle(self, *args, **options): backend = db.load_backend('mysql') conn = backend.DatabaseWrapper({'NAME': 'playlistpnow', 'USER': '******', 'PASSWORD': '******', 'HOST': 'localhost', 'PORT': '3306', 'OPTIONS': ''}) old = conn.cursor() self.old_root_ids = (175319, 57488) signals.pre_save.disconnect(yourplaylist_bookmarked) signals.m2m_changed.disconnect(update_counts) signals.post_save.disconnect(new_follower, sender=Follow) signals.post_save.disconnect(new_follow, sender=Follow) signals.post_save.disconnect(playlist_create_activity, sender=Playlist) signals.m2m_changed.disconnect(last_playlist, sender=Playlist.tracks.through) signals.pre_save.disconnect(get_info_if_no_image) signals.m2m_changed.disconnect(update_fans) #self.sync_users_accounts(old) #self.sync_followers(old) #self.sync_friends(old) #self.sync_categories(old) #self.sync_tracks(old) self.sync_playlists(old)
def init_pool(): if not globals().get('pool_initialized', False): global pool_initialized pool_initialized = True try: backendname = settings.DATABASES['default']['ENGINE'] backend = load_backend(backendname) #replace the database object with a proxy. backend.Database = pool.manage(backend.Database, poolclass=pool.QueuePool, echo=settings.DEBUG, recycle=settings.DBPOOL_WAIT_TIMEOUT, pool_size=settings.DBPOOL_SIZE, max_overflow=settings.DBPOOL_MAX, timeout=settings.DBPOOL_INTERNAL_CONN_TIMEOUT) backend.DatabaseError = backend.Database.DatabaseError backend.IntegrityError = backend.Database.IntegrityError logging.info("Connection Pool initialized") except: logging.exception("Connection Pool initialization error")
def _pre_setup(self): """Munge DB infrastructure before the superclass gets a chance to set up the DBs.""" # clear all module state pindb._init_state() # patch up the db system to use the effective router settings (see override_settings) # we can't just reconstruct objects here because # lots of places do from foo import baz, so they have # a local reference to an object we can't replace. # so reach in and (gulp) mash the object's state. if dj_VERSION < (1, 4): for conn in dj_db.connections._connections.values(): conn.close() dj_db.connections._connections = {} else: for conn in dj_db.connections.all(): conn.close() dj_db.connections._connections = local() dj_db.connections.databases = settings.DATABASES def make_router(import_path): module_path, class_name = import_path.rsplit('.', 1) mod = importlib.import_module(module_path) return getattr(mod, class_name)() dj_db.router.routers = [ make_router(import_path) for import_path in settings.DATABASE_ROUTERS] dj_db.connection = dj_db.connections[dj_db.DEFAULT_DB_ALIAS] dj_db.backend = dj_db.load_backend(dj_db.connection.settings_dict['ENGINE']) self.shim_runner = DjangoTestSuiteRunner() self.setup_databases() super(PinDbTestCase, self)._pre_setup()
if __django_12__: try: connection = connections['mongodb'].connection except ConnectionDoesNotExist: # Need to raise a better error print connections.databases raise else: # because this is Django <1.2 doesn't load all the engines so we have to # do it manually. # Since with Django <1.2 we have to first define a normal backend engine # like sqlite so then the base backend for mongodb is never called from django.db import load_backend backend = load_backend('django_mongokit.mongodb') connection = backend.DatabaseWrapper({ 'DATABASE_HOST': getattr(settings, 'MONGO_DATABASE_HOST', None), 'DATABASE_NAME': settings.MONGO_DATABASE_NAME, 'DATABASE_OPTIONS': getattr(settings, 'MONGO_DATABASE_OPTIONS', None), 'DATABASE_PASSWORD': getattr(settings, 'MONGO_DATABASE_PASSWORD', None), 'DATABASE_PORT': getattr(settings, 'MONGO_DATABASE_PORT', None), 'DATABASE_USER': getattr(settings, 'MONGO_DATABASE_USER', None), 'TIME_ZONE': settings.TIME_ZONE, }) connection = connection.connection # The reason this is a function rather than an instance is that you're supposed # to get the database object every time by calling this function. If you define
__django_12__ = False if __django_12__: try: connection = connections['mongodb'].connection except ConnectionDoesNotExist: # Need to raise a better error print connections.databases raise else: # because this is Django <1.2 doesn't load all the engines so we have to # do it manually. # Since with Django <1.2 we have to first define a normal backend engine # like sqlite so then the base backend for mongodb is never called from django.db import load_backend backend = load_backend('django_mongokit.mongodb') connection = backend.DatabaseWrapper({ 'DATABASE_HOST': getattr(settings, 'MONGO_DATABASE_HOST', None), 'DATABASE_NAME': settings.MONGO_DATABASE_NAME, 'DATABASE_OPTIONS': getattr(settings, 'MONGO_DATABASE_OPTIONS', None), 'DATABASE_PASSWORD': getattr(settings, 'MONGO_DATABASE_PASSWORD', None), 'DATABASE_PORT': getattr(settings, 'MONGO_DATABASE_PORT', None), 'DATABASE_USER': getattr(settings, 'MONGO_DATABASE_USER', None), 'TIME_ZONE': settings.TIME_ZONE,