def test_default_serial_consistency_level(self, *_):
"""
Make sure default_serial_consistency_level passes through to a query message.
Also make sure Statement.serial_consistency_level overrides the default.
PR #510
"""
s = Session(Cluster(protocol_version=4), [Host("127.0.0.1", SimpleConvictionPolicy)])
# default is None
self.assertIsNone(s.default_serial_consistency_level)
# Should fail
with self.assertRaises(ValueError):
s.default_serial_consistency_level = ConsistencyLevel.ANY
with self.assertRaises(ValueError):
s.default_serial_consistency_level = 1001
for cl in (None, ConsistencyLevel.LOCAL_SERIAL, ConsistencyLevel.SERIAL):
s.default_serial_consistency_level = cl
# default is passed through
f = s.execute_async(query='')
self.assertEqual(f.message.serial_consistency_level, cl)
# any non-None statement setting takes precedence
for cl_override in (ConsistencyLevel.LOCAL_SERIAL, ConsistencyLevel.SERIAL):
f = s.execute_async(SimpleStatement(query_string='', serial_consistency_level=cl_override))
self.assertEqual(s.default_serial_consistency_level, cl)
self.assertEqual(f.message.serial_consistency_level, cl_override)
def test_default_serial_consistency_level_ep(self, *_):
"""
Make sure default_serial_consistency_level passes through to a query message using execution profiles.
Also make sure Statement.serial_consistency_level overrides the default.
PR #510
"""
c = Cluster(protocol_version=4)
s = Session(c, [Host("127.0.0.1", SimpleConvictionPolicy)])
# default is None
default_profile = c.profile_manager.default
self.assertIsNone(default_profile.serial_consistency_level)
for cl in (None, ConsistencyLevel.LOCAL_SERIAL,
ConsistencyLevel.SERIAL):
s.get_execution_profile(
EXEC_PROFILE_DEFAULT).serial_consistency_level = cl
# default is passed through
f = s.execute_async(query='')
self.assertEqual(f.message.serial_consistency_level, cl)
# any non-None statement setting takes precedence
for cl_override in (ConsistencyLevel.LOCAL_SERIAL,
ConsistencyLevel.SERIAL):
f = s.execute_async(
SimpleStatement(query_string='',
serial_consistency_level=cl_override))
self.assertEqual(default_profile.serial_consistency_level, cl)
self.assertEqual(f.message.serial_consistency_level,
cl_override)
def test_statement_params_override_profile(self):
non_default_profile = ExecutionProfile(RoundRobinPolicy(),
*[object() for _ in range(3)])
cluster = Cluster(
execution_profiles={'non-default': non_default_profile})
session = Session(cluster,
hosts=[Host("127.0.0.1", SimpleConvictionPolicy)])
self.assertEqual(cluster._config_mode, _ConfigMode.PROFILES)
rf = session.execute_async("query", execution_profile='non-default')
ss = SimpleStatement("query",
retry_policy=DowngradingConsistencyRetryPolicy(),
consistency_level=ConsistencyLevel.ALL,
serial_consistency_level=ConsistencyLevel.SERIAL)
my_timeout = 1.1234
self.assertNotEqual(ss.retry_policy.__class__,
rf._load_balancer.__class__)
self.assertNotEqual(ss.consistency_level, rf.message.consistency_level)
self.assertNotEqual(ss._serial_consistency_level,
rf.message.serial_consistency_level)
self.assertNotEqual(my_timeout, rf.timeout)
rf = session.execute_async(ss,
timeout=my_timeout,
execution_profile='non-default')
expected_profile = ExecutionProfile(
non_default_profile.load_balancing_policy, ss.retry_policy,
ss.consistency_level, ss._serial_consistency_level, my_timeout,
non_default_profile.row_factory)
self._verify_response_future_profile(rf, expected_profile)
def test_profile_name_value(self):
internalized_profile = ExecutionProfile(RoundRobinPolicy(), *[object() for _ in range(2)])
cluster = Cluster(execution_profiles={'by-name': internalized_profile})
session = Session(cluster, hosts=[Host("127.0.0.1", SimpleConvictionPolicy)])
self.assertEqual(cluster._config_mode, _ConfigMode.PROFILES)
rf = session.execute_async("query", execution_profile='by-name')
self._verify_response_future_profile(rf, internalized_profile)
by_value = ExecutionProfile(RoundRobinPolicy(), *[object() for _ in range(2)])
rf = session.execute_async("query", execution_profile=by_value)
self._verify_response_future_profile(rf, by_value)
def test_default_profile(self):
non_default_profile = ExecutionProfile(RoundRobinPolicy(), *[object() for _ in range(3)])
cluster = Cluster(execution_profiles={'non-default': non_default_profile})
session = Session(cluster, hosts=[Host("127.0.0.1", SimpleConvictionPolicy)])
self.assertEqual(cluster._config_mode, _ConfigMode.PROFILES)
default_profile = cluster.profile_manager.profiles[EXEC_PROFILE_DEFAULT]
rf = session.execute_async("query")
self._verify_response_future_profile(rf, default_profile)
rf = session.execute_async("query", execution_profile='non-default')
self._verify_response_future_profile(rf, non_default_profile)
def test_default_profile(self):
non_default_profile = ExecutionProfile(RoundRobinPolicy(), *[object() for _ in range(3)])
cluster = Cluster(execution_profiles={'non-default': non_default_profile})
session = Session(cluster, hosts=[Host("127.0.0.1", SimpleConvictionPolicy)])
self.assertEqual(cluster._config_mode, _ConfigMode.PROFILES)
default_profile = cluster.profile_manager.profiles[EXEC_PROFILE_DEFAULT]
rf = session.execute_async("query")
self._verify_response_future_profile(rf, default_profile)
rf = session.execute_async("query", execution_profile='non-default')
self._verify_response_future_profile(rf, non_default_profile)
def test_statement_params_override_legacy(self):
cluster = Cluster(
load_balancing_policy=RoundRobinPolicy(),
default_retry_policy=DowngradingConsistencyRetryPolicy())
self.assertEqual(cluster._config_mode, _ConfigMode.LEGACY)
session = Session(cluster,
hosts=[Host("127.0.0.1", SimpleConvictionPolicy)])
ss = SimpleStatement("query",
retry_policy=DowngradingConsistencyRetryPolicy(),
consistency_level=ConsistencyLevel.ALL,
serial_consistency_level=ConsistencyLevel.SERIAL)
my_timeout = 1.1234
self.assertNotEqual(ss.retry_policy.__class__,
cluster.default_retry_policy)
self.assertNotEqual(ss.consistency_level,
session.default_consistency_level)
self.assertNotEqual(ss._serial_consistency_level,
session.default_serial_consistency_level)
self.assertNotEqual(my_timeout, session.default_timeout)
rf = session.execute_async(ss, timeout=my_timeout)
expected_profile = ExecutionProfile(
load_balancing_policy=cluster.load_balancing_policy,
retry_policy=ss.retry_policy,
request_timeout=my_timeout,
consistency_level=ss.consistency_level,
serial_consistency_level=ss._serial_consistency_level)
self._verify_response_future_profile(rf, expected_profile)
def save(self, session: Session, prep_insert_statement: PreparedStatement, data):
if data is None:
raise ValueError("Cannot save None data to Cassandra.")
def success_insert(results, pulse_id, channel_name):
if (pulse_id, channel_name) in self.future_cache:
self.future_cache.remove((pulse_id, channel_name))
else:
_logger.warning("WTF MAN, success but no key?")
_logger.debug("Inserted pulse_id=%s for channel_name=%s", pulse_id, channel_name)
def failed_insert(e, pulse_id, channel_name):
if (pulse_id, channel_name) in self.future_cache:
self.future_cache.remove((pulse_id, channel_name))
else:
_logger.warning("WTF MAN, fail but no key?")
_logger.error("ERRRO IN %s. %s", channel_name, e)
for pulse_data in data:
pulse_id = pulse_data[2]
channel_name = pulse_data[0]
future = session.execute_async(prep_insert_statement, pulse_data)
future.add_callbacks(callback=success_insert, callback_args=(pulse_id, channel_name),
errback=failed_insert, errback_args=(pulse_id, channel_name))
self.future_cache.add((pulse_id, channel_name))
return len(self.future_cache)
def async_data_insert(session: Session, keyspace: str, table: str,
measurement: Measurement) -> ResponseFuture:
prepared_statement = session.prepare(
f"INSERT INTO {keyspace}.{table} (name, timestamp, value) VALUES (?, ?, ?)"
)
# parse date into datetime instance with timezone info
timestamp = dateutil.parser.isoparse(measurement.timestamp)
return session.execute_async(
prepared_statement, (measurement.name, timestamp, measurement.value))
def test_default_profile(self):
non_default_profile = ExecutionProfile(RoundRobinPolicy(), *[object() for _ in range(2)])
cluster = Cluster(execution_profiles={'non-default': non_default_profile})
session = Session(cluster, hosts=[Host("127.0.0.1", SimpleConvictionPolicy)])
self.assertEqual(cluster._config_mode, _ConfigMode.PROFILES)
default_profile = session.get_execution_profile(EXEC_PROFILE_DEFAULT)
rf = session.execute_async("query")
self._verify_response_future_profile(rf, default_profile)
rf = session.execute_async("query", execution_profile='non-default')
self._verify_response_future_profile(rf, non_default_profile)
for name, ep in six.iteritems(cluster.profile_manager.profiles):
self.assertEqual(ep, session.get_execution_profile(name))
# invalid ep
with self.assertRaises(ValueError):
session.get_execution_profile('non-existent')
def test_default_legacy(self):
cluster = Cluster(load_balancing_policy=RoundRobinPolicy(), default_retry_policy=DowngradingConsistencyRetryPolicy())
self.assertEqual(cluster._config_mode, _ConfigMode.LEGACY)
session = Session(cluster, hosts=[Host("127.0.0.1", SimpleConvictionPolicy)])
session.default_timeout = 3.7
session.default_consistency_level = ConsistencyLevel.ALL
session.default_serial_consistency_level = ConsistencyLevel.SERIAL
rf = session.execute_async("query")
expected_profile = ExecutionProfile(cluster.load_balancing_policy, cluster.default_retry_policy,
session.default_consistency_level, session.default_serial_consistency_level,
session.default_timeout, session.row_factory)
self._verify_response_future_profile(rf, expected_profile)
def test_statement_params_override_profile(self):
non_default_profile = ExecutionProfile(RoundRobinPolicy(), *[object() for _ in range(2)])
cluster = Cluster(execution_profiles={'non-default': non_default_profile})
session = Session(cluster, hosts=[Host("127.0.0.1", SimpleConvictionPolicy)])
self.assertEqual(cluster._config_mode, _ConfigMode.PROFILES)
rf = session.execute_async("query", execution_profile='non-default')
ss = SimpleStatement("query", retry_policy=DowngradingConsistencyRetryPolicy(),
consistency_level=ConsistencyLevel.ALL, serial_consistency_level=ConsistencyLevel.SERIAL)
my_timeout = 1.1234
self.assertNotEqual(ss.retry_policy.__class__, rf._load_balancer.__class__)
self.assertNotEqual(ss.consistency_level, rf.message.consistency_level)
self.assertNotEqual(ss._serial_consistency_level, rf.message.serial_consistency_level)
self.assertNotEqual(my_timeout, rf.timeout)
rf = session.execute_async(ss, timeout=my_timeout, execution_profile='non-default')
expected_profile = ExecutionProfile(non_default_profile.load_balancing_policy, ss.retry_policy,
ss.consistency_level, ss._serial_consistency_level, my_timeout, non_default_profile.row_factory)
self._verify_response_future_profile(rf, expected_profile)
def test_statement_params_override_legacy(self):
cluster = Cluster(load_balancing_policy=RoundRobinPolicy(), default_retry_policy=DowngradingConsistencyRetryPolicy())
self.assertEqual(cluster._config_mode, _ConfigMode.LEGACY)
session = Session(cluster, hosts=[Host("127.0.0.1", SimpleConvictionPolicy)])
ss = SimpleStatement("query", retry_policy=DowngradingConsistencyRetryPolicy(),
consistency_level=ConsistencyLevel.ALL, serial_consistency_level=ConsistencyLevel.SERIAL)
my_timeout = 1.1234
self.assertNotEqual(ss.retry_policy.__class__, cluster.default_retry_policy)
self.assertNotEqual(ss.consistency_level, session.default_consistency_level)
self.assertNotEqual(ss._serial_consistency_level, session.default_serial_consistency_level)
self.assertNotEqual(my_timeout, session.default_timeout)
rf = session.execute_async(ss, timeout=my_timeout)
expected_profile = ExecutionProfile(load_balancing_policy=cluster.load_balancing_policy, retry_policy=ss.retry_policy,
request_timeout=my_timeout, consistency_level=ss.consistency_level,
serial_consistency_level=ss._serial_consistency_level)
self._verify_response_future_profile(rf, expected_profile)
def save(self, session: Session, prep_insert_statement: PreparedStatement, data):
if data is None:
raise ValueError("Cannot save None data to Cassandra.")
for channel_data in data:
channel_name = channel_data[0]
self.data_cache[channel_name].append(channel_data)
self.cache_counter += 1
if self.cache_counter < 100:
return len(self.future_cache)
def success_insert(results, future, pulse_id, channel_name):
self.future_cache.remove(future)
_logger.debug("Inserted pulse_id=%s for channel_name=%s", pulse_id, channel_name)
def failed_insert(e, future, pulse_id, channel_name):
self.future_cache.remove(future)
_logger.error("ERRRO IN %s. %s", channel_name, e)
for channel_name, data in self.data_cache.items():
batch = BatchStatement(batch_type=BatchType.UNLOGGED)
for pulse_data in data:
batch.add(prep_insert_statement, pulse_data)
future = session.execute_async(batch)
future.add_callbacks(callback=success_insert, callback_args=(future, 1, channel_name),
errback=failed_insert, errback_args=(future, 1, channel_name))
self.future_cache.add(future)
self.data_cache.clear()
self.cache_counter = 0
return len(self.future_cache)
async def _execute_query_async(session: Session, query, parameters=None):
cassandra_future = session.execute_async(query, parameters)
asyncio_future = asyncio.Future()
cassandra_future.add_callbacks(asyncio_future.set_result,
asyncio_future.set_exception)
return await asyncio_future
