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