def test_reboot_required(self):
"""
Test that reboot required flag is set when all the required agent
parameters are set.
"""
self.agent._parse_options(["--config-path", self.agent_conf_dir])
# Check that reboot required is false until we set all the params
self.assertFalse(self.agent.reboot_required)
req = ProvisionRequest()
req.availability_zone = "test1"
req.datastores = ["ds3", "ds4"]
req.networks = ["Public"]
addr = ServerAddress(host="localhost", port=2345)
req.address = addr
self.agent.update_config(req)
# Verify that the bootstrap is still false as zk config is not
# specified.
self.assertFalse(self.agent.bootstrap_ready)
self.assertTrue(self.agent.reboot_required)
req = ProvisionRequest()
req.availability_zone = "test1"
req.datastores = ["ds3", "ds4"]
req.networks = ["Public"]
addr = ServerAddress(host="localhost", port=2345)
req.address = addr
self.agent.update_config(req)
self.assertTrue(self.agent.reboot_required)
def test_report(self, client_class, time_class, chairman):
"""Test that resurrected and missing hosts get reported correctly"""
client_class.side_effect = self.create_fake_client
chairman.return_value.report_resurrected.return_value = \
ReportResurrectedResponse(result=0)
bar_client = MagicMock()
baz_client = MagicMock()
self._clients["bar"] = bar_client
self._clients["baz"] = baz_client
children = {
"bar": ServerAddress("bar", 1234),
"baz": ServerAddress("baz", 1234)
}
# first ping succeeds for bar and baz. they get reported resurrected.
health_checker = HealthChecker("id", children, self.conf)
time_class.return_value = 0.0
health_checker._send_heartbeat()
health_checker._send_report()
req = ReportResurrectedRequest(hosts=['bar', 'baz'],
schedulers=None,
scheduler_id='id')
chairman.return_value.report_resurrected.assert_called_once_with(req)
self.assertFalse(chairman.return_value.report_missing.called)
self.assertEquals(health_checker._resurrected_children,
set(["bar", "baz"]))
self.assertEquals(health_checker._missing_children, set())
# call _send_report again. this time nothing should get reported.
chairman.reset_mock()
health_checker._send_report()
self.assertFalse(chairman.return_value.report_missing.called)
self.assertFalse(chairman.return_value.report_resurrected.called)
# bar goes missing.
bar_client.ping.side_effect = Exception()
health_checker._send_heartbeat()
time_class.return_value = 100.0
chairman.return_value.report_missing.return_value = \
ReportMissingResponse(result=0)
health_checker._send_report()
req = ReportMissingRequest(hosts=['bar'],
schedulers=None,
scheduler_id='id')
chairman.return_value.report_missing.assert_called_once_with(req)
self.assertFalse(chairman.return_value.report_resurrected.called)
# bar comes back
chairman.reset_mock()
bar_client.ping.side_effect = None
time_class.return_value = 200.0
health_checker._send_heartbeat()
chairman.return_value.report_resurrected.return_value = \
ReportResurrectedResponse(result=0)
health_checker._send_report()
req = ReportResurrectedRequest(hosts=['bar'],
schedulers=None,
scheduler_id='id')
self.assertFalse(chairman.return_value.report_missing.called)
chairman.return_value.report_resurrected.assert_called_once_with(req)
def test_config_change(self):
# Test chairman config change
chairman_callback1 = mock.MagicMock()
chairman_callback2 = mock.MagicMock()
chairman_server = [
ServerAddress("192.168.0.1", 8835),
ServerAddress("192.168.0.2", 8835),
]
self.agent.on_config_change(self.agent.CHAIRMAN, chairman_callback1)
self.agent.on_config_change(self.agent.CHAIRMAN, chairman_callback2)
provision = ProvisionRequest(chairman_server=chairman_server)
self.agent.update_config(provision)
chairman_callback1.assert_called_once_with(chairman_server)
chairman_callback2.assert_called_once_with(chairman_server)
self.assertFalse(self.agent.reboot_required)
# Test cpu_overcommit and memory_overcommit config change
cpu_callback = mock.MagicMock()
mem_callback = mock.MagicMock()
provision.cpu_overcommit = 5.0
provision.memory_overcommit = 6.0
self.agent.on_config_change(self.agent.CPU_OVERCOMMIT, cpu_callback)
self.agent.on_config_change(self.agent.MEMORY_OVERCOMMIT, mem_callback)
self.agent.update_config(provision)
cpu_callback.assert_called_once_with(5.0)
mem_callback.assert_called_once_with(6.0)
def _provision_host(self, datastore):
""" Provisions the agents on the remote hosts """
req = ProvisionRequest()
req.availability_zone = "test"
req.datastores = [datastore]
req.networks = ["VM Network"]
req.address = ServerAddress(host="localhost", port=8835)
req.chairman_server = [ServerAddress("localhost", 13000)]
req.memory_overcommit = 2.0
req.image_datastores = set(
[ImageDatastore(name=datastore, used_for_vms=True)])
res = self.agent_client.provision(req)
# This will trigger a restart if the agent config changes, which
# will happen the first time provision_hosts is called.
self.assertEqual(res.result, ProvisionResultCode.OK)
# If a restart is required subsequent calls will fail.
# This is an indirect way to determine if a restart is required.
host_config_request = Host.GetConfigRequest()
res = self.host_client.get_host_config(host_config_request)
if (res.result != GetConfigResultCode.OK):
# Sleep for 15 s for the agent to reboot and come back up
time.sleep(15)
def test_persistence(self):
"""
Test that we can process and persist config options.
"""
self.agent._parse_options([
"--chairman",
"h1:13000, h2:13000", "--memory-overcommit", "1.5", "--datastore",
["datastore1"], "--in-uwsim", "--config-path", self.agent_conf_dir,
"--utilization-transfer-ratio", "0.5"
])
self.assertEqual(
self.agent.chairman_list,
[ServerAddress("h1", 13000),
ServerAddress("h2", 13000)])
self.assertEqual(self.agent.memory_overcommit, 1.5)
self.assertEqual(self.agent.in_uwsim, True)
self.assertEqual(self.agent.utilization_transfer_ratio, 0.5)
self.agent._persist_config()
# Simulate an agent restart.
new_agent = AgentConfig(["--config-path", self.agent_conf_dir])
self.assertEqual(
new_agent.chairman_list,
[ServerAddress("h1", 13000),
ServerAddress("h2", 13000)])
self.assertEqual(new_agent.memory_overcommit, 1.5)
self.assertEqual(new_agent.in_uwsim, True)
self.assertEqual(self.agent.utilization_transfer_ratio, 0.5)
def test_reboot_required(self):
"""
Test that reboot required flag is set when all the required agent
parameters are set.
"""
self.agent._parse_options(["--config-path", self.agent_conf_dir])
# Check that reboot required is false until we set all the params
self.assertFalse(self.agent.reboot_required)
req = ProvisionRequest()
req.datastores = ["ds3", "ds4"]
req.stats_plugin_config = StatsPluginConfig()
req.stats_plugin_config.enabled = False
addr = ServerAddress(host="localhost", port=2345)
req.address = addr
self.agent.provision(req)
# Verify that the bootstrap is still false as zk config is not
# specified.
self.assertFalse(self.agent.bootstrap_ready)
self.assertTrue(self.agent.reboot_required)
req = ProvisionRequest()
req.datastores = ["ds3", "ds4"]
addr = ServerAddress(host="localhost", port=2345)
req.address = addr
self.agent.provision(req)
self.assertTrue(self.agent.reboot_required)
def test_basic(self):
servers = [ServerAddress("server1", 1234),
ServerAddress("server2", 1234)]
listenerA = Listener()
listenerB = Listener()
serverset = StaticServerSet(servers)
serverset.add_change_listener(listenerA)
serverset.add_change_listener(listenerB)
self.assertEqual(servers, listenerA.servers)
self.assertEqual(servers, listenerB.servers)
def _update_agent_invalid_config(self):
"""
Negative test case to update the agent with an invalid config
"""
req = ProvisionRequest()
req.availability_zone = "bootstrap_availability_zone_id"
req.datastores = ["bootstrap_datastore"]
req.networks = ["Bootstrap Network"]
addr = ServerAddress(host="foobar", port=8835)
req.address = addr
req.chairman_server = [ServerAddress("h1", 13000),
ServerAddress("h2", 13000)]
req.memory_overcommit = 0.5
res = self.control_client.provision(req)
self.assertEqual(res.result, ProvisionResultCode.INVALID_CONFIG)
def test_heartbeat(self, client_class, time_class):
"""Test that sequence number and timestamp get updated correctly
after sending heartbeat."""
client_class.side_effect = self.create_fake_client
bar_client = MagicMock()
baz_client = MagicMock()
self._clients["bar"] = bar_client
self._clients["baz"] = baz_client
children = {
"bar": ServerAddress("bar", 1234),
"baz": ServerAddress("baz", 1234)
}
# make sure things are initialized properly
time_class.return_value = 0.0
health_checker = HealthChecker("id", children, self.conf)
self.assertEquals(health_checker._seqnum, 0)
self.assertEquals(len(health_checker._last_update), 2)
self.assertEquals(health_checker._last_update["bar"], (0, 0.0))
self.assertEquals(health_checker._last_update["baz"], (0, 0.0))
# send a ping
time_class.return_value = 10.0
health_checker._send_heartbeat()
self.assertEquals(health_checker._seqnum, 1)
self.assertEquals(len(health_checker._last_update), 2)
self.assertEquals(health_checker._last_update["bar"], (1, 10.0))
self.assertEquals(health_checker._last_update["baz"], (1, 10.0))
# send another ping. ping to baz fails.
time_class.return_value = 20.0
baz_client.ping.side_effect = Exception()
health_checker._send_heartbeat()
self.assertEquals(health_checker._seqnum, 2)
self.assertEquals(len(health_checker._last_update), 2)
self.assertEquals(health_checker._last_update["bar"], (2, 20.0))
self.assertEquals(health_checker._last_update["baz"], (1, 10.0))
# send another ping. ping to bar fails.
time_class.return_value = 30.0
bar_client.ping.side_effect = Exception()
baz_client.ping.side_effect = None
health_checker._send_heartbeat()
self.assertEquals(health_checker._seqnum, 3)
self.assertEquals(len(health_checker._last_update), 2)
self.assertEquals(health_checker._last_update["bar"], (2, 20.0))
self.assertEquals(health_checker._last_update["baz"], (3, 30.0))
def configure(self, hosts):
"""Configure the leaf scheduler.
:param hosts: list of child hosts
:type hosts: list of str
"""
# Transfer children's constraints from list to set, so searching
# elements are more efficient.
self._hosts = []
for host in hosts:
self._hosts.append(ChildInfo.from_thrift(host))
self._coalesce_resources(self._hosts)
if self._health_checker:
self._health_checker.stop()
if self._enable_health_checker:
# initialize health checker with the new set of children.
agent_config = common.services.get(ServiceName.AGENT_CONFIG)
children = dict((host.id, ServerAddress(host.address, host.port))
for host in self._hosts)
self._health_checker = HealthChecker(self._scheduler_id, children,
agent_config)
self._health_checker.start()
self._configured = ConfigStates.INITIALIZED
def test_host_config_after_provision(self):
"""
Test if the agent returns the correct HostConfig
after being provisioned
"""
host_config_request = Host.GetConfigRequest()
res = self.host_client.get_host_config(host_config_request)
self.assertEqual(res.result, GetConfigResultCode.OK)
hostConfig = res.hostConfig
datastores = [ds.name for ds in hostConfig.datastores]
containsDs = [
ds for ds in self.get_all_datastores() if ds in datastores
]
self.assertEqual(containsDs, self.get_all_datastores())
networks = [net.id for net in hostConfig.networks]
self.assertEqual(networks, self.vim_client.get_networks())
self.assertEqual(hostConfig.address,
ServerAddress(host=self.server, port=8835))
self.assertTrue(hostConfig.management_only)
# get_host_config reports datastore id for image datastore even if it
# was provisioned with a datastore name.
image_datastore_name = self.get_image_datastore()
image_datastore_id = None
for ds in hostConfig.datastores:
if ds.name == image_datastore_name:
image_datastore_id = ds.id
self.assertEqual(
list(hostConfig.image_datastore_ids)[0], image_datastore_id)
def _parse_chairman_list(self, chairman_list):
"""
Converts a list of chairman with port config into a list of
ServerAddress.
Chairman list is persisted as a list of "ip:port"
:param chairman_list: The list of chairman as a comma separated string.
:rtype list of chairman service addresses of type ServerAddress
"""
if not chairman_list:
return []
server_list = []
for server in chairman_list:
try:
host, port = server.split(":")
server_list.append(ServerAddress(host=host, port=int(port)))
except ValueError:
self._logger.warning(
"Failed to parse server %s, Invalid delemiter" % server)
pass
except AttributeError:
self._logger.warning("Failed to parse chairman server %s" %
server)
pass
return server_list
def test_place(self):
handler = HostHandler(MagicMock())
score = Score(100, 100)
place_list = [MagicMock()]
address = ServerAddress(host="localhost", port=1234)
request = PlaceRequest(resource=Resource(self._sample_vm(), []))
handler.hypervisor.placement_manager.place.return_value = (score,
place_list)
response = handler.place(request)
assert_that(response.result, is_(PlaceResultCode.OK))
assert_that(response.score, is_(score))
assert_that(response.placementList.placements,
is_([item.to_thrift() for item in place_list]))
assert_that(response.address, is_(address))
common.services.get(ServiceName.MODE).set_mode(
MODE.ENTERING_MAINTENANCE)
response = handler.place(request)
assert_that(response.result, is_(PlaceResultCode.INVALID_STATE))
common.services.get(ServiceName.MODE).set_mode(MODE.MAINTENANCE)
response = handler.place(request)
assert_that(response.result, is_(PlaceResultCode.INVALID_STATE))
def provision_hosts(self,
mem_overcommit=2.0,
datastores=None,
used_for_vms=True,
image_ds=None,
host_id=None,
deployment_id="test-deployment"):
""" Provisions the agents on the remote hosts """
if datastores is None:
datastores = self.get_all_datastores()
image_datastore = self.get_image_datastore()
elif image_ds:
image_datastore = image_ds
else:
image_datastore = datastores[0]
req = ProvisionRequest()
req.datastores = datastores
req.address = ServerAddress(host=self.server, port=8835)
req.memory_overcommit = mem_overcommit
req.image_datastore_info = ImageDatastore(name=image_datastore,
used_for_vms=used_for_vms)
req.image_datastores = set([req.image_datastore_info])
req.management_only = True
req.auth_enabled = False
if host_id:
req.host_id = host_id
else:
req.host_id = self.host_id
if deployment_id:
req.deployment_id = deployment_id
else:
req.deployment_id = self.deployment_id
res = self.control_client.provision(req)
# This will trigger a restart if the agent config changes, which
# will happen the first time provision_hosts is called.
self.assertEqual(res.result, ProvisionResultCode.OK)
# Wait for up to 60 seconds for the agent to reboot.
count = 0
while count < 60:
try:
res = self.control_client.get_agent_status()
if res.status == AgentStatusCode.OK:
# Agent is up
return
except:
logger.exception("Can't connect to agent")
count += 1
time.sleep(1)
# Reconnect the clients
self._close_agent_connections()
self.client_connections()
self.fail("Cannot connect to agent %s after provisioning" %
self.server)
return host_id
def test_property_accessors(self):
self.agent._parse_options([
"--config-path", self.agent_conf_dir, "--availability-zone",
"test", "--hostname", "localhost", "--port", "1234",
"--datastores", "ds1, ds2", "--vm-network", "VM Network",
"--wait-timeout", "5", "--chairman", "h1:1300, h2:1300"
])
assert_that(self.agent.availability_zone, equal_to("test"))
assert_that(self.agent.hostname, equal_to("localhost"))
assert_that(self.agent.host_port, equal_to(1234))
assert_that(self.agent.datastores, equal_to(["ds1", "ds2"]))
assert_that(self.agent.networks, equal_to(["VM Network"]))
assert_that(self.agent.wait_timeout, equal_to(5))
assert_that(
self.agent.chairman_list,
equal_to([ServerAddress("h1", 1300),
ServerAddress("h2", 1300)]))
def parse_address(value):
"""Deserialize the given thrift encoded string into a address tuple.
:type value: str
:rtype: tuple
"""
address = ServerAddress()
deserialize(address, value)
return address.host, address.port
def create_address(host, port):
"""Serialize the given address to thrift ServerAddress.
:type host: str
:type port: int
:rtype: str
"""
address = ServerAddress(host, port)
return serialize(address)
def get_register_host_request(host, port, agent_id, networks, datastores,
image_datastore, availability_zone,
management_only=False):
host_config = HostConfig(agent_id=agent_id, datastores=datastores,
address=ServerAddress(host, port=port),
networks=networks,
availability_zone=availability_zone,
image_datastore_ids=set([image_datastore]),
management_only=management_only)
return RegisterHostRequest(agent_id, host_config)
def _update_agent_config(self):
"""
Update the agent config using the bootstrap interface.
Verifies that thrift requests after a config update return back
SYSTEM_ERROR and the agent is stopped.
:return the request we used to configure the host with.
"""
req = ProvisionRequest()
req.availability_zone = "bootstrap_availability_zone_id"
req.datastores = ["bootstrap_datastore"]
req.networks = ["Bootstrap Network"]
addr = ServerAddress(host="foobar", port=8835)
req.address = addr
req.chairman_server = [ServerAddress("h1", 13000),
ServerAddress("h2", 13000)]
req.memory_overcommit = 2.0
res = self.control_client.provision(req)
self.assertEqual(res.result, ProvisionResultCode.OK)
# Now check that the agent went down and all requests fail until the
# agent restarts.
# Use a time greater than the restart poll thread.
remaining_sleep_time = 15
sleep_time = 0.5
agent_restarted = False
while 0 < remaining_sleep_time:
try:
res = self.control_client.get_agent_status()
# Verify that the response is restarting
self.assertEqual(res.status, AgentStatusCode.RESTARTING)
time.sleep(sleep_time)
remaining_sleep_time -= sleep_time
except TTransport.TTransportException:
agent_restarted = True
break
except:
logger.debug("Caught exception, assuming restart: ",
exc_info=True)
agent_restarted = True
break
self.assertTrue(agent_restarted)
return req
def _update_agent_invalid_config(self):
"""
Negative test case to update the agent with an invalid config
"""
req = ProvisionRequest()
req.datastores = ["bootstrap_datastore"]
addr = ServerAddress(host="foobar", port=8835)
req.address = addr
req.memory_overcommit = 0.5
res = self.control_client.provision(req)
self.assertEqual(res.result, ProvisionResultCode.INVALID_CONFIG)
def test_chairman_parsing(self):
"""Tests that the parsing logic for chairman works"""
str_1 = "10.10.10.1:13000"
str_2 = "10.10.10.2:13000"
str_3 = "10.10.10.3:13000"
invalid_str = "10.10.10.3;13000"
srv_1 = ServerAddress(host="10.10.10.1", port=13000)
srv_2 = ServerAddress(host="10.10.10.2", port=13000)
srv_3 = ServerAddress(host="10.10.10.3", port=13000)
# Test 1 check that we can parse a list of chairman services.
chairman_str = [str_1, str_2, str_3]
chairman_list = self.agent._parse_chairman_list(chairman_str)
self.assertEqual(len(chairman_list), 3)
self.assertEqual([srv_1, srv_2, srv_3], chairman_list)
# Test 2 check that we can parse single chairman
chairman_str = str_1
chairman_list = self.agent._parse_chairman_list([chairman_str])
self.assertEqual(len(chairman_list), 1)
self.assertEqual([srv_1], chairman_list)
# Test invalid input string - 2; one of the delimiters are invalid
chairman_str = [str_1, str_2, invalid_str, str_3]
chairman_list = self.agent._parse_chairman_list(chairman_str)
self.assertEqual(len(chairman_list), 3)
self.assertEqual([srv_1, srv_2, srv_3], chairman_list)
# Test conversion from server address to string.
chairman_str = self.agent._parse_chairman_server_address(
[srv_1, srv_2, srv_3])
self.assertEqual([str_1, str_2, str_3], chairman_str)
# Handle empty list
chairman_str = self.agent._parse_chairman_server_address([])
self.assertEqual([], chairman_str)
# Handle None
chairman_str = self.agent._parse_chairman_server_address(None)
self.assertEqual([], chairman_str)
def get_register_host_request(self, port=8080):
"""
Generates a random register host request
which has same datastore and same availability zone
"""
host_id = str(uuid.uuid4())
if not hasattr(self, "image_datastore"):
self.image_datastore = str(uuid.uuid4())
datastores = [Datastore(self.image_datastore)]
networks = [Network("nw1", [NetworkType.VM])]
host_config = HostConfig(agent_id=host_id,
datastores=datastores,
address=ServerAddress("127.0.0.1", port=port),
networks=networks)
host_config.availability_zone = "foo"
host_config.image_datastore_ids = set(self.image_datastore)
return RegisterHostRequest(host_id, host_config)
def test_slow_heartbeater(self, client_class, time_class, chairman):
"""Don't report missing if the current sequence number is equal to
the sequence number of the last successful ping.
"""
client_class.side_effect = self.create_fake_client
bar_client = MagicMock()
self._clients["bar"] = bar_client
children = {"bar": ServerAddress("bar", 1234)}
# send a ping. bar should get reported resurrected.
health_checker = HealthChecker("id", children, self.conf)
time_class.return_value = 0.0
chairman.return_value.report_resurrected.return_value = \
ReportResurrectedResponse(result=0)
health_checker._send_heartbeat()
health_checker._send_report()
req = ReportResurrectedRequest(hosts=['bar'],
schedulers=None,
scheduler_id='id')
chairman.return_value.report_resurrected.assert_called_once_with(req)
self.assertFalse(chairman.return_value.report_missing.called)
self.assertEquals(health_checker._resurrected_children, set(["bar"]))
self.assertEquals(health_checker._missing_children, set())
# call _send_report() again after 100 seconds. bar shouldn't get
# reported missing since the heartbeater hasn't send another ping.
time_class.return_value = 100.0
chairman.reset_mock()
health_checker._send_report()
self.assertFalse(chairman.return_value.report_missing.called)
self.assertFalse(chairman.return_value.report_resurrected.called)
# ping fails. now the reporter should report bar missing.
bar_client.ping.side_effect = Exception()
chairman.return_value.report_missing.return_value = \
ReportMissingResponse(result=0)
health_checker._send_heartbeat()
health_checker._send_report()
req = ReportMissingRequest(hosts=['bar'],
schedulers=None,
scheduler_id='id')
chairman.return_value.report_missing.assert_called_once_with(req)
self.assertFalse(chairman.return_value.report_resurrected.called)
def test_send_image_to_host(self):
image_id = new_id() + "_test_xfer_image"
image_id_2 = "%s_xfered" % image_id
dst_image, _ = self._create_test_image(image_id)
datastore = self._find_configured_datastore_in_host_config()
transfer_image_request = TransferImageRequest(
source_image_id=image_id,
source_datastore_id=datastore.id,
destination_host=ServerAddress(host=self.server, port=8835),
destination_datastore_id=datastore.id,
destination_image_id=image_id_2)
res = self.host_client.transfer_image(transfer_image_request)
self.assertEqual(res.result, TransferImageResultCode.OK)
# clean up images created in test
self._delete_image(dst_image)
xfered_image = Image(image_id_2, datastore)
self._delete_image(xfered_image)
def setUp(self):
self.hostname = "localhost"
self.host_port = 1234
self.availability_zone_id = "test"
self.host_addr = ServerAddress(self.hostname, self.host_port)
self.chairman_list = []
self.agent_id = "foo"
self.host_config = HostConfig(self.agent_id, self.availability_zone_id,
[Datastore("bar")], self.host_addr,
[Network("nw1")])
self.registrant = ChairmanRegistrant(self.chairman_list)
host_handler = MagicMock()
host_handler.get_host_config_no_logging.return_value = \
GetConfigResponse(hostConfig=self.host_config)
common.services.register(Host.Iface, host_handler)
self.request = RegisterHostRequest("foo", self.host_config)
self.state_file = tempfile.mktemp()
common.services.register(ServiceName.MODE,
Mode(State(self.state_file)))
def test_chairman_failure(self, client_class, time_class, chairman):
"""Reporter should retry reporting if chairman fails."""
client_class.side_effect = self.create_fake_client
bar_client = MagicMock()
self._clients["bar"] = bar_client
children = {"bar": ServerAddress("bar", 1234)}
# report_resurrected returns a non-zero value
health_checker = HealthChecker("id", children, self.conf)
time_class.return_value = 0.0
health_checker._send_heartbeat()
chairman.return_value.report_resurrected.return_value = \
ReportResurrectedResponse(result=1)
health_checker._send_report()
req = ReportResurrectedRequest(hosts=['bar'],
schedulers=None,
scheduler_id='id')
chairman.return_value.report_resurrected.assert_called_once_with(req)
self.assertFalse(chairman.return_value.report_missing.called)
# report_resurrected throws an exception
chairman.reset_mock()
chairman.return_value.report_resurrected.side_effect = Exception()
health_checker._send_report()
chairman.return_value.report_resurrected.assert_called_once_with(req)
self.assertFalse(chairman.return_value.report_missing.called)
# report succeeds
chairman.reset_mock()
chairman.return_value.report_resurrected.side_effect = None
chairman.return_value.report_resurrected.return_value = \
ReportResurrectedResponse(result=0)
health_checker._send_report()
chairman.return_value.report_resurrected.assert_called_once_with(req)
self.assertFalse(chairman.return_value.report_missing.called)
# report doesn't get called anymore.
chairman.reset_mock()
health_checker._send_report()
self.assertFalse(chairman.return_value.report_resurrected.called)
self.assertFalse(chairman.return_value.report_missing.called)
def test_agent_config_update(self):
""" Test that updating the config using the RPC struct works """
self.agent._parse_options([
"--config-path", self.agent_conf_dir, "--availability-zone",
"test", "--hostname", "localhost", "--port", "1234",
"--datastores", "ds1, ds2"
])
expected_image_ds = [{"name": "ds3", "used_for_vms": True}]
# Without chairman config we can't be provision ready
self.assertFalse(self.agent.bootstrap_ready)
self.assertTrue(self.agent.provision_ready)
self.assertFalse(self.agent.reboot_required)
req = ProvisionRequest()
req.availability_zone = "test1"
req.datastores = ["ds3", "ds4"]
req.networks = ["Public"]
req.memory_overcommit = 1.5
req.image_datastores = set([ImageDatastore("ds3", True)])
addr = ServerAddress(host="localhost", port=2345)
req.chairman_server = [
ServerAddress("h1", 13000),
ServerAddress("h2", 13000)
]
req.address = addr
req.host_id = "host1"
self.agent.update_config(req)
assert_that(self.agent.availability_zone, equal_to("test1"))
assert_that(self.agent.hostname, equal_to("localhost"))
assert_that(self.agent.host_port, equal_to(2345))
assert_that(self.agent.datastores, equal_to(["ds3", "ds4"]))
assert_that(self.agent.networks, equal_to(["Public"]))
assert_that(
self.agent.chairman_list,
equal_to([ServerAddress("h1", 13000),
ServerAddress("h2", 13000)]))
assert_that(self.agent.memory_overcommit, equal_to(1.5))
assert_that(self.agent.image_datastores, equal_to(expected_image_ds))
assert_that(self.agent.host_id, equal_to("host1"))
self.assertTrue(self.agent.bootstrap_ready)
self.assertTrue(self.agent.reboot_required)
# Verify we are able to unset all the configuration.
req = ProvisionRequest()
self.agent.update_config(req)
assert_that(self.agent.availability_zone, equal_to(None))
assert_that(self.agent.hostname, equal_to(None))
assert_that(self.agent.host_port, equal_to(8835))
assert_that(self.agent.datastores, equal_to([]))
assert_that(self.agent.networks, equal_to([]))
assert_that(self.agent.chairman_list, equal_to([]))
# Unsetting memory overcommit should set it to the default value.
self.assertEqual(self.agent.memory_overcommit, 1.0)
self.assertFalse(self.agent.bootstrap_ready)
assert_that(self.agent.image_datastores, equal_to(expected_image_ds))
assert_that(self.agent.host_id, equal_to(None))
# Test an invalid update and verify the update doesn't have any side
# effects.
req = ProvisionRequest()
req.availability_zone = "test1"
req.datastores = ["ds3", "ds4"]
req.networks = ["Public"]
req.memory_overcommit = 0.5
addr = ServerAddress(host="localhost", port=2345)
req.chairman_server = [
ServerAddress("h1", 13000),
ServerAddress("h2", 13000)
]
req.address = addr
# Verify an exception is raised.
self.assertRaises(InvalidConfig, self.agent.update_config, req)
assert_that(self.agent.availability_zone, equal_to(None))
assert_that(self.agent.hostname, equal_to(None))
assert_that(self.agent.host_port, equal_to(8835))
assert_that(self.agent.datastores, equal_to([]))
assert_that(self.agent.networks, equal_to([]))
assert_that(self.agent.chairman_list, equal_to([]))
self.assertFalse(self.agent.bootstrap_ready)
self.assertEqual(self.agent.memory_overcommit, 1.0)
def test_agent_config_update(self):
""" Test that updating the config using the RPC struct works """
self.agent._parse_options(["--config-path", self.agent_conf_dir,
"--hostname", "localhost",
"--port", "1234",
"--datastores", "ds1, ds2"])
expected_image_ds = [{"name": "ds3", "used_for_vms": True}]
self.assertFalse(self.agent.bootstrap_ready)
self.assertTrue(self.agent.provision_ready)
self.assertFalse(self.agent.reboot_required)
req = ProvisionRequest()
req.datastores = ["ds3", "ds4"]
req.memory_overcommit = 1.5
req.image_datastores = set([ImageDatastore("ds3", True)])
addr = ServerAddress(host="localhost", port=2345)
req.address = addr
stats_plugin_config = StatsPluginConfig(
stats_store_endpoint="10.0.0.100", stats_store_port=8081, stats_enabled=True)
req.stats_plugin_config = stats_plugin_config
req.host_id = "host1"
req.deployment_id = "deployment1"
self.agent.provision(req)
assert_that(self.agent.stats_store_endpoint, equal_to("10.0.0.100"))
assert_that(self.agent.stats_store_port, equal_to(8081))
assert_that(self.agent.stats_enabled, equal_to(True))
assert_that(self.agent.hostname, equal_to("localhost"))
assert_that(self.agent.host_port, equal_to(2345))
assert_that(self.agent.datastores, equal_to(["ds3", "ds4"]))
assert_that(self.agent.memory_overcommit,
equal_to(1.5))
assert_that(self.agent.image_datastores, equal_to(expected_image_ds))
assert_that(self.agent.host_id, equal_to("host1"))
assert_that(self.agent.deployment_id, equal_to("deployment1"))
self.assertTrue(self.agent.bootstrap_ready)
self.assertTrue(self.agent.reboot_required)
# Verify we are able to unset all the configuration.
req = ProvisionRequest()
self.agent.provision(req)
assert_that(self.agent.hostname, equal_to(None))
assert_that(self.agent.host_port, equal_to(8835))
assert_that(self.agent.datastores, equal_to([]))
# Unsetting memory overcommit should set it to the default value.
self.assertEqual(self.agent.memory_overcommit, 1.0)
self.assertFalse(self.agent.bootstrap_ready)
assert_that(self.agent.image_datastores, equal_to(expected_image_ds))
assert_that(self.agent.host_id, equal_to(None))
# Test an invalid update and verify the update doesn't have any side
# effects.
req = ProvisionRequest()
req.datastores = ["ds3", "ds4"]
req.memory_overcommit = 0.5
addr = ServerAddress(host="localhost", port=2345)
req.address = addr
# Verify an exception is raised.
self.assertRaises(InvalidConfig, self.agent.provision, req)
assert_that(self.agent.hostname, equal_to(None))
assert_that(self.agent.host_port, equal_to(8835))
assert_that(self.agent.datastores, equal_to([]))
self.assertFalse(self.agent.bootstrap_ready)
self.assertEqual(self.agent.memory_overcommit, 1.0)
def on_server_added(self, address):
self.servers.append(ServerAddress(address[0], address[1]))
def test_agent_config_set_availability_zone(self):
""" Test that updating the config using the RPC struct works """
self.agent._parse_options([
"--config-path", self.agent_conf_dir, "--availability-zone",
"test", "--hostname", "localhost", "--port", "1234",
"--datastores", "ds1, ds2"
])
expected_image_ds = [{"name": "ds3", "used_for_vms": True}]
# Without chairman config we can't be ready
self.assertFalse(self.agent.bootstrap_ready)
self.assertTrue(self.agent.provision_ready)
self.assertFalse(self.agent.reboot_required)
req = ProvisionRequest()
req.availability_zone = "test1"
req.datastores = ["ds3", "ds4"]
req.networks = ["Public"]
req.memory_overcommit = 1.5
req.image_datastores = set([ImageDatastore("ds3", True)])
addr = ServerAddress(host="localhost", port=2345)
req.chairman_server = [
ServerAddress("h1", 13000),
ServerAddress("h2", 13000)
]
req.address = addr
req.host_id = "host1"
self.agent.update_config(req)
assert_that(self.agent.availability_zone, equal_to("test1"))
assert_that(self.agent.hostname, equal_to("localhost"))
assert_that(self.agent.host_port, equal_to(2345))
assert_that(self.agent.datastores, equal_to(["ds3", "ds4"]))
assert_that(self.agent.networks, equal_to(["Public"]))
assert_that(
self.agent.chairman_list,
equal_to([ServerAddress("h1", 13000),
ServerAddress("h2", 13000)]))
assert_that(self.agent.memory_overcommit, equal_to(1.5))
assert_that(self.agent.image_datastores, equal_to(expected_image_ds))
assert_that(self.agent.host_id, equal_to("host1"))
self.assertTrue(self.agent.bootstrap_ready)
self.assertTrue(self.agent.reboot_required)
# Verify we are able to update availability zone only.
setZone = SetAvailabilityZoneRequest()
setZone.availability_zone = "test2"
self.agent.set_availability_zone(setZone)
assert_that(self.agent.availability_zone, equal_to("test2"))
assert_that(self.agent.hostname, equal_to("localhost"))
assert_that(self.agent.host_port, equal_to(2345))
assert_that(self.agent.datastores, equal_to(["ds3", "ds4"]))
assert_that(self.agent.networks, equal_to(["Public"]))
assert_that(
self.agent.chairman_list,
equal_to([ServerAddress("h1", 13000),
ServerAddress("h2", 13000)]))
assert_that(self.agent.memory_overcommit, equal_to(1.5))
assert_that(self.agent.image_datastores, equal_to(expected_image_ds))
assert_that(self.agent.host_id, equal_to("host1"))
self.assertTrue(self.agent.bootstrap_ready)
self.assertTrue(self.agent.reboot_required)
