def get_cluster(options, env):
"""
Obtain a cluster from the command line options and environment.
:param BenchmarkOption options: Parsed command line options.
:param dict env: Dictionary of environment variables.
:return BenchmarkCluster: Cluster to benchmark.
"""
cluster_option = options['cluster']
if cluster_option:
try:
cluster = BenchmarkCluster.from_cluster_yaml(
FilePath(cluster_option)
)
except IOError as e:
usage(
options, 'Cluster file {!r} not found.'.format(e.filename)
)
else:
try:
cluster = BenchmarkCluster.from_acceptance_test_env(env)
except KeyError as e:
usage(
options, 'Environment variable {!r} not set.'.format(e.args[0])
)
except ValueError as e:
usage(options, e.args[0])
except ValidationError as e:
usage(options, e.message)
return cluster
def get_cluster(options, env):
"""
Obtain a cluster from the command line options and environment.
:param BenchmarkOption options: Parsed command line options.
:param dict env: Dictionary of environment variables.
:return BenchmarkCluster: Cluster to benchmark.
"""
cluster_option = options['cluster']
if cluster_option:
try:
cluster = BenchmarkCluster.from_cluster_yaml(
FilePath(cluster_option))
except IOError as e:
usage(options, 'Cluster file {!r} not found.'.format(e.filename))
else:
try:
cluster = BenchmarkCluster.from_acceptance_test_env(env)
except KeyError as e:
usage(options,
'Environment variable {!r} not set.'.format(e.args[0]))
except ValueError as e:
usage(options, e.args[0])
except ValidationError as e:
usage(options, e.message)
return cluster
def setUp(self):
super(BenchmarkClusterTests, self).setUp()
node = Node(
# Node public_address is actually the internal cluster address
uuid=uuid4(), public_address=CONTROL_SERVICE_PRIVATE_IP
)
self.control_service = FakeFlockerClient([node])
self.cluster = BenchmarkCluster(
CONTROL_SERVICE_PUBLIC_IP,
lambda reactor: self.control_service,
{
CONTROL_SERVICE_PRIVATE_IP: CONTROL_SERVICE_PUBLIC_IP,
},
DEFAULT_VOLUME_SIZE,
)
def test_read_request_load_start_stop_start_succeeds(self, _logger):
"""
``read_request_load_scenario`` starts, stops and starts
without collapsing.
"""
c = Clock()
node1 = Node(uuid=uuid4(), public_address=IPAddress('10.0.0.1'))
node2 = Node(uuid=uuid4(), public_address=IPAddress('10.0.0.2'))
cluster = BenchmarkCluster(
node1.public_address,
lambda reactor: FakeFlockerClient([node1, node2]),
{node1.public_address, node2.public_address},
default_volume_size=DEFAULT_VOLUME_SIZE)
sample_size = 5
s = read_request_load_scenario(c, cluster, sample_size=sample_size)
# Start and stop
s.start()
c.pump(repeat(1, sample_size))
s.stop()
# Start again and verify the scenario succeeds
d = s.start()
c.pump(repeat(1, sample_size))
s.maintained().addBoth(lambda x: self.fail())
d.addCallback(lambda ignored: s.stop())
c.pump(repeat(1, sample_size))
self.successResultOf(d)
def test_read_request_load_succeeds(self, _logger):
"""
``read_request_load_scenario`` starts and stops without collapsing.
"""
c = Clock()
node1 = Node(uuid=uuid4(), public_address=IPAddress('10.0.0.1'))
node2 = Node(uuid=uuid4(), public_address=IPAddress('10.0.0.2'))
cluster = BenchmarkCluster(
node1.public_address,
lambda reactor: FakeFlockerClient([node1, node2]),
{node1.public_address, node2.public_address},
default_volume_size=DEFAULT_VOLUME_SIZE)
sample_size = 5
s = read_request_load_scenario(c, cluster, sample_size=sample_size)
d = s.start()
# Request rate samples are recorded every second and we need to
# collect enough samples to establish the rate which is defined
# by `sample_size`. Therefore, advance the clock by
# `sample_size` seconds to obtain enough samples.
c.pump(repeat(1, sample_size))
s.maintained().addBoth(lambda x: self.fail())
d.addCallback(lambda ignored: s.stop())
c.pump(repeat(1, sample_size))
self.successResultOf(d)
def test_get_probe_timeout(self):
"""
CreateContainer probe times-out if get_probe runs too long.
"""
clock = Clock()
node_id = uuid4()
node = Node(uuid=node_id, public_address=IPAddress('10.0.0.1'))
control_service = FakeFlockerClient([node], node_id)
cluster = BenchmarkCluster(
IPAddress('10.0.0.1'),
lambda reactor: control_service,
{},
None,
)
operation = CreateContainer(clock, cluster)
d = operation.get_probe()
clock.advance(DEFAULT_TIMEOUT.total_seconds())
# No control_service.synchronize_state() call, so cluster state
# never shows container is created.
# The Deferred fails if container not created within 10 minutes.
self.failureResultOf(d)
class BenchmarkClusterTests(TestCase):
def setUp(self):
super(BenchmarkClusterTests, self).setUp()
node = Node(
# Node public_address is actually the internal cluster address
uuid=uuid4(), public_address=CONTROL_SERVICE_PRIVATE_IP
)
self.control_service = FakeFlockerClient([node])
self.cluster = BenchmarkCluster(
CONTROL_SERVICE_PUBLIC_IP,
lambda reactor: self.control_service,
{
CONTROL_SERVICE_PRIVATE_IP: CONTROL_SERVICE_PUBLIC_IP,
},
DEFAULT_VOLUME_SIZE,
)
def test_control_node_address(self):
"""
The ``control_node_address`` method gives expected results.
"""
self.assertEqual(
self.cluster.control_node_address(), CONTROL_SERVICE_PUBLIC_IP)
def test_control_service(self):
"""
The ``control_service`` method gives expected results.
"""
self.assertIs(
self.cluster.get_control_service(Clock()), self.control_service)
def test_public_address(self):
"""
The ``public_address`` method gives expected results.
"""
self.assertEqual(
self.cluster.public_address(CONTROL_SERVICE_PRIVATE_IP),
CONTROL_SERVICE_PUBLIC_IP
)
def test_default_volume_size(self):
"""
The ``default_volume_size`` method gives expected results.
"""
self.assertEqual(
self.cluster.default_volume_size(), DEFAULT_VOLUME_SIZE)
def start_read_request(result):
cluster = BenchmarkCluster(
IPAddress('10.0.0.1'),
lambda reactor: control_service,
{},
None,
)
request = ReadRequest(Clock(), cluster, 'list_datasets_state')
return request.get_probe()
def make_cluster(self, FlockerClientInstance):
"""
Create a cluster that can be used by the scenario tests.
"""
return BenchmarkCluster(
self.node1.public_address,
lambda reactor: FlockerClientInstance,
{self.node1.public_address, self.node2.public_address},
default_volume_size=DEFAULT_VOLUME_SIZE,
)
def setUp(self):
node = Node(
# Node public_address is actually the internal cluster address
uuid=uuid4(), public_address=CONTROL_SERVICE_PRIVATE_IP
)
self.control_service = FakeFlockerClient([node])
self.cluster = BenchmarkCluster(
CONTROL_SERVICE_PUBLIC_IP, lambda reactor: self.control_service, {
CONTROL_SERVICE_PRIVATE_IP: CONTROL_SERVICE_PUBLIC_IP,
}
)
def make_cluster(self, make_flocker_client):
"""
Create a cluster that can be used by the scenario tests.
"""
node1 = Node(uuid=uuid4(), public_address=IPAddress('10.0.0.1'))
node2 = Node(uuid=uuid4(), public_address=IPAddress('10.0.0.2'))
return BenchmarkCluster(
node1.public_address,
lambda reactor: make_flocker_client(
FakeFlockerClient([node1, node2]), reactor),
{node1.public_address, node2.public_address},
default_volume_size=DEFAULT_VOLUME_SIZE,
)
class BenchmarkClusterTests(SynchronousTestCase):
def setUp(self):
node = Node(
# Node public_address is actually the internal cluster address
uuid=uuid4(), public_address=CONTROL_SERVICE_PRIVATE_IP
)
self.control_service = FakeFlockerClient([node])
self.cluster = BenchmarkCluster(
CONTROL_SERVICE_PUBLIC_IP, lambda reactor: self.control_service, {
CONTROL_SERVICE_PRIVATE_IP: CONTROL_SERVICE_PUBLIC_IP,
}
)
def test_control_node_address(self):
"""
The ``control_node_address`` method gives expected results.
"""
self.assertEqual(
self.cluster.control_node_address(), CONTROL_SERVICE_PUBLIC_IP)
def test_control_service(self):
"""
The ``control_service`` method gives expected results.
"""
self.assertIs(
self.cluster.get_control_service(Clock()), self.control_service)
def test_public_address(self):
"""
The ``public_address`` method gives expected results.
"""
self.assertEqual(
self.cluster.public_address(CONTROL_SERVICE_PRIVATE_IP),
CONTROL_SERVICE_PUBLIC_IP
)
def test_empty_cluster(self):
"""
CreateDataset fails if no nodes in cluster.
"""
control_service = FakeFlockerClient()
cluster = BenchmarkCluster(
IPAddress('10.0.0.1'),
lambda reactor: control_service,
{},
None,
)
d = CreateDataset(Clock(), cluster).get_probe()
self.failureResultOf(d, EmptyClusterError)
def test_create_container(self, _logger):
"""
CreateContainer probe waits for cluster to converge.
"""
clock = Clock()
node_id = uuid4()
node = Node(uuid=node_id, public_address=IPAddress('10.0.0.1'))
control_service = FakeFlockerClient([node], node_id)
cluster = BenchmarkCluster(
IPAddress('10.0.0.1'),
lambda reactor: control_service,
{},
None,
)
operation = CreateContainer(clock, cluster)
d = operation.get_probe()
def run_probe(probe):
def cleanup(result):
cleaned_up = probe.cleanup()
cleaned_up.addCallback(lambda _ignored: result)
return cleaned_up
d = probe.run()
d.addCallback(cleanup)
return d
d.addCallback(run_probe)
# Advance the clock because probe periodically polls the state.
# Due to multiple steps, need to synchronize state a few times.
control_service.synchronize_state() # creation of pull container
clock.advance(1)
control_service.synchronize_state() # deletion of pull container
clock.advance(1)
# The Deferred does not fire before the container has been created.
self.assertNoResult(d)
control_service.synchronize_state() # creation of test container
clock.advance(1)
# The Deferred fires once the container has been created.
self.successResultOf(d)
def test_cpu_time(self):
"""
Fake Flocker cluster gives expected results.
"""
clock = Clock()
node1 = Node(uuid=uuid4(), public_address=IPAddress('10.0.0.1'))
node2 = Node(uuid=uuid4(), public_address=IPAddress('10.0.0.2'))
metric = CPUTime(clock,
BenchmarkCluster(
IPAddress('10.0.0.1'),
lambda reactor: FakeFlockerClient([node1, node2]),
{},
None,
),
_LocalRunner(),
processes=[_pid_1_name])
d = metric.measure(lambda: clock.advance(5))
# Although it is unlikely, it's possible that we could get a CPU
# time != 0, so filter values out.
def remove_process_times(node_cpu_times):
for process_times in node_cpu_times.values():
if process_times:
for process in process_times:
if process != WALLCLOCK_LABEL:
process_times[process] = 0
return node_cpu_times
d.addCallback(remove_process_times)
def check(result):
self.assertEqual(
result, {
'10.0.0.1': {
_pid_1_name: 0,
WALLCLOCK_LABEL: 5
},
'10.0.0.2': {
_pid_1_name: 0,
WALLCLOCK_LABEL: 5
}
})
d.addCallback(check)
return d
def test_create_dataset(self, logger):
"""
CreateDataset probe waits for cluster to converge.
"""
clock = Clock()
node_id = uuid4()
node = Node(uuid=node_id, public_address=IPAddress('10.0.0.1'))
control_service = FakeFlockerClient([node], node_id)
cluster = BenchmarkCluster(
IPAddress('10.0.0.1'),
lambda reactor: control_service,
{},
None,
)
operation = CreateDataset(clock, cluster)
d = operation.get_probe()
def run_probe(probe):
def cleanup(result):
cleaned_up = probe.cleanup()
cleaned_up.addCallback(lambda _ignored: result)
return cleaned_up
d = probe.run()
d.addCallback(cleanup)
return d
d.addCallback(run_probe)
# Advance the clock because probe periodically polls the state.
# The Deferred does not fire before the dataset has been created.
clock.advance(1)
self.assertNoResult(d)
# Trigger convergence of the fake Flocker cluster.
control_service.synchronize_state()
# The Deferred fires once the dataset has been created.
clock.advance(1)
self.successResultOf(d)
def test_scenario_throws_exception_when_already_started(self, _logger):
"""
start method in the ``RequestLoadScenario`` throws a
``RequestScenarioAlreadyStarted`` if the scenario is already started.
"""
c = Clock()
node1 = Node(uuid=uuid4(), public_address=IPAddress('10.0.0.1'))
node2 = Node(uuid=uuid4(), public_address=IPAddress('10.0.0.2'))
cluster = BenchmarkCluster(
node1.public_address,
lambda reactor: FakeFlockerClient([node1, node2]),
{node1.public_address, node2.public_address},
default_volume_size=DEFAULT_VOLUME_SIZE)
sample_size = 5
s = read_request_load_scenario(c, cluster, sample_size=sample_size)
s.start()
self.assertRaises(RequestScenarioAlreadyStarted, s.start)
