def test_unregister_host(self):
"""unregister host after host being registered or missing
"""
h_id_config = {}
# Register two hosts with the chairman.
reg_host_req_1 = self.get_register_host_request()
server_address = reg_host_req_1.config.address.host
server_port = reg_host_req_1.config.address.port
h_id_config[reg_host_req_1.id] = reg_host_req_1.config
host_handler = AgentHandler(2)
self.thrift_server = ThriftServer(server_address, server_port,
host_handler)
self.thrift_server.start_server()
rc = self.chairman_client.register_host(reg_host_req_1)
self.assertEqual(rc.result, RegisterHostResultCode.OK)
reg_host_req_2 = self.get_register_host_request()
h_id_config[reg_host_req_2.id] = reg_host_req_2.config
rc = self.chairman_client.register_host(reg_host_req_2)
self.assertEqual(rc.result, RegisterHostResultCode.OK)
# verify that all the agents received configurations
host_handler.received_all.wait(30)
assert_that(len(host_handler.configs), is_(len(h_id_config)))
client = self._get_nonchroot_client()
client.start()
# Verify that the host has registered with chairman
host_registered = wait_for(EventType.CREATED, HOSTS_PREFIX,
h_id_config.keys()[0], client)
self.assertTrue(host_registered)
host_registered = wait_for(EventType.CREATED, HOSTS_PREFIX,
h_id_config.keys()[1], client)
self.assertTrue(host_registered)
# validate /hosts
read_hosts = client.get_children(HOSTS_PREFIX)
self.assertEqual(len(read_hosts), len(h_id_config))
for h in read_hosts:
path = HOSTS_PREFIX + "/" + h
host_config = extract_node_data(client, path, HostConfig)
self.assertTrue(host_config in h_id_config.values())
# validate only one leaf scheduler for same
# availability_zone/datastore agents
roles_registered = wait_for(EventType.CREATED, ROLES_PREFIX, "",
client, "get_children")
roles_hosts = client.get_children(ROLES_PREFIX)
self.assertTrue(roles_registered)
self.assertEqual(len(roles_hosts), 1)
# preserve the host id that owns the leaf scheduler
leaf_scheduler_host_id = None
# validate leaf scheduler has 2 hosts
r_id = roles_hosts[0]
leaf_scheduler_host_id = r_id
path = ROLES_PREFIX + "/" + r_id
roles = extract_node_data(client, path, Roles)
scheduler_role = roles.schedulers[0]
self.assertEqual(len(scheduler_role.hosts), 2)
self.assertTrue(h_id_config.keys()[0] in scheduler_role.hosts)
self.assertTrue(h_id_config.keys()[1] in scheduler_role.hosts)
# normalize from unicode to str
leaf_scheduler_host_id = \
normalize('NFKD', leaf_scheduler_host_id).encode('ascii', 'ignore')
# validate report missing
del h_id_config[leaf_scheduler_host_id]
missing_host_id = h_id_config.keys()[0]
missing_host_list = h_id_config.keys()
scheduler_id = host_handler.configs[missing_host_id].scheduler
missing_req = ReportMissingRequest(scheduler_id, None,
missing_host_list)
m_hosts = missing_req.hosts
rc = self.chairman_client.report_missing(missing_req)
self.assertEqual(rc.result, ReportMissingResultCode.OK)
# validate /missing
host_missing = wait_for(EventType.CREATED, MISSING_PREFIX,
missing_host_id, client)
self.assertTrue(host_missing)
missing_hosts = client.get_children(MISSING_PREFIX)
self.assertEqual(len(missing_hosts), len(m_hosts))
for host in missing_hosts:
self.assertTrue(host in m_hosts)
# expecting role changed
role_changed_event = async_wait_for(EventType.CHANGED, ROLES_PREFIX,
leaf_scheduler_host_id, client)
# unregister missing host
unreg_req = UnregisterHostRequest(missing_host_id)
rc = self.chairman_client.unregister_host(unreg_req)
self.assertEqual(rc.result, UnregisterHostResultCode.OK)
role_changed_event.wait(20)
self.assertTrue(role_changed_event.isSet())
# Validate /missing after unregister host
missing_hosts = client.get_children(MISSING_PREFIX)
self.assertEqual(len(missing_hosts), 0)
# validate leaf scheduler's host number after unregistered a host
roles_hosts = client.get_children(ROLES_PREFIX)
r_id = roles_hosts[0]
path = ROLES_PREFIX + "/" + r_id
roles = extract_node_data(client, path, Roles)
scheduler_role = roles.schedulers[0]
self.assertEqual(len(scheduler_role.hosts), 1)
self.assertTrue(r_id in scheduler_role.hosts)
self.assertTrue(missing_host_id not in scheduler_role.hosts)
# expecting role being deleted
role_changed_event = async_wait_for(EventType.DELETED, ROLES_PREFIX,
leaf_scheduler_host_id, client)
# unregister host that owns leaf scheduler
unreg_req = UnregisterHostRequest(leaf_scheduler_host_id)
rc = self.chairman_client.unregister_host(unreg_req)
self.assertEqual(rc.result, UnregisterHostResultCode.OK)
role_changed_event.wait(20)
self.assertTrue(role_changed_event.isSet())
# Validate the state persisted in zk.
read_hosts = client.get_children(HOSTS_PREFIX)
self.assertEqual(len(read_hosts), 0)
client.stop()
def test_get_status(self):
chairman_client_leader = self.chairman_client
# starts 2 more chairman instances
host = '127.0.0.1'
port_1 = 13001
port_2 = 13002
self.runtime.start_chairman(host, port_1)
self.runtime.start_chairman(host, port_2)
(transport_1, chairman_client_non_leader_1) = \
create_chairman_client(host, port_1)
(transport_2, chairman_client_non_leader_2) = \
create_chairman_client(host, port_2)
self.transports.append(transport_1)
self.transports.append(transport_2)
h_id_config = {}
# Register two hosts with the chairman leader.
reg_host_req_1 = self.get_register_host_request()
server_address = reg_host_req_1.config.address.host
server_port = reg_host_req_1.config.address.port
h_id_config[reg_host_req_1.id] = reg_host_req_1.config
host_handler = AgentHandler(2)
self.thrift_server = ThriftServer(server_address, server_port,
host_handler)
self.thrift_server.start_server()
rc = chairman_client_leader.register_host(reg_host_req_1)
self.assertEqual(rc.result, RegisterHostResultCode.OK)
reg_host_req_2 = self.get_register_host_request()
h_id_config[reg_host_req_2.id] = reg_host_req_2.config
rc = self.chairman_client.register_host(reg_host_req_2)
self.assertEqual(rc.result, RegisterHostResultCode.OK)
# verify that all the agents received configurations
host_handler.received_all.wait(20)
assert_that(len(host_handler.configs), is_(len(h_id_config)))
# verify chairman leader is in READY status
get_status_request = GetStatusRequest()
rc = chairman_client_leader.get_status(get_status_request)
self.assertEqual(rc.type, StatusType.READY)
# verify the second chairman which is not leader is in READY status
# while it notices that there is a leader exist
rc = chairman_client_non_leader_1.get_status(get_status_request)
self.assertEqual(rc.type, StatusType.READY)
# verify the third chairman which is not leader is in READY status
# while it notices that there is a leader exist
rc = chairman_client_non_leader_2.get_status(get_status_request)
self.assertEqual(rc.type, StatusType.READY)
client = self._get_nonchroot_client()
client.start()
read_chairman_leader = client.get_children(CHAIRMAN_SERVICE)[0]
# normalize from unicode to str
read_chairman_leader = \
normalize('NFKD', read_chairman_leader).encode('ascii', 'ignore')
# expecting chairman leader being deleted
leader_deleted_event = async_wait_for(EventType.DELETED,
CHAIRMAN_SERVICE,
read_chairman_leader, client)
# deleting chairman leader from service
client.delete(CHAIRMAN_SERVICE + "/" + read_chairman_leader)
leader_deleted_event.wait(20)
self.assertTrue(leader_deleted_event.isSet())
def wait_for_status(chairman_client, status):
retries = 0
while (retries < 10):
try:
rc = chairman_client.get_status(get_status_request)
if rc.type != status:
break
except:
logger.exception("get_status() failed")
retries += 1
time.sleep(1)
return rc
