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]
