def test_delay_can_be_0(self):
"""
Test to validate that the delay can be zero for the ConstantSpeculativeExecutionPolicy
@since 3.13
@jira_ticket PYTHON-836
@expected_result all the queries are executed immediately
@test_category policy
"""
number_of_requests = 4
spec = ExecutionProfile(
speculative_execution_policy=ConstantSpeculativeExecutionPolicy(
0, number_of_requests))
cluster = Cluster()
cluster.add_execution_profile("spec", spec)
session = cluster.connect(wait_for_all_pools=True)
self.addCleanup(cluster.shutdown)
counter = count()
def patch_and_count(f):
def patched(*args, **kwargs):
next(counter)
f(*args, **kwargs)
return patched
ResponseFuture._on_speculative_execute = patch_and_count(
ResponseFuture._on_speculative_execute)
stmt = SimpleStatement("INSERT INTO test3rf.test(k, v) VALUES (1, 2)")
stmt.is_idempotent = True
results = session.execute(stmt, execution_profile="spec")
self.assertEqual(len(results.response_future.attempted_hosts), 3)
self.assertEqual(next(counter), number_of_requests)
def test_speculative_execution(self):
"""
Test to ensure that speculative execution honors LBP, and that they retry appropriately.
This test will use various LBP, and ConstantSpeculativeExecutionPolicy settings and ensure the proper number of hosts are queried
@since 3.7.0
@jira_ticket PYTHON-218
@expected_result speculative retries should honor max retries, idempotent state of queries, and underlying lbp.
@test_category metadata
"""
self.session.execute("""USE {0}""".format(self.keyspace_name))
self.session.execute("""create or replace function timeout (arg int) RETURNS NULL ON NULL INPUT RETURNS int LANGUAGE java AS $$ long start = System.currentTimeMillis(); while(System.currentTimeMillis() - start < arg){} return arg; $$;""")
self.session.execute("""CREATE TABLE d (k int PRIMARY KEY , i int);""")
self.session.execute("""INSERT INTO d (k,i) VALUES (0, 1000);""")
statement = SimpleStatement("""SELECT timeout(i) FROM d WHERE k =0""", is_idempotent=True)
statement_non_idem = SimpleStatement("""SELECT timeout(i) FROM d WHERE k =0""", is_idempotent=False)
# This LBP should repeat hosts up to around 30
result = self.session.execute(statement, execution_profile='spec_ep_brr')
self.assertEqual(21, len(result.response_future.attempted_hosts))
# This LBP should keep host list to 3
result = self.session.execute(statement, execution_profile='spec_ep_rr')
self.assertEqual(3, len(result.response_future.attempted_hosts))
# Spec_execution policy should limit retries to 1
result = self.session.execute(statement, execution_profile='spec_ep_rr_lim')
self.assertEqual(2, len(result.response_future.attempted_hosts))
# Spec_execution policy should not be used if the query is not idempotent
result = self.session.execute(statement_non_idem, execution_profile='spec_ep_brr')
self.assertEqual(1, len(result.response_future.attempted_hosts))
# Default policy with non_idem query
result = self.session.execute(statement_non_idem)
self.assertEqual(1, len(result.response_future.attempted_hosts))
# Should be able to run an idempotent query against default execution policy with no speculative_execution_policy
result = self.session.execute(statement)
self.assertEqual(1, len(result.response_future.attempted_hosts))
# Test timeout with spec_ex
with self.assertRaises(OperationTimedOut):
result = self.session.execute(statement, execution_profile='spec_ep_rr', timeout=.5)
# PYTHON-736 Test speculation policy works with a prepared statement
statement = self.session.prepare("SELECT timeout(i) FROM d WHERE k = ?")
# non-idempotent
result = self.session.execute(statement, (0,), execution_profile='spec_ep_brr')
self.assertEqual(1, len(result.response_future.attempted_hosts))
# idempotent
statement.is_idempotent = True
result = self.session.execute(statement, (0,), execution_profile='spec_ep_brr')
self.assertLess(1, len(result.response_future.attempted_hosts))
def test_delay_can_be_0(self):
"""
Test to validate that the delay can be zero for the ConstantSpeculativeExecutionPolicy
@since 3.13
@jira_ticket PYTHON-836
@expected_result all the queries are executed immediately
@test_category policy
"""
query_to_prime = "INSERT INTO madeup_keyspace.madeup_table(k, v) VALUES (1, 2)"
prime_query(query_to_prime, then={"delay_in_ms": 5000})
number_of_requests = 4
spec = ExecutionProfile(
load_balancing_policy=RoundRobinPolicy(),
speculative_execution_policy=ConstantSpeculativeExecutionPolicy(
0, number_of_requests))
cluster = Cluster()
cluster.add_execution_profile("spec", spec)
session = cluster.connect(wait_for_all_pools=True)
self.addCleanup(cluster.shutdown)
counter = count()
def patch_and_count(f):
def patched(*args, **kwargs):
next(counter)
print("patched")
f(*args, **kwargs)
return patched
self.addCleanup(setattr, ResponseFuture, "send_request",
ResponseFuture.send_request)
ResponseFuture.send_request = patch_and_count(
ResponseFuture.send_request)
stmt = SimpleStatement(query_to_prime)
stmt.is_idempotent = True
results = session.execute(stmt, execution_profile="spec")
self.assertEqual(len(results.response_future.attempted_hosts), 3)
# send_request is called number_of_requests times for the speculative request
# plus one for the call from the main thread.
self.assertEqual(next(counter), number_of_requests + 1)
def test_delay_can_be_0(self):
"""
Test to validate that the delay can be zero for the ConstantSpeculativeExecutionPolicy
@since 3.13
@jira_ticket PYTHON-836
@expected_result all the queries are executed immediately
@test_category policy
"""
query_to_prime = "INSERT INTO madeup_keyspace.madeup_table(k, v) VALUES (1, 2)"
prime_query(query_to_prime, then={"delay_in_ms": 5000})
number_of_requests = 4
spec = ExecutionProfile(load_balancing_policy=RoundRobinPolicy(),
speculative_execution_policy=ConstantSpeculativeExecutionPolicy(0, number_of_requests))
cluster = Cluster()
cluster.add_execution_profile("spec", spec)
session = cluster.connect(wait_for_all_pools=True)
self.addCleanup(cluster.shutdown)
counter = count()
def patch_and_count(f):
def patched(*args, **kwargs):
next(counter)
print("patched")
f(*args, **kwargs)
return patched
self.addCleanup(setattr, ResponseFuture, "send_request", ResponseFuture.send_request)
ResponseFuture.send_request = patch_and_count(ResponseFuture.send_request)
stmt = SimpleStatement(query_to_prime)
stmt.is_idempotent = True
results = session.execute(stmt, execution_profile="spec")
self.assertEqual(len(results.response_future.attempted_hosts), 3)
# send_request is called number_of_requests times for the speculative request
# plus one for the call from the main thread.
self.assertEqual(next(counter), number_of_requests + 1)
