def tearDownClass(cls):
super(ManagementConnectionTests, cls).tearDownClass()
# reset the default connection
conn.unregister_connection('fake_cluster')
conn.unregister_connection('cluster')
setup_connection(DEFAULT_KEYSPACE)
def tearDownClass(cls):
super(ManagementConnectionTests, cls).tearDownClass()
# reset the default connection
conn.unregister_connection('fake_cluster')
conn.unregister_connection('cluster')
setup_connection(DEFAULT_KEYSPACE)
def create_tables(orgname):
connection.setup(CASSANDRA_HOSTS, orgname, protocol_version=3)
# session = get_session(orgname)
sync_table(Users)
sync_table(Data)
sync_table(Repos)
connection.unregister_connection('default')
def setUpClass(cls):
super(ManagementConnectionTests, cls).setUpClass()
conn.unregister_connection('default')
conn.register_connection('fake_cluster', ['127.0.0.100'],
lazy_connect=True,
retry_connect=True,
default=True)
conn.register_connection('cluster', [CASSANDRA_IP])
def setUpClass(cls):
conn.register_connection('cluster', ['127.0.0.1'])
test_queryset.TestModel.__queryset__ = ModelQuerySetNew
test_queryset.IndexedTestModel.__queryset__ = ModelQuerySetNew
test_queryset.IndexedCollectionsTestModel.__queryset__ = ModelQuerySetNew
test_queryset.TestMultiClusteringModel.__queryset__ = ModelQuerySetNew
super(BaseConnectionTestNoDefault, cls).setUpClass()
conn.unregister_connection('default')
def tearDownClass(cls):
super(BatchQueryConnectionTests, cls).tearDownClass()
# reset the default connection
conn.unregister_connection('fake_cluster')
conn.unregister_connection('cluster')
setup_connection(DEFAULT_KEYSPACE)
drop_keyspace('ks1')
def tearDownClass(cls):
super(BatchQueryConnectionTests, cls).tearDownClass()
# reset the default connection
conn.unregister_connection('fake_cluster')
conn.unregister_connection('cluster')
setup_connection(DEFAULT_KEYSPACE)
drop_keyspace('ks1')
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 setUpClass(cls):
conn.register_connection('cluster', [CASSANDRA_IP])
test_queryset.TestModel.__queryset__ = ModelQuerySetNew
test_queryset.IndexedTestModel.__queryset__ = ModelQuerySetNew
test_queryset.IndexedCollectionsTestModel.__queryset__ = ModelQuerySetNew
test_queryset.TestMultiClusteringModel.__queryset__ = ModelQuerySetNew
super(BaseConnectionTestNoDefault, cls).setUpClass()
conn.unregister_connection('default')
def setUpClass(cls):
super(UsingDescriptorTests, cls).setUpClass()
conn.unregister_connection('default')
conn.register_connection('fake_cluster', ['127.0.0.100'],
lazy_connect=True,
retry_connect=True,
default=True)
conn.register_connection('cluster', ['127.0.0.1'])
def setUpClass(cls):
super(ContextQueryConnectionTests, cls).setUpClass()
create_keyspace_simple('ks1', 1)
conn.unregister_connection('default')
conn.register_connection('fake_cluster', ['127.0.0.100'], lazy_connect=True, retry_connect=True, default=True)
conn.register_connection('cluster', ['127.0.0.1'])
with ContextQuery(TestModel, connection='cluster') as tm:
sync_table(tm)
def setUpClass(cls):
super(BatchQueryConnectionTests, cls).setUpClass()
create_keyspace_simple('ks1', 1)
sync_table(TestModel)
sync_table(AnotherTestModel)
conn.unregister_connection('default')
conn.register_connection('fake_cluster', ['127.0.0.100'], lazy_connect=True, retry_connect=True, default=True)
conn.register_connection('cluster', ['127.0.0.1'])
def tearDownClass(cls):
super(UsingDescriptorTests, cls).tearDownClass()
# reset the default connection
conn.unregister_connection('fake_cluster')
conn.unregister_connection('cluster')
setup_connection(DEFAULT_KEYSPACE)
for ks in cls.keyspaces:
drop_keyspace(ks)
def setUpClass(cls):
super(BatchQueryConnectionTests, cls).setUpClass()
create_keyspace_simple('ks1', 1)
sync_table(TestModel)
sync_table(AnotherTestModel)
conn.unregister_connection('default')
conn.register_connection('fake_cluster', ['127.0.0.100'], lazy_connect=True, retry_connect=True, default=True)
conn.register_connection('cluster', [CASSANDRA_IP])
def tearDownClass(cls):
super(UsingDescriptorTests, cls).tearDownClass()
# reset the default connection
conn.unregister_connection('fake_cluster')
conn.unregister_connection('cluster')
setup_connection(DEFAULT_KEYSPACE)
for ks in cls.keyspaces:
drop_keyspace(ks)
def setUpClass(cls):
super(ContextQueryConnectionTests, cls).setUpClass()
create_keyspace_simple('ks1', 1)
conn.unregister_connection('default')
conn.register_connection('fake_cluster', ['1.2.3.4'], lazy_connect=True, retry_connect=True, default=True)
conn.register_connection('cluster', [CASSANDRA_IP])
with ContextQuery(TestModel, connection='cluster') as tm:
sync_table(tm)
def setUpClass(cls):
connection.unregister_connection('default')
cls.keyspace1 = 'ctest1'
cls.keyspace2 = 'ctest2'
super(ConnectionTest, cls).setUpClass()
cls.setup_cluster = Cluster(protocol_version=PROTOCOL_VERSION)
cls.setup_session = cls.setup_cluster.connect()
ddl = "CREATE KEYSPACE {0} WITH replication = {{'class': 'SimpleStrategy', 'replication_factor': '{1}'}}".format(cls.keyspace1, 1)
execute_with_long_wait_retry(cls.setup_session, ddl)
ddl = "CREATE KEYSPACE {0} WITH replication = {{'class': 'SimpleStrategy', 'replication_factor': '{1}'}}".format(cls.keyspace2, 1)
execute_with_long_wait_retry(cls.setup_session, ddl)
def tearDownClass(cls):
super(ContextQueryConnectionTests, cls).tearDownClass()
with ContextQuery(TestModel, connection='cluster') as tm:
drop_table(tm)
drop_keyspace('ks1', connections=['cluster'])
# reset the default connection
conn.unregister_connection('fake_cluster')
conn.unregister_connection('cluster')
setup_connection(DEFAULT_KEYSPACE)
def drop_keyspace(cls, nodes=None, keyspace='results_database', auth_provider=None):
nodes = nodes if nodes else ['localhost']
connection_id = uuid.uuid4()
try:
register_connection(name=str(connection_id), session=Cluster(nodes, auth_provider=auth_provider).connect())
does_keyspace_exist = keyspace in get_cluster(str(connection_id)).metadata.keyspaces
if does_keyspace_exist:
drop_keyspace(keyspace, connections=[str(connection_id)])
finally:
unregister_connection(name=str(connection_id))
def setUpClass(cls):
connection.unregister_connection('default')
cls.keyspace1 = 'ctest1'
cls.keyspace2 = 'ctest2'
super(ConnectionTest, cls).setUpClass()
cls.setup_cluster = Cluster(protocol_version=PROTOCOL_VERSION)
cls.setup_session = cls.setup_cluster.connect()
ddl = "CREATE KEYSPACE {0} WITH replication = {{'class': 'SimpleStrategy', 'replication_factor': '{1}'}}".format(cls.keyspace1, 1)
execute_with_long_wait_retry(cls.setup_session, ddl)
ddl = "CREATE KEYSPACE {0} WITH replication = {{'class': 'SimpleStrategy', 'replication_factor': '{1}'}}".format(cls.keyspace2, 1)
execute_with_long_wait_retry(cls.setup_session, ddl)
def tearDownClass(cls):
super(ContextQueryConnectionTests, cls).tearDownClass()
with ContextQuery(TestModel, connection='cluster') as tm:
drop_table(tm)
drop_keyspace('ks1', connections=['cluster'])
# reset the default connection
conn.unregister_connection('fake_cluster')
conn.unregister_connection('cluster')
setup_connection(DEFAULT_KEYSPACE)
def create_orgspace():
session = get_session()
# TODO: Replication strategy should be updated to 3
query = SimpleStatement(
"CREATE KEYSPACE IF NOT EXISTS %s WITH REPLICATION = {'class': 'NetworkTopologyStrategy', 'DC1': 1};"
% ("org", ))
session.execute(query)
session.shutdown()
connection.setup(CASSANDRA_HOSTS, "org", protocol_version=3)
# session = get_session(orgname)
sync_table(org)
connection.unregister_connection('default')
return
def cqlengine_management(cassandra):
"""Setup session for cqlengine
"""
# create test keyspace
os.environ['CQLENG_ALLOW_SCHEMA_MANAGEMENT'] = 'true'
test_keyspace = 'test_async_cqlengine'
cqlengine_connection.register_connection(
'cqlengine', session=cassandra, default=True)
management.create_keyspace_simple(test_keyspace, replication_factor=1)
# setup cqlengine session
cassandra.set_keyspace(test_keyspace)
cqlengine_connection.set_session(cassandra)
yield management
management.drop_keyspace(test_keyspace)
cqlengine_connection.unregister_connection('cqlengine')
def __init__(self, nodes=None, keyspace='results_database', auth_provider=None, create_keyspace=False, replication_map=None):
self.keyspace = keyspace
self._depth = 0
self._connection_id = uuid.uuid4()
self._models = {}
self._nodes = nodes if nodes else ['localhost']
self._auth_provider = auth_provider
self._batch = []
try:
register_connection(name=str(self._connection_id), session=Cluster(self._nodes, auth_provider=self._auth_provider).connect())
does_keyspace_exist = self.keyspace in get_cluster(str(self._connection_id)).metadata.keyspaces
if create_keyspace and not does_keyspace_exist:
if not self.can_modify_schema():
raise Exception('Cannot create keyspace, Schema modification is disabled')
if replication_map is None:
create_keyspace_simple(self.keyspace, replication_factor=1, connections=[str(self._connection_id)])
else:
create_keyspace_network_topology(self.keyspace, dc_replication_map=replication_map, connections=[str(self._connection_id)])
elif not does_keyspace_exist:
raise Exception(f'Keyspace {self.keyspace} does not exist and will not be created')
finally:
unregister_connection(name=str(self._connection_id))
def insert_users():
connection.setup(CASSANDRA_HOSTS, "hehe1")
# session = get_session("hehe1")
# connection.get_session(session)
manu = Users.create(name="manu")
connection.unregister_connection('default')
def tearDownClass(cls):
conn.unregister_connection('cluster')
setup_connection(DEFAULT_KEYSPACE)
super(BaseConnectionTestNoDefault, cls).tearDownClass()
def another_insert_users():
connection.setup(CASSANDRA_HOSTS, "hehe1")
d = {"name": "manya"}
manu = Users.create(**d)
connection.unregister_connection('default')
def unregister_connection():
logger.debug('Connecting unregistration start ***')
connection.unregister_connection(config.CA_HOST)
logger.debug('*** Unregisted successfully')
def create(session):
x = '{"name":"Hehe17", "addr": [{ "contributions": 1, "html_url": "https://github.com/dmalan", "contrib_id": "788678", "name": "dmalan"}]}'
# rows = session.execute('INSERT INTO users2 JSON\'{"name":"Haha", "addr": [{"street":"Easy St.", "zipcode":"99999"},
# {"street":"Difficult St.", "zipcode":"99999"}]}\'')
query = SimpleStatement("INSERT INTO users2 JSON \'" + str(x) + "\';")
session.execute(query)
session.shutdown()
connection.setup(CASSANDRA_HOSTS, "org1", protocol_version=3)
#sync_table(users2)
#sync_table(users3)
x='{"name":"Hehe7", "addr": [{ "contributions": 1, "html_url": "https://github.com/dmalan", "contrib_id": "788678", "name": "dmalan"}]}'
d = json.loads(x)
c = Contrib(**(d["addr"][0]))
users2.create(**(json.loads(x)))
connection.unregister_connection('default')
#cluster = Cluster()
#session = cluster.connect('org1')
#rows = session.execute('INSERT INTO users2 JSON\'{"name":"Haha", "addr": [{"street":"Easy St.", "zipcode":"99999"},
# {"street":"Difficult St.", "zipcode":"99999"}]}\'')
#query = SimpleStatement("INSERT INTO users2 JSON \'"+str(x)+"\';")
#session.execute(query)
#session.shutdown()
#rows = session.execute('INSERT INTO users2 JSON %s;'% (x,))
def __exit__(self, *args, **kwargs):
self._depth -= 1
if self._depth <= 0:
unregister_connection(name=str(self._connection_id))
def teardown_package():
connection.unregister_connection("default")
def unregister_connection():
logger.debug('Connecting unregistration start ***')
eval_setting_MY_NETWORK()
connection.unregister_connection(setting.MY_NETWORK)
logger.debug('*** Unregisted successfully')
def unregister_cassandra_connection():
connection.unregister_connection('default_cas')
def setUpClass(cls):
super(ManagementConnectionTests, cls).setUpClass()
conn.unregister_connection('default')
conn.register_connection('fake_cluster', ['127.0.0.100'], lazy_connect=True, retry_connect=True, default=True)
conn.register_connection('cluster', ['127.0.0.1'])
def stop(self):
try:
unregister_connection(self.connection_name)
except Exception as e:
self.cluster.shutdown()
self.connection = None
def tearDown(self):
connection.unregister_connection("default")
def tearDownClass(cls):
conn.unregister_connection('cluster')
setup_connection(DEFAULT_KEYSPACE)
super(BaseConnectionTestNoDefault, cls).tearDownClass()
def teardown_package():
connection.unregister_connection("default")
def tearDown(self):
connection.unregister_connection("default")
def setUpClass(cls):
super(UsingDescriptorTests, cls).setUpClass()
conn.unregister_connection('default')
conn.register_connection('fake_cluster', ['127.0.0.100'], lazy_connect=True, retry_connect=True, default=True)
conn.register_connection('cluster', [CASSANDRA_IP])
