def connect(self): auth_provider = PlainTextAuthProvider( username=self.username, password=self.password ) self.cluster = Cluster( ["node_0", "node_1"], auth_provider=auth_provider, # executor_threads=int(os.getenv('CASSANDRA_EXECUTOR_THREADS')), # protocol_version=int(os.getenv('CASSANDRA_PROTOCOL_VERSION')), ) self.session = self.cluster.connect() self.session.execute( """ CREATE KEYSPACE IF NOT EXISTS test_key_space WITH REPLICATION = { 'class' : 'SimpleStrategy', 'replication_factor': '3'} AND durable_writes = true; """ ) self.session.set_keyspace(self.key_space) register_connection(str(self.session), session=self.session) set_default_connection(str(self.session))
def db_set(keyspace): try: connection.set_default_connection(CONN_NM) except Exception as err: print('db set exception occured...') connection.unregister_connection(CONN_NM) connection.register_connection(CONN_NM, config.CASSANDRA_CONTACT_POINTS[config.DTP], default=True) connection.session.set_keyspace(keyspace) print('...fix db connection. return to process')
def connection_factory(): contact_point = os.environ['CASSANDRA_CONTACT_POINT'] cluster = Cluster([contact_point]) connection = cluster.connect(keyspace=os.environ['CASSANDRA_KEYSPACE']) register_connection(str(connection), session=connection) set_default_connection(str(connection)) return connection
def pool_initializer(): from nexustiles.nexustiles import NexusTileService global tile_service tile_service = NexusTileService() # TODO This is a hack to make sure each sub-process uses it's own connection to cassandra. data-access needs to be updated from cassandra.cqlengine import connection from multiprocessing import current_process connection.register_connection(current_process().name, [host.address for host in connection.get_session().hosts]) connection.set_default_connection(current_process().name)
def setup(keyspace): try: # if conn_name is exist connection.set_default_connection(config.CA_HOST) except Exception as err: logger.error('=====CQLEngineException=====', err) unregister_connection() register_connection() models.DEFAULT_KEYSPACE = keyspace_DTP(keyspace)
def connect(self): auth_provider = PlainTextAuthProvider(username='******', password='******') self.cluster = Cluster( ['node_0', 'node_1'], auth_provider=auth_provider, # executor_threads=int(os.getenv('CASSANDRA_EXECUTOR_THREADS')), # protocol_version=int(os.getenv('CASSANDRA_PROTOCOL_VERSION')), ) self.session = self.cluster.connect() register_connection(str(self.session), session=self.session) set_default_connection(str(self.session))
def test_continuous_paging_basic(self): """ Test to ensure that various continuous paging works with cqlengine for session @since DSE 2.4 @jira_ticket PYTHON-872 @expected_result various continous paging options should fetch all the results @test_category queries """ for connection_name in self.sane_connections: connection.set_default_connection(connection_name) row = TestMultiKeyModel.get(partition=0, cluster=0) self.assertEqual(row.partition, 0) self.assertEqual(row.cluster, 0) rows = TestMultiKeyModel.objects().allow_filtering() self.assertEqual(len(rows), 1000)
def connect(self): """ DB connection.""" auth_provider = PlainTextAuthProvider(username=os.getenv('CASSANDRA_USERNAME'), password=os.getenv('CASSANDRA_PASSWORD')) self.cluster = Cluster( [os.getenv('CASSANDRA_HOST')], load_balancing_policy=TokenAwarePolicy(DCAwareRoundRobinPolicy()), port=os.getenv('CASSANDRA_PORT'), auth_provider=auth_provider, executor_threads=2, protocol_version=4, ) self.session = self.cluster.connect() register_connection(str(self.session), session=self.session) set_default_connection(str(self.session))
async def setup_cassandra(app, loop): logger.warning('Initializing Database') cluster = Cluster(['cassandra_seed_node']) session = cluster.connect() session.execute( """CREATE KEYSPACE IF NOT EXISTS soda WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'} AND durable_writes = true;""" ) session.execute('USE soda') register_connection(str(session), session=session) set_default_connection(str(session)) sync_table(User, keyspaces=['soda']) sync_table(Record, keyspaces=['soda']) sync_table(Project, keyspaces=['soda']) aiosession(session) app.db = session return app
def __init__(self): cloud_config= { 'secure_connect_bundle': './private/secure-connect-CoursesDB.zip' } user = None password = None with open('./private/CassandraPassword.json') as f: data = json.load(f) user = data['user'] password = data['password'] auth_provider = PlainTextAuthProvider(user, password) cluster = Cluster(cloud=cloud_config, auth_provider=auth_provider) self.session = cluster.connect() self.session.execute("USE {}".format(_keyspace)) _session = self.session register_connection(str(_session), session=_session) set_default_connection(str(_session))
def test_fetch_size(self): """ Test to ensure that various continuous paging works with different fetch sizes for session @since DSE 2.4 @jira_ticket PYTHON-872 @expected_result various continous paging options should fetch all the results @test_category queries """ for connection_name in self.connections: conn = connection._connections[connection_name] initial_default = conn.session.default_fetch_size self.addCleanup(setattr, conn.session, "default_fetch_size", initial_default) connection.set_default_connection("ONEPAGE") for fetch_size in (2, 3, 7, 10, 99, 100, 101, 150): connection._connections[ "ONEPAGE"].session.default_fetch_size = fetch_size rows = TestMultiKeyModel.objects().allow_filtering() self.assertEqual(fetch_size, len(rows)) connection.set_default_connection("MANYPAGES") for fetch_size in (2, 3, 7, 10, 15): connection._connections[ "MANYPAGES"].session.default_fetch_size = fetch_size rows = TestMultiKeyModel.objects().allow_filtering() self.assertEqual(fetch_size * 10, len(rows)) for connection_name in self.sane_connections: connection.set_default_connection(connection_name) for fetch_size in (2, 3, 7, 10, 99, 100, 101, 150): connection._connections[ connection_name].session.default_fetch_size = fetch_size rows = TestMultiKeyModel.objects().allow_filtering() self.assertEqual(1000, len(rows))
def create_test_db(self, verbosity=1, autoclobber=False, **kwargs): """ Creates a test database, prompting the user for confirmation if the database already exists. Returns the name of the test database created. """ # Don't import django.core.management if it isn't needed. from django.core.management import call_command from django.conf import settings self.connection.connect() default_alias = get_default_cassandra_connection()[0] # If using django-nose, its runner has already set the db name # to test_*, so restore it here so that all the models for the # live keyspace can be found. self.connection.connection.keyspace = self.connection.settings_dict[ 'NAME'] test_database_name = self._get_test_db_name() # Set all models keyspace to the test keyspace self.set_models_keyspace(test_database_name) if verbosity >= 1: test_db_repr = '' if verbosity >= 2: test_db_repr = " ('%s')" % test_database_name print("Creating test database for alias '%s'%s..." % (self.connection.alias, test_db_repr)) options = self.connection.settings_dict.get('OPTIONS', {}) # temporarily enable schema metadata for sync_cassandra connection_options_copy = options.get('connection', {}).copy() if not connection_options_copy.get('schema_metadata_enabled', True): options['connection']['schema_metadata_enabled'] = True self.connection.reconnect() set_default_connection(default_alias) replication_opts = options.get('replication', {}) replication_factor = replication_opts.pop('replication_factor', 1) create_keyspace_simple( test_database_name, replication_factor, connections=[self.connection.alias], ) settings.DATABASES[self.connection.alias]["NAME"] = test_database_name self.connection.settings_dict["NAME"] = test_database_name self.connection.reconnect() set_default_connection(default_alias) # Report syncdb messages at one level lower than that requested. # This ensures we don't get flooded with messages during testing # (unless you really ask to be flooded) call_command( 'sync_cassandra', verbosity=max(verbosity - 1, 0), database=self.connection.alias, ) # restore the original connection options if not connection_options_copy.get('schema_metadata_enabled', True): print('Disabling metadata on %s' % self.connection.settings_dict['NAME']) options['connection'][ 'schema_metadata_enabled'] = connection_options_copy[ 'schema_metadata_enabled'] self.connection.reconnect() set_default_connection(default_alias) return test_database_name
def tearDownClass(cls): if not DSE_VERSION or DSE_VERSION < cls.required_dse_version: return cls.cluster_default.shutdown() connection.set_default_connection("default")
def create_test_db(self, verbosity=1, autoclobber=False, **kwargs): """ Creates a test database, prompting the user for confirmation if the database already exists. Returns the name of the test database created. """ # Don't import django.core.management if it isn't needed. from django.core.management import call_command from django.conf import settings self.connection.connect() default_alias = get_default_cassandra_connection()[0] # If using django-nose, its runner has already set the db name # to test_*, so restore it here so that all the models for the # live keyspace can be found. self.connection.connection.keyspace = \ self.connection.settings_dict['NAME'] test_database_name = self._get_test_db_name() # Set all models keyspace to the test keyspace self.set_models_keyspace(test_database_name) if verbosity >= 1: test_db_repr = '' if verbosity >= 2: test_db_repr = " ('%s')" % test_database_name print("Creating test database for alias '%s'%s..." % ( self.connection.alias, test_db_repr)) options = self.connection.settings_dict.get('OPTIONS', {}) # temporarily enable schema metadata for sync_cassandra connection_options_copy = options.get('connection', {}).copy() if not connection_options_copy.get('schema_metadata_enabled', True): options['connection']['schema_metadata_enabled'] = True self.connection.reconnect() set_default_connection(default_alias) replication_opts = options.get('replication', {}) replication_factor = replication_opts.pop('replication_factor', 1) create_keyspace_simple( test_database_name, replication_factor, connections=[self.connection.alias]) settings.DATABASES[self.connection.alias]["NAME"] = test_database_name self.connection.settings_dict["NAME"] = test_database_name self.connection.reconnect() set_default_connection(default_alias) # Report syncdb messages at one level lower than that requested. # This ensures we don't get flooded with messages during testing # (unless you really ask to be flooded) call_command( 'sync_cassandra', verbosity=max(verbosity - 1, 0), database=self.connection.alias ) # restore the original connection options if not connection_options_copy.get('schema_metadata_enabled', True): print('Disabling metadata on %s' % self.connection.settings_dict['NAME']) options['connection']['schema_metadata_enabled'] = \ connection_options_copy['schema_metadata_enabled'] self.connection.reconnect() set_default_connection(default_alias) return test_database_name
CREATE KEYSPACE IF NOT EXISTS %s WITH replication = { 'class': 'SimpleStrategy', 'replication_factor': '2' } """ % KEYSPACE) log.info("Setting keyspace...") session.set_keyspace(KEYSPACE) session.row_factory = dict_factory session.execute("USE {}".format(KEYSPACE)) return session _session = cassandra_session_factory() register_connection(str(_session), session=_session) set_default_connection(str(_session)) class AbstractRepository(abc.ABC): @abc.abstractmethod def to_dict(self, obj): raise NotImplementedError @abc.abstractmethod def to_list(self, l): raise NotImplementedError class BaseRepository(AbstractRepository): _model = None
import app.index.routes as index import app.sensors.routes as sensors import app.statistic.routes as statistic import app.token.routes as token import app.users.routes as users from config import Config # Setup app app = Flask(__name__) app.auth = auth app.config.from_object(Config) app.cassandra_auth_provider = PlainTextAuthProvider(username=app.config['CASSANDRA_USERNAME'], password=app.config['CASSANDRA_PASSWORD']) app.cluster = Cluster([app.config['CASSANDRA_CLUSTER_HOST']], auth_provider=app.cassandra_auth_provider) app.session = app.cluster.connect() app.session.set_keyspace('kaspa') connection.register_connection('clusterKaspa', session=app.session) connection.set_default_connection('clusterKaspa') models.DEFAULT_KEYSPACE = 'kaspa' app.register_blueprint(auth.mod) app.register_blueprint(index.mod) app.register_blueprint(sensors.mod) app.register_blueprint(statistic.mod) app.register_blueprint(token.mod) app.register_blueprint(users.mod)
def ready(self): session = Cluster(['127.0.0.1']).connect() # session.row_factory = dict_factory connection.register_connection(str(session), session=session) connection.set_default_connection(str(session)) settings.CONNECTION = [connection, session]