def test_invalid_object(self):
class NoConfAsDict(object):
pass
obj = NoConfAsDict()
ns = 'tests.unit.advanced.test_insights'
if sys.version_info > (3, ):
ns += '.TestGetConfig.test_invalid_object.<locals>'
# no default
# ... as a policy
self.assertEqual(insights_registry.serialize(obj, policy=True), {
'type': 'NoConfAsDict',
'namespace': ns,
'options': {}
})
# ... not as a policy (default)
self.assertEqual(insights_registry.serialize(obj), {
'type': 'NoConfAsDict',
'namespace': ns,
})
# with default
self.assertIs(
insights_registry.serialize(obj,
default=sentinel.attr_err_default),
sentinel.attr_err_default)
def test_DC_aware_round_robin_policy(self):
self.assertEqual(
insights_registry.serialize(DCAwareRoundRobinPolicy()),
{'namespace': 'cassandra.policies',
'options': {'local_dc': '', 'used_hosts_per_remote_dc': 0},
'type': 'DCAwareRoundRobinPolicy'}
)
self.assertEqual(
insights_registry.serialize(DCAwareRoundRobinPolicy(local_dc='fake_local_dc',
used_hosts_per_remote_dc=15)),
{'namespace': 'cassandra.policies',
'options': {'local_dc': 'fake_local_dc', 'used_hosts_per_remote_dc': 15},
'type': 'DCAwareRoundRobinPolicy'}
)
def wrapper_policy_insights_serializer(policy):
return {'type': policy.__class__.__name__,
'namespace': namespace(policy.__class__),
'options': {
'child_policy': insights_registry.serialize(policy._child_policy,
policy=True)
}}
def test_whitelist_round_robin_policy(self):
self.assertEqual(
insights_registry.serialize(WhiteListRoundRobinPolicy(['127.0.0.3'])),
{'namespace': 'cassandra.policies',
'options': {'allowed_hosts': ('127.0.0.3',)},
'type': 'WhiteListRoundRobinPolicy'}
)
def execution_profile_insights_serializer(profile):
return {
'loadBalancing': insights_registry.serialize(profile.load_balancing_policy,
policy=True),
'retry': insights_registry.serialize(profile.retry_policy,
policy=True),
'readTimeout': profile.request_timeout,
'consistency': ConsistencyLevel.value_to_name.get(profile.consistency_level, None),
'serialConsistency': ConsistencyLevel.value_to_name.get(profile.serial_consistency_level, None),
'continuousPagingOptions': (insights_registry.serialize(profile.continuous_paging_options)
if (profile.continuous_paging_options is not None and
profile.continuous_paging_options is not _NOT_SET) else
None),
'speculativeExecution': insights_registry.serialize(profile.speculative_execution_policy),
'graphOptions': None
}
def test_graph_analytics_execution_profile(self):
self.maxDiff = None
self.assertEqual(
insights_registry.serialize(GraphAnalyticsExecutionProfile()),
{'consistency': 'LOCAL_ONE',
'continuousPagingOptions': None,
'loadBalancing': {'namespace': 'cassandra.policies',
'options': {'child_policy': {'namespace': 'cassandra.policies',
'options': {'child_policy': {'namespace': 'cassandra.policies',
'options': {'local_dc': '',
'used_hosts_per_remote_dc': 0},
'type': 'DCAwareRoundRobinPolicy'},
'shuffle_replicas': False},
'type': 'TokenAwarePolicy'}},
'type': 'DefaultLoadBalancingPolicy'},
'readTimeout': 604800.0,
'retry': {'namespace': 'cassandra.policies', 'options': {}, 'type': 'NeverRetryPolicy'},
'serialConsistency': None,
'speculativeExecution': {'namespace': 'cassandra.policies',
'options': {}, 'type': 'NoSpeculativeExecutionPolicy'},
'graphOptions': {'graphProtocol': None,
'language': 'gremlin-groovy',
'source': 'a'},
}
)
def token_aware_policy_insights_serializer(policy):
return {'type': policy.__class__.__name__,
'namespace': namespace(policy.__class__),
'options': {'child_policy': insights_registry.serialize(policy._child_policy,
policy=True),
'shuffle_replicas': policy.shuffle_replicas}
}
def test_spec_exec_policy(self):
self.assertEqual(
insights_registry.serialize(SpeculativeExecutionPolicy()), {
'type': 'SpeculativeExecutionPolicy',
'namespace': 'cassandra.policies',
'options': {}
})
def test_retry_policy(self):
self.assertEqual(
insights_registry.serialize(RetryPolicy()), {
'type': 'RetryPolicy',
'namespace': 'cassandra.policies',
'options': {}
})
def test_execution_profile(self):
self.maxDiff = None
self.assertEqual(
insights_registry.serialize(ExecutionProfile()), {
'consistency': 'LOCAL_ONE',
'continuousPagingOptions': None,
'loadBalancing': {
'namespace': 'cassandra.policies',
'options': {
'child_policy': {
'namespace': 'cassandra.policies',
'options': {
'local_dc': '',
'used_hosts_per_remote_dc': 0
},
'type': 'DCAwareRoundRobinPolicy'
},
'shuffle_replicas': False
},
'type': 'TokenAwarePolicy'
},
'readTimeout': 10.0,
'retry': {
'namespace': 'cassandra.policies',
'options': {},
'type': 'RetryPolicy'
},
'serialConsistency': None,
'speculativeExecution': {
'namespace': 'cassandra.policies',
'options': {},
'type': 'NoSpeculativeExecutionPolicy'
},
'graphOptions': None
})
def test_constant_reconnection_policy(self):
self.assertEqual(
insights_registry.serialize(ConstantReconnectionPolicy(3, 200)),
{'type': 'ConstantReconnectionPolicy',
'namespace': 'cassandra.policies',
'options': {'delay': 3, 'max_attempts': 200}
}
)
def test_exponential_reconnection_policy(self):
self.assertEqual(
insights_registry.serialize(ExponentialReconnectionPolicy(4, 100, 10)),
{'type': 'ExponentialReconnectionPolicy',
'namespace': 'cassandra.policies',
'options': {'base_delay': 4, 'max_delay': 100, 'max_attempts': 10}
}
)
def host_filter_policy_insights_serializer(policy):
return {
'type': policy.__class__.__name__,
'namespace': namespace(policy.__class__),
'options': {'child_policy': insights_registry.serialize(policy._child_policy,
policy=True),
'predicate': policy.predicate.__name__}
}
def test_constant_spec_exec_policy(self):
self.assertEqual(
insights_registry.serialize(ConstantSpeculativeExecutionPolicy(100, 101)),
{'type': 'ConstantSpeculativeExecutionPolicy',
'namespace': 'cassandra.policies',
'options': {'delay': 100,
'max_attempts': 101}
}
)
def test_token_aware_policy(self):
self.assertEqual(
insights_registry.serialize(TokenAwarePolicy(child_policy=LoadBalancingPolicy())),
{'namespace': 'cassandra.policies',
'options': {'child_policy': {'namespace': 'cassandra.policies',
'options': {},
'type': 'LoadBalancingPolicy'},
'shuffle_replicas': False},
'type': 'TokenAwarePolicy'}
)
def test_wrapper_policy(self):
self.assertEqual(
insights_registry.serialize(WrapperPolicy(LoadBalancingPolicy())),
{'namespace': 'cassandra.policies',
'options': {'child_policy': {'namespace': 'cassandra.policies',
'options': {},
'type': 'LoadBalancingPolicy'}
},
'type': 'WrapperPolicy'}
)
def test_successful_return(self):
class SuperclassSentinel(object):
pass
class SubclassSentinel(SuperclassSentinel):
pass
@insights_registry.register_serializer_for(SuperclassSentinel)
def superclass_sentinel_serializer(obj):
return sentinel.serialized_superclass
self.assertIs(insights_registry.serialize(SuperclassSentinel()),
sentinel.serialized_superclass)
self.assertIs(insights_registry.serialize(SubclassSentinel()),
sentinel.serialized_superclass)
# with default -- same behavior
self.assertIs(insights_registry.serialize(SubclassSentinel(), default=object()),
sentinel.serialized_superclass)
def profile_manager_insights_serializer(manager):
defaults = {
# Insights's expected default
'default': insights_registry.serialize(manager.profiles[EXEC_PROFILE_DEFAULT]),
# remaining named defaults for driver's defaults, including duplicated default
'EXEC_PROFILE_DEFAULT': insights_registry.serialize(manager.profiles[EXEC_PROFILE_DEFAULT]),
'EXEC_PROFILE_GRAPH_DEFAULT': insights_registry.serialize(manager.profiles[EXEC_PROFILE_GRAPH_DEFAULT]),
'EXEC_PROFILE_GRAPH_SYSTEM_DEFAULT': insights_registry.serialize(
manager.profiles[EXEC_PROFILE_GRAPH_SYSTEM_DEFAULT]
),
'EXEC_PROFILE_GRAPH_ANALYTICS_DEFAULT': insights_registry.serialize(
manager.profiles[EXEC_PROFILE_GRAPH_ANALYTICS_DEFAULT]
)
}
other = {
key: insights_registry.serialize(value)
for key, value in manager.profiles.items()
if key not in _EXEC_PROFILE_DEFAULT_KEYS
}
overlapping_keys = set(defaults) & set(other)
if overlapping_keys:
log.debug('The following key names overlap default key sentinel keys '
'and these non-default EPs will not be displayed in Insights '
': {}'.format(list(overlapping_keys)))
other.update(defaults)
return other
def test_host_filter_policy(self):
def my_predicate(s):
return False
self.assertEqual(
insights_registry.serialize(HostFilterPolicy(LoadBalancingPolicy(), my_predicate)),
{'namespace': 'cassandra.policies',
'options': {'child_policy': {'namespace': 'cassandra.policies',
'options': {},
'type': 'LoadBalancingPolicy'},
'predicate': 'my_predicate'},
'type': 'HostFilterPolicy'}
)
def test_graph_options(self):
self.maxDiff = None
go = GraphOptions(graph_name='name_for_test',
graph_source='source_for_test',
graph_language='lang_for_test',
graph_protocol='protocol_for_test',
graph_read_consistency_level=ConsistencyLevel.ANY,
graph_write_consistency_level=ConsistencyLevel.ONE,
graph_invalid_option='invalid')
log.debug(go._graph_options)
self.assertEqual(
insights_registry.serialize(go),
{'source': 'source_for_test',
'language': 'lang_for_test',
'graphProtocol': 'protocol_for_test',
# no graph_invalid_option
}
)
def _get_startup_data(self):
cc = self._session.cluster.control_connection
try:
local_ipaddr = cc._connection._socket.getsockname()[0]
except Exception as e:
local_ipaddr = None
log.debug('Unable to get local socket addr from {}: {}'.format(cc._connection, e))
hostname = socket.getfqdn()
host_distances_counter = Counter(
self._session.cluster.profile_manager.distance(host)
for host in self._session.hosts
)
host_distances_dict = {
'local': host_distances_counter[HostDistance.LOCAL],
'remote': host_distances_counter[HostDistance.REMOTE],
'ignored': host_distances_counter[HostDistance.IGNORED]
}
try:
compression_type = cc._connection._compression_type
except AttributeError:
compression_type = 'NONE'
cert_validation = None
try:
if self._session.cluster.ssl_context:
if isinstance(self._session.cluster.ssl_context, ssl.SSLContext):
cert_validation = self._session.cluster.ssl_context.verify_mode == ssl.CERT_REQUIRED
else: # pyopenssl
from OpenSSL import SSL
cert_validation = self._session.cluster.ssl_context.get_verify_mode() != SSL.VERIFY_NONE
elif self._session.cluster.ssl_options:
cert_validation = self._session.cluster.ssl_options.get('cert_reqs') == ssl.CERT_REQUIRED
except Exception as e:
log.debug('Unable to get the cert validation: {}'.format(e))
uname_info = platform.uname()
return {
'metadata': {
'name': 'driver.startup',
'insightMappingId': 'v1',
'insightType': 'EVENT',
'timestamp': ms_timestamp_from_datetime(datetime.datetime.utcnow()),
'tags': {
'language': 'python'
},
},
'data': {
'driverName': 'DataStax Python Driver',
'driverVersion': sys.modules['cassandra'].__version__,
'clientId': str(self._session.cluster.client_id),
'sessionId': str(self._session.session_id),
'applicationName': self._session.cluster.application_name or 'python',
'applicationNameWasGenerated': not self._session.cluster.application_name,
'applicationVersion': self._session.cluster.application_version,
'contactPoints': self._session.cluster._endpoint_map_for_insights,
'dataCenters': list(set(h.datacenter for h in self._session.cluster.metadata.all_hosts()
if (h.datacenter and
self._session.cluster.profile_manager.distance(h) == HostDistance.LOCAL))),
'initialControlConnection': cc._connection.host if cc._connection else None,
'protocolVersion': self._session.cluster.protocol_version,
'localAddress': local_ipaddr,
'hostName': hostname,
'executionProfiles': insights_registry.serialize(self._session.cluster.profile_manager),
'configuredConnectionLength': host_distances_dict,
'heartbeatInterval': self._session.cluster.idle_heartbeat_interval,
'compression': compression_type.upper() if compression_type else 'NONE',
'reconnectionPolicy': insights_registry.serialize(self._session.cluster.reconnection_policy),
'sslConfigured': {
'enabled': bool(self._session.cluster.ssl_options or self._session.cluster.ssl_context),
'certValidation': cert_validation
},
'authProvider': {
'type': (self._session.cluster.auth_provider.__class__.__name__
if self._session.cluster.auth_provider else
None)
},
'otherOptions': {
},
'platformInfo': {
'os': {
'name': uname_info.system if six.PY3 else uname_info[0],
'version': uname_info.release if six.PY3 else uname_info[2],
'arch': uname_info.machine if six.PY3 else uname_info[4]
},
'cpus': {
'length': multiprocessing.cpu_count(),
'model': platform.processor()
},
'runtime': {
'python': sys.version,
'event_loop': self._session.cluster.connection_class.__name__
}
},
'periodicStatusInterval': self._interval
}
}
def graph_execution_profile_insights_serializer(profile):
rv = insights_registry.serialize(profile, cls=ExecutionProfile)
rv['graphOptions'] = insights_registry.serialize(profile.graph_options)
return rv
