def test_schedule_no_max(self):
base_delay = 2
max_delay = 100
test_iter = 10000
policy = ExponentialReconnectionPolicy(base_delay=base_delay, max_delay=max_delay, max_attempts=None)
sched_slice = list(islice(policy.new_schedule(), 0, test_iter))
self.assertEqual(sched_slice[0], base_delay)
self.assertEqual(sched_slice[-1], max_delay)
self.assertEqual(len(sched_slice), test_iter)
def test_schedule(self):
policy = ExponentialReconnectionPolicy(base_delay=2, max_delay=100)
schedule = list(policy.new_schedule())
self.assertEqual(len(schedule), 64)
for i, delay in enumerate(schedule):
if i == 0:
self.assertEqual(delay, 2)
elif i < 6:
self.assertEqual(delay, schedule[i - 1] * 2)
else:
self.assertEqual(delay, 100)
def test_schedule(self):
policy = ExponentialReconnectionPolicy(base_delay=2, max_delay=100)
schedule = list(policy.new_schedule())
self.assertEqual(len(schedule), 64)
for i, delay in enumerate(schedule):
if i == 0:
self.assertEqual(delay, 2)
elif i < 6:
self.assertEqual(delay, schedule[i - 1] * 2)
else:
self.assertEqual(delay, 100)
def test_schedule_no_max(self):
base_delay = 2
max_delay = 100
test_iter = 10000
policy = ExponentialReconnectionPolicy(base_delay=base_delay,
max_delay=max_delay,
max_attempts=None)
sched_slice = list(islice(policy.new_schedule(), 0, test_iter))
self.assertEqual(sched_slice[0], base_delay)
self.assertEqual(sched_slice[-1], max_delay)
self.assertEqual(len(sched_slice), test_iter)
def test_schedule_with_max(self):
base_delay = 2
max_delay = 100
max_attempts = 64
policy = ExponentialReconnectionPolicy(base_delay=base_delay, max_delay=max_delay, max_attempts=max_attempts)
schedule = list(policy.new_schedule())
self.assertEqual(len(schedule), max_attempts)
for i, delay in enumerate(schedule):
if i == 0:
self.assertEqual(delay, base_delay)
elif i < 6:
self.assertEqual(delay, schedule[i - 1] * 2)
else:
self.assertEqual(delay, max_delay)
def test_schedule_with_max(self):
base_delay = 2
max_delay = 100
max_attempts = 64
policy = ExponentialReconnectionPolicy(base_delay=base_delay,
max_delay=max_delay,
max_attempts=max_attempts)
schedule = list(policy.new_schedule())
self.assertEqual(len(schedule), max_attempts)
for i, delay in enumerate(schedule):
if i == 0:
self.assertEqual(delay, base_delay)
elif i < 6:
self.assertEqual(delay, schedule[i - 1] * 2)
else:
self.assertEqual(delay, max_delay)
def setup(self):
if not self.keyspace or not isinstance(self.keyspace, text_type):
self.keyspace = self.container.service_name
cluster_options = dict(
reconnection_policy=ExponentialReconnectionPolicy(base_delay=3,
max_delay=15),
connection_class=EventletConnection)
if self.models:
cluster_options['protocol_version'] = 3
os.environ.setdefault('CQLENG_ALLOW_SCHEMA_MANAGEMENT', '1')
self.connection = register_connection(
name=self.connection_name,
hosts=self.nodes,
lazy_connect=False,
retry_connect=True,
cluster_options=cluster_options,
default=self.connection_name == DEFAULT_CONNECTION_NAME)
topology = self.cassandra_config.get('topology', SIMPLE_KEYSPACE)
if topology not in (SIMPLE_KEYSPACE, NETWORK_KEYSPACE):
topology = SIMPLE_KEYSPACE
topology_func = {
SIMPLE_KEYSPACE: management.create_keyspace_simple,
NETWORK_KEYSPACE: management.create_keyspace_network_topology
}.get(topology)
topology_func(**self.topology_options(topology))
if self.session:
self.session.set_keyspace(self.keyspace)
for model in self.models:
sync_table(model, [self.keyspace], [self.connection])
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 test_default_connections(self):
"""
Ensure errors are not thrown when using non-default policies
"""
Cluster(load_balancing_policy=RoundRobinPolicy(),
reconnection_policy=ExponentialReconnectionPolicy(1.0, 600.0),
default_retry_policy=RetryPolicy(),
conviction_policy_factory=SimpleConvictionPolicy)
def test_schedule(self):
policy = ExponentialReconnectionPolicy(base_delay=2, max_delay=100, max_attempts=None)
i=0;
for delay in policy.new_schedule():
i += 1
if i > 10000:
break;
self.assertEqual(i, 10001)
policy = ExponentialReconnectionPolicy(base_delay=2, max_delay=100, max_attempts=64)
schedule = list(policy.new_schedule())
self.assertEqual(len(schedule), 64)
for i, delay in enumerate(schedule):
if i == 0:
self.assertEqual(delay, 2)
elif i < 6:
self.assertEqual(delay, schedule[i - 1] * 2)
else:
self.assertEqual(delay, 100)
def cluster(cfg, keyspace=None):
auth = PlainTextAuthProvider(username=cfg['cassandra_user'],
password=cfg['cassandra_pass'])
cluster = Cluster(cfg['cassandra_host'],
load_balancing_policy=RoundRobinPolicy(),
default_retry_policy=RetryPolicy(),
reconnection_policy=ExponentialReconnectionPolicy(
1.0, 600.0),
port=cfg['cassandra_port'],
auth_provider=auth)
return cluster
