class StorageProxy(object): def __init__(self, node): assert isinstance(node, Node) self.node = node self.jmx = JolokiaAgent(node) self.mbean = make_mbean("db", type="StorageProxy") def start(self): self.jmx.start() def stop(self): self.jmx.stop() @property def blocking_read_repair(self): return self.jmx.read_attribute(self.mbean, "ReadRepairRepairedBlocking") @property def speculated_data_request(self): return self.jmx.read_attribute(self.mbean, "ReadRepairSpeculatedRequest") @property def speculated_data_repair(self): return self.jmx.read_attribute(self.mbean, "ReadRepairSpeculatedRepair") def __enter__(self): """ For contextmanager-style usage. """ self.start() return self def __exit__(self, exc_type, value, traceback): """ For contextmanager-style usage. """ self.stop()
class StorageService(object): def __init__(self, node): assert isinstance(node, Node) self.node = node self.jmx = JolokiaAgent(node) self.mbean = make_mbean("db", type="StorageService") def start(self): self.jmx.start() def stop(self): self.jmx.stop() def get_replicas(self, ks, cf, key): return self.jmx.execute_method( self.mbean, "getNaturalEndpointsWithPort(java.lang.String,java.lang.String,java.lang.String,boolean)", [ks, cf, key, True]) def __enter__(self): """ For contextmanager-style usage. """ self.start() return self def __exit__(self, exc_type, value, traceback): """ For contextmanager-style usage. """ self.stop()
class TableMetrics(object): def __init__(self, node, keyspace, table): assert isinstance(node, Node) self.jmx = JolokiaAgent(node) self.write_latency_mbean = make_mbean("metrics", type="Table", name="WriteLatency", keyspace=keyspace, scope=table) self.speculative_reads_mbean = make_mbean("metrics", type="Table", name="SpeculativeRetries", keyspace=keyspace, scope=table) self.transient_writes_mbean = make_mbean("metrics", type="Table", name="TransientWrites", keyspace=keyspace, scope=table) @property def write_count(self): return self.jmx.read_attribute(self.write_latency_mbean, "Count") @property def speculative_reads(self): return self.jmx.read_attribute(self.speculative_reads_mbean, "Count") @property def transient_writes(self): return self.jmx.read_attribute(self.transient_writes_mbean, "Count") def start(self): self.jmx.start() def stop(self): self.jmx.stop() def __enter__(self): """ For contextmanager-style usage. """ self.start() return self def __exit__(self, exc_type, value, traceback): """ For contextmanager-style usage. """ self.stop()
class StorageService(object): def __init__(self, node): assert isinstance(node, Node) self.node = node self.jmx = JolokiaAgent(node) self.mbean = make_mbean("db", type="StorageService") def start(self): self.jmx.start() def stop(self): self.jmx.stop() def get_replicas(self, ks, cf, key): return self.jmx.execute_method(self.mbean, "getNaturalEndpointsWithPort(java.lang.String,java.lang.String,java.lang.String,boolean)", [ks, cf, key, True]) def __enter__(self): """ For contextmanager-style usage. """ self.start() return self def __exit__(self, exc_type, value, traceback): """ For contextmanager-style usage. """ self.stop()
def setup_once(self): cluster = self.cluster cluster.set_configuration_options({ 'read_request_timeout_in_ms': 3000, 'write_request_timeout_in_ms': 3000, 'phi_convict_threshold': 12, 'tombstone_failure_threshold': TOMBSTONE_FAILURE_THRESHOLD, 'enable_materialized_views': 'true' }) cluster.populate(2, debug=True) cluster.start(jvm_args=JVM_ARGS) node1 = cluster.nodelist()[0] global jmx jmx = JolokiaAgent(node1) jmx.start() s = self.session = self.patient_exclusive_cql_connection( node1, retry_policy=FallthroughRetryPolicy(), request_timeout=30) for k in [KEYSPACE, FAIL_WRITE_KEYSPACE]: create_ks(s, k, 2) s.execute( f"CREATE TABLE {k}.{TABLE} (k int, c int, v int, PRIMARY KEY (k,c))" ) create_ks(s, VIEW_KEYSPACE, 1) s.execute( f"CREATE TABLE {VIEW_KEYSPACE}.{TABLE} (k int, c int, v int, PRIMARY KEY (k,c))" ) s.execute( f"CREATE MATERIALIZED VIEW {VIEW_KEYSPACE}.{VIEW} AS SELECT * FROM {TABLE} WHERE c IS NOT NULL AND k IS NOT NULL PRIMARY KEY (c,k);" ) # Here we're doing a series of deletions in order to create enough tombstones to exceed the configured fail threshold. # This partition will be used to test read failures. for c in range(TOMBSTONE_FAILURE_THRESHOLD + 1): self.session.execute( f"DELETE FROM {KEYSPACE}.{TABLE} WHERE k={TOMBSTONE_FAIL_KEY} AND c={c}" ) node1.watch_log_for( "Created default superuser role 'cassandra'" ) # don't race with async default role creation, which creates a write node1.watch_log_for( 'Completed submission of build tasks for any materialized views defined at startup', filename='debug.log') # view builds cause background reads
class StorageProxy(object): def __init__(self, node): assert isinstance(node, Node) self.node = node self.jmx = JolokiaAgent(node) def start(self): self.jmx.start() def stop(self): self.jmx.stop() def _get_metric(self, metric): mbean = make_mbean("metrics", type="ReadRepair", name=metric) return self.jmx.read_attribute(mbean, "Count") @property def blocking_read_repair(self): return self._get_metric("RepairedBlocking") @property def speculated_rr_read(self): return self._get_metric("SpeculatedRead") @property def speculated_rr_write(self): return self._get_metric("SpeculatedWrite") def get_table_metric(self, keyspace, table, metric, attr="Count"): mbean = make_mbean("metrics", keyspace=keyspace, scope=table, type="Table", name=metric) return self.jmx.read_attribute(mbean, attr) def __enter__(self): """ For contextmanager-style usage. """ self.start() return self def __exit__(self, exc_type, value, traceback): """ For contextmanager-style usage. """ self.stop()