def test_sync_grid(self):
member_mgr = member.GridMemberManager(self.test_grid_config)
member_mgr.sync_grid()
grids = dbi.get_grids(self.ctx.session)
self.assertEqual(1, len(grids))
self.assertEqual(self.test_grid_config.grid_id, grids[0]['grid_id'])
self.assertEqual(self.test_grid_config.grid_name,
grids[0]['grid_name'])
expected_grid_connection = {
"wapi_version": self.test_grid_config.wapi_version,
"ssl_verify": self.test_grid_config.ssl_verify,
"http_pool_connections":
self.test_grid_config.http_pool_connections,
"http_pool_maxsize": self.test_grid_config.http_pool_maxsize,
"http_request_timeout":
self.test_grid_config.http_request_timeout,
"admin_user": {"name": self.test_grid_config.admin_user_name,
"password": self.test_grid_config.admin_password}
}
actual_grid_connection = jsonutils.loads(grids[0]['grid_connection'])
self.assertEqual(expected_grid_connection, actual_grid_connection)
self.assertEqual('ON', grids[0]['grid_status'])
# change active grid to "Test Grid 2"
new_active_grid_config = grid.GridConfiguration(self.ctx)
new_active_grid_config.gm_connector = mock.Mock()
new_active_grid_config.grid_id = 200
new_active_grid_config.grid_name = "Test Grid 2"
new_active_grid_config.grid_master_host = '192.168.1.8'
new_active_grid_config.admin_user_name = 'admin'
new_active_grid_config.admin_password = '******'
new_active_grid_config.wapi_version = '1.4.2'
member_mgr = member.GridMemberManager(new_active_grid_config)
member_mgr.sync_grid()
grids = dbi.get_grids(self.ctx.session)
self.assertEqual(2, len(grids))
self.assertEqual(self.test_grid_config.grid_id, grids[0]['grid_id'])
self.assertEqual('OFF', grids[0]['grid_status'])
self.assertEqual(new_active_grid_config.grid_id, grids[1]['grid_id'])
self.assertEqual(new_active_grid_config.grid_name,
grids[1]['grid_name'])
expected_grid_connection = {
"wapi_version": new_active_grid_config.wapi_version,
"ssl_verify": new_active_grid_config.ssl_verify,
"http_pool_connections":
new_active_grid_config.http_pool_connections,
"http_pool_maxsize": new_active_grid_config.http_pool_maxsize,
"http_request_timeout":
new_active_grid_config.http_request_timeout,
"admin_user": {"name": new_active_grid_config.admin_user_name,
"password": new_active_grid_config.admin_password}
}
actual_grid_connection = jsonutils.loads(grids[1]['grid_connection'])
self.assertEqual(expected_grid_connection, actual_grid_connection)
self.assertEqual('ON', grids[1]['grid_status'])
def test_db_records_to_json(self):
grid_1_id = 100
grid_2_id = 200
dbi.add_grid(self.ctx.session, grid_1_id, 'test grid 1',
'{"wapi_version": "2.0",'
'"wapi_admin_user": '******'{ "name": "admin", "password": "******" }}',
'ON',
'gm-id-1')
dbi.add_grid(self.ctx.session, grid_2_id, 'test grid 2', '{}', 'OFF',
'gm-id-2')
grids = dbi.get_grids(self.ctx.session)
json = utils.db_records_to_json(grids)
self.assertEqual('test grid 1', json[0]["grid_name"])
self.assertEqual('test grid 2', json[1]["grid_name"])
json_string = json[0]["grid_connection"]
grid_connection_json = jsonutils.loads(json_string)
self.assertIsInstance(json_string, six.string_types)
self.assertIsInstance(grid_connection_json, dict)
self.assertEqual('2.0', grid_connection_json['wapi_version'])
self.assertEqual('admin',
grid_connection_json['wapi_admin_user']['name'])
grid_connection = utils.json_to_obj('grid_connection',
grid_connection_json)
self.assertEqual('2.0', grid_connection.wapi_version)
self.assertEqual('admin', grid_connection.wapi_admin_user.name)
self.assertEqual('{}', json[1]["grid_connection"])
self.assertEqual({}, jsonutils.loads(json[1]["grid_connection"]))
def sync_grid(self):
"""Synchronize an active grid.
Only one active grid should be kept where grid_status is set to 'ON'.
"""
session = self._context.session
grid_connection = self._grid_config.get_grid_connection()
grid_connection_json = jsonutils.dumps(grid_connection)
db_grids = dbi.get_grids(session)
db_grid_ids = utils.get_values_from_records('grid_id', db_grids)
# update the existing grid or add new grid
if self._grid_config.grid_id in db_grid_ids:
dbi.update_grid(session, self._grid_config.grid_id,
self._grid_config.grid_name, grid_connection_json,
const.GRID_STATUS_ON)
else:
dbi.add_grid(session, self._grid_config.grid_id,
self._grid_config.grid_name, grid_connection_json,
const.GRID_STATUS_ON, utils.get_hash())
# deleting grids are delicate operation so we won't allow it
# but we will set grid status to OFF to unused grids.
persisted_set = set(db_grid_ids)
disable_set = persisted_set.difference([self._grid_config.grid_id])
disabling_grid_ids = list(disable_set)
for grid_id in disabling_grid_ids:
dbi.update_grid(session,
grid_id,
grid_status=const.GRID_STATUS_OFF)
session.flush()
def test_get_values_from_records(self):
grid_1_id = 100
grid_2_id = 200
dbi.add_grid(self.ctx.session, grid_1_id, 'test grid 1', '{}', 'ON',
'gm-id-1')
dbi.add_grid(self.ctx.session, grid_2_id, 'test grid 2', '{}', 'OFF',
'gm-id-2')
grids = dbi.get_grids(self.ctx.session)
grid_ids = utils.get_values_from_records('grid_id', grids)
self.assertEqual(grid_1_id, grid_ids[0])
self.assertEqual(grid_2_id, grid_ids[1])
grid_names = utils.get_values_from_records('grid_name', grids)
self.assertEqual('test grid 1', grid_names[0])
self.assertEqual('test grid 2', grid_names[1])
def test_get_composite_values_from_records(self):
grid_1_id = 100
grid_1_name = 'test grid 1'
grid_2_id = 200
grid_2_name = 'test grid 2'
dbi.remove_grids(self.ctx.session, [grid_1_id, grid_2_id])
dbi.add_grid(self.ctx.session, grid_1_id, grid_1_name, '{}', 'ON',
'gm-id-1')
dbi.add_grid(self.ctx.session, grid_2_id, grid_2_name, '{}', 'OFF',
'gm-id-2')
grids = dbi.get_grids(self.ctx.session)
composite_keys = ['grid_id', 'grid_name']
delimiter = '-'
composite_values = utils.get_composite_values_from_records(
composite_keys, grids, delimiter)
expected_value = str(grid_1_id) + delimiter + grid_1_name
self.assertEqual(expected_value, composite_values[0])
expected_value = str(grid_2_id) + delimiter + grid_2_name
self.assertEqual(expected_value, composite_values[1])
def test_db_records_to_obj(self):
grid_1_id = 100
grid_2_id = 200
dbi.add_grid(
self.ctx.session, grid_1_id, 'test grid 1',
'{"wapi_version": "2.0",'
'"wapi_admin_user": '******'{ "name": "admin", "password": "******" }}', 'ON', 'gm-id-1')
dbi.add_grid(self.ctx.session, grid_2_id, 'test grid 2', '{}', 'ON',
'gm-id-2')
grids = dbi.get_grids(self.ctx.session)
grid_obj = utils.db_records_to_obj('Grid', grids)
self.assertEqual('test grid 1', grid_obj[0].grid_name)
self.assertEqual('test grid 1', grid_obj[0].get('grid_name'))
self.assertEqual('test grid 1', grid_obj[0]['grid_name'])
self.assertEqual('test grid 2', grid_obj[1].grid_name)
self.assertEqual('test grid 2', grid_obj[1].get('grid_name'))
self.assertEqual('test grid 2', grid_obj[1]['grid_name'])
grid_connection = jsonutils.loads(grid_obj[0].grid_connection)
self.assertEqual('admin', grid_connection["wapi_admin_user"]["name"])
def sync_grid(self):
"""Synchronize an active grid.
Only one active grid should be kept where grid_status is set to 'ON'.
"""
session = self._context.session
grid_connection = self._grid_config.get_grid_connection()
grid_connection_json = jsonutils.dumps(grid_connection)
db_grids = dbi.get_grids(session)
db_grid_ids = utils.get_values_from_records('grid_id', db_grids)
# update the existing grid or add new grid
if self._grid_config.grid_id in db_grid_ids:
dbi.update_grid(session,
self._grid_config.grid_id,
self._grid_config.grid_name,
grid_connection_json,
const.GRID_STATUS_ON)
else:
dbi.add_grid(session,
self._grid_config.grid_id,
self._grid_config.grid_name,
grid_connection_json,
const.GRID_STATUS_ON,
utils.get_hash())
# deleting grids are delicate operation so we won't allow it
# but we will set grid status to OFF to unused grids.
persisted_set = set(db_grid_ids)
disable_set = persisted_set.difference([self._grid_config.grid_id])
disabling_grid_ids = list(disable_set)
for grid_id in disabling_grid_ids:
dbi.update_grid(session,
grid_id,
grid_status=const.GRID_STATUS_OFF)
session.flush()
def test_db_records_to_obj(self):
grid_1_id = 100
grid_2_id = 200
dbi.add_grid(self.ctx.session, grid_1_id, 'test grid 1',
'{"wapi_version": "2.0",'
'"wapi_admin_user": '******'{ "name": "admin", "password": "******" }}',
'ON',
'gm-id-1')
dbi.add_grid(self.ctx.session, grid_2_id, 'test grid 2', '{}', 'ON',
'gm-id-2')
grids = dbi.get_grids(self.ctx.session)
grid_obj = utils.db_records_to_obj('Grid', grids)
self.assertEqual('test grid 1', grid_obj[0].grid_name)
self.assertEqual('test grid 1', grid_obj[0].get('grid_name'))
self.assertEqual('test grid 1', grid_obj[0]['grid_name'])
self.assertEqual('test grid 2', grid_obj[1].grid_name)
self.assertEqual('test grid 2', grid_obj[1].get('grid_name'))
self.assertEqual('test grid 2', grid_obj[1]['grid_name'])
grid_connection = jsonutils.loads(grid_obj[0].grid_connection)
self.assertEqual('admin', grid_connection["wapi_admin_user"]["name"])
def test_sync_grid(self):
member_mgr = member.GridMemberManager(self.test_grid_config)
member_mgr.sync_grid()
grids = dbi.get_grids(self.ctx.session)
self.assertEqual(1, len(grids))
self.assertEqual(self.test_grid_config.grid_id, grids[0]['grid_id'])
self.assertEqual(self.test_grid_config.grid_name,
grids[0]['grid_name'])
expected_grid_connection = {
"wapi_version": self.test_grid_config.wapi_version,
"ssl_verify": self.test_grid_config.ssl_verify,
"http_pool_connections":
self.test_grid_config.http_pool_connections,
"http_pool_maxsize": self.test_grid_config.http_pool_maxsize,
"http_request_timeout": self.test_grid_config.http_request_timeout,
"admin_user": {
"name": self.test_grid_config.admin_user_name,
"password": self.test_grid_config.admin_password
}
}
actual_grid_connection = jsonutils.loads(grids[0]['grid_connection'])
self.assertEqual(expected_grid_connection, actual_grid_connection)
self.assertEqual('ON', grids[0]['grid_status'])
# change active grid to "Test Grid 2"
new_active_grid_config = grid.GridConfiguration(self.ctx)
new_active_grid_config.gm_connector = mock.Mock()
new_active_grid_config.grid_id = 200
new_active_grid_config.grid_name = "Test Grid 2"
new_active_grid_config.grid_master_host = '192.168.1.8'
new_active_grid_config.admin_user_name = 'admin'
new_active_grid_config.admin_password = '******'
new_active_grid_config.wapi_version = '1.4.2'
member_mgr = member.GridMemberManager(new_active_grid_config)
member_mgr.sync_grid()
grids = dbi.get_grids(self.ctx.session)
self.assertEqual(2, len(grids))
self.assertEqual(self.test_grid_config.grid_id, grids[0]['grid_id'])
self.assertEqual('OFF', grids[0]['grid_status'])
self.assertEqual(new_active_grid_config.grid_id, grids[1]['grid_id'])
self.assertEqual(new_active_grid_config.grid_name,
grids[1]['grid_name'])
expected_grid_connection = {
"wapi_version": new_active_grid_config.wapi_version,
"ssl_verify": new_active_grid_config.ssl_verify,
"http_pool_connections":
new_active_grid_config.http_pool_connections,
"http_pool_maxsize": new_active_grid_config.http_pool_maxsize,
"http_request_timeout":
new_active_grid_config.http_request_timeout,
"admin_user": {
"name": new_active_grid_config.admin_user_name,
"password": new_active_grid_config.admin_password
}
}
actual_grid_connection = jsonutils.loads(grids[1]['grid_connection'])
self.assertEqual(expected_grid_connection, actual_grid_connection)
self.assertEqual('ON', grids[1]['grid_status'])
def test_grid_management(self):
grid_list = [{'grid_id': 100,
'grid_name': 'Test Grid 1000',
'grid_connection': '{}',
'grid_status': 'ON'},
{'grid_id': 200,
'grid_name': 'Test Grid 2000',
'grid_connection': '{}',
'grid_status': 'OFF'}]
# expects no grid
db_grids = infoblox_db.get_grids(self.ctx.session)
self.assertEqual(0, len(db_grids))
# test grid additions
self._create_grids(grid_list)
db_grids = infoblox_db.get_grids(self.ctx.session)
actual_grid_rows = utils.get_composite_values_from_records(
['grid_id', 'grid_name', 'grid_connection', 'grid_status'],
db_grids)
expected_grid_rows = utils.get_composite_values_from_records(
['grid_id', 'grid_name', 'grid_connection', 'grid_status'],
grid_list)
self.assertEqual(expected_grid_rows, actual_grid_rows)
# test grid retrieval by grid_id filter
db_grids = infoblox_db.get_grids(self.ctx.session,
grid_id=grid_list[0]['grid_id'])
self.assertEqual(grid_list[0]['grid_id'], db_grids[0]['grid_id'])
self.assertEqual(grid_list[0]['grid_name'], db_grids[0]['grid_name'])
self.assertEqual(grid_list[0]['grid_connection'],
db_grids[0]['grid_connection'])
self.assertEqual(grid_list[0]['grid_connection'],
db_grids[0]['grid_connection'])
self.assertEqual(grid_list[0]['grid_status'],
db_grids[0]['grid_status'])
db_grids = infoblox_db.get_grids(self.ctx.session,
grid_id=grid_list[1]['grid_id'],
grid_name=grid_list[0]['grid_name'])
self.assertEqual([], db_grids)
# test grid retrieval by grid_id and grid_name filters
db_grids = infoblox_db.get_grids(self.ctx.session,
grid_id=grid_list[1]['grid_id'],
grid_name=grid_list[1]['grid_name'])
self.assertEqual(grid_list[1]['grid_id'], db_grids[0]['grid_id'])
self.assertEqual(grid_list[1]['grid_name'], db_grids[0]['grid_name'])
self.assertEqual(grid_list[1]['grid_connection'],
db_grids[0]['grid_connection'])
self.assertEqual(grid_list[1]['grid_connection'],
db_grids[0]['grid_connection'])
self.assertEqual(grid_list[1]['grid_status'],
db_grids[0]['grid_status'])
# test grid update
grid_name_update = "Test Grid 1000 Enhanced"
grid_connection_json = {
"wapi_version": "2.0",
"ssl_verify": False,
"http_pool_connections": 100,
"http_pool_maxsize": 100,
"http_request_timeout": 120,
"admin_user": {"name": "admin", "password": "******"}
}
grid_connection_json_string = jsonutils.dumps(grid_connection_json)
infoblox_db.update_grid(self.ctx.session,
grid_list[0]['grid_id'],
grid_name_update,
grid_connection_json_string)
db_grids = infoblox_db.get_grids(self.ctx.session,
grid_list[0]['grid_id'])
self.assertEqual(grid_name_update, db_grids[0]['grid_name'])
self.assertEqual(grid_connection_json_string,
db_grids[0]['grid_connection'])
# test grid removal
infoblox_db.remove_grids(self.ctx.session, [grid_list[0]['grid_id']])
db_grids = infoblox_db.get_grids(self.ctx.session,
grid_list[0]['grid_id'])
self.assertEqual(0, len(db_grids))
# remove two grids
self._create_grids([grid_list[0]])
infoblox_db.remove_grids(self.ctx.session,
[grid_list[0]['grid_id'],
grid_list[1]['grid_id']])
db_grids = infoblox_db.get_grids(self.ctx.session)
self.assertEqual(0, len(db_grids))
def sync_members(self):
"""Synchronizes grid members.
Members in the active grid are discovered from NIOS backend and
grid members are in sync in neutron db. The members who are no longer
in used are set to 'OFF' status.
"""
session = self._context.session
grid_id = self._grid_config.grid_id
db_grids = dbi.get_grids(session)
db_grid = utils.find_one_in_list('grid_id', grid_id, db_grids)
gm_member_id = db_grid.gm_id
db_members = dbi.get_members(session, grid_id=grid_id)
gm_member = utils.find_one_in_list('member_id', gm_member_id,
db_members)
discovered_members = self._discover_members()
if not discovered_members:
return
dns_member_settings = self._discover_dns_settings()
dhcp_member_settings = self._discover_dhcp_settings()
discovered_licenses = self._discover_member_licenses()
discovered_member_ids = []
for member in discovered_members:
member_name = member['host_name']
member_ip, member_ipv6 = self._get_lan1_ips(member)
member_wapi = member_ip if member_ip else member_ipv6
member_hwid = member['node_info'][0].get('hwid')
member_status = self._get_member_status(
member['node_info'][0]['service_status'])
member_type = self._get_member_type(discovered_licenses,
member_name, member_hwid)
require_db_update = False
if member_type == const.MEMBER_TYPE_GRID_MASTER:
if gm_member:
require_db_update = True
member_id = gm_member_id
member_wapi = self._grid_config.grid_master_host
else:
# no need to process 'Is Cloud Member' flag for non GM members
ea_is_cloud_member = utils.get_ea_value(
const.EA_IS_CLOUD_MEMBER, member)
is_cloud_member = (types.Boolean()(ea_is_cloud_member)
if ea_is_cloud_member else False)
if not is_cloud_member:
continue
db_member = utils.find_one_in_list('member_name', member_name,
db_members)
if db_member:
require_db_update = True
member_id = db_member.member_id
else:
member_id = utils.get_hash(str(grid_id) + member_name)
member_dhcp_ip, member_dhcp_ipv6 = self._get_dhcp_ips(
member, dhcp_member_settings)
member_dns_ip, member_dns_ipv6 = self._get_dns_ips(
member, dns_member_settings)
if require_db_update:
dbi.update_member(session, member_id, grid_id, member_name,
member_ip, member_ipv6, member_type,
member_status, member_dhcp_ip,
member_dhcp_ipv6, member_dns_ip,
member_dns_ipv6, member_wapi)
else:
dbi.add_member(session, member_id, grid_id, member_name,
member_ip, member_ipv6, member_type,
member_status, member_dhcp_ip, member_dhcp_ipv6,
member_dns_ip, member_dns_ipv6, member_wapi)
discovered_member_ids.append(member_id)
# deleting members are delicate operation so we won't allow it
# but we will set member status to OFF to unused members.
db_member_ids = utils.get_values_from_records('member_id', db_members)
persisted_set = set(db_member_ids)
discovered_set = set(discovered_member_ids)
disable_set = persisted_set.difference(discovered_set)
disabling_member_ids = list(disable_set)
for member_id in disabling_member_ids:
dbi.update_member(session,
member_id,
grid_id,
member_status=const.MEMBER_STATUS_OFF)
session.flush()
def test_grid_management(self):
grid_list = [{
'grid_id': 100,
'grid_name': 'Test Grid 1000',
'grid_connection': '{}',
'grid_status': 'ON'
}, {
'grid_id': 200,
'grid_name': 'Test Grid 2000',
'grid_connection': '{}',
'grid_status': 'OFF'
}]
# expects no grid
db_grids = infoblox_db.get_grids(self.ctx.session)
self.assertEqual(0, len(db_grids))
# test grid additions
self._create_grids(grid_list)
db_grids = infoblox_db.get_grids(self.ctx.session)
actual_grid_rows = utils.get_composite_values_from_records(
['grid_id', 'grid_name', 'grid_connection', 'grid_status'],
db_grids)
expected_grid_rows = utils.get_composite_values_from_records(
['grid_id', 'grid_name', 'grid_connection', 'grid_status'],
grid_list)
self.assertEqual(expected_grid_rows, actual_grid_rows)
# test grid retrieval by grid_id filter
db_grids = infoblox_db.get_grids(self.ctx.session,
grid_id=grid_list[0]['grid_id'])
self.assertEqual(grid_list[0]['grid_id'], db_grids[0]['grid_id'])
self.assertEqual(grid_list[0]['grid_name'], db_grids[0]['grid_name'])
self.assertEqual(grid_list[0]['grid_connection'],
db_grids[0]['grid_connection'])
self.assertEqual(grid_list[0]['grid_connection'],
db_grids[0]['grid_connection'])
self.assertEqual(grid_list[0]['grid_status'],
db_grids[0]['grid_status'])
db_grids = infoblox_db.get_grids(self.ctx.session,
grid_id=grid_list[1]['grid_id'],
grid_name=grid_list[0]['grid_name'])
self.assertEqual([], db_grids)
# test grid retrieval by grid_id and grid_name filters
db_grids = infoblox_db.get_grids(self.ctx.session,
grid_id=grid_list[1]['grid_id'],
grid_name=grid_list[1]['grid_name'])
self.assertEqual(grid_list[1]['grid_id'], db_grids[0]['grid_id'])
self.assertEqual(grid_list[1]['grid_name'], db_grids[0]['grid_name'])
self.assertEqual(grid_list[1]['grid_connection'],
db_grids[0]['grid_connection'])
self.assertEqual(grid_list[1]['grid_connection'],
db_grids[0]['grid_connection'])
self.assertEqual(grid_list[1]['grid_status'],
db_grids[0]['grid_status'])
# test grid update
grid_name_update = "Test Grid 1000 Enhanced"
grid_connection_json = {
"wapi_version": "2.0",
"ssl_verify": False,
"http_pool_connections": 100,
"http_pool_maxsize": 100,
"http_request_timeout": 120,
"admin_user": {
"name": "admin",
"password": "******"
}
}
grid_connection_json_string = jsonutils.dumps(grid_connection_json)
infoblox_db.update_grid(self.ctx.session, grid_list[0]['grid_id'],
grid_name_update, grid_connection_json_string)
db_grids = infoblox_db.get_grids(self.ctx.session,
grid_list[0]['grid_id'])
self.assertEqual(grid_name_update, db_grids[0]['grid_name'])
self.assertEqual(grid_connection_json_string,
db_grids[0]['grid_connection'])
# test grid removal
infoblox_db.remove_grids(self.ctx.session, [grid_list[0]['grid_id']])
db_grids = infoblox_db.get_grids(self.ctx.session,
grid_list[0]['grid_id'])
self.assertEqual(0, len(db_grids))
# remove two grids
self._create_grids([grid_list[0]])
infoblox_db.remove_grids(
self.ctx.session,
[grid_list[0]['grid_id'], grid_list[1]['grid_id']])
db_grids = infoblox_db.get_grids(self.ctx.session)
self.assertEqual(0, len(db_grids))
def sync_members(self):
"""Synchronizes grid members.
Members in the active grid are discovered from NIOS backend and
grid members are in sync in neutron db. The members who are no longer
in used are set to 'OFF' status.
"""
session = self._context.session
grid_id = self._grid_config.grid_id
db_grids = dbi.get_grids(session)
db_grid = utils.find_one_in_list('grid_id', grid_id, db_grids)
gm_member_id = db_grid.gm_id
db_members = dbi.get_members(session, grid_id=grid_id)
gm_member = utils.find_one_in_list('member_id', gm_member_id,
db_members)
discovered_members = self._discover_members()
if not discovered_members:
return
dns_member_settings = self._discover_dns_settings()
dhcp_member_settings = self._discover_dhcp_settings()
discovered_licenses = self._discover_member_licenses()
discovered_member_ids = []
for member in discovered_members:
member_name = member['host_name']
member_ip, member_ipv6 = self._get_lan1_ips(member)
member_wapi = member_ip if member_ip else member_ipv6
member_hwid = member['node_info'][0].get('hwid')
member_status = self._get_member_status(
member['node_info'][0]['service_status'])
member_type = self._get_member_type(discovered_licenses,
member_name,
member_hwid)
require_db_update = False
if member_type == const.MEMBER_TYPE_GRID_MASTER:
if gm_member:
require_db_update = True
member_id = gm_member_id
member_wapi = self._grid_config.grid_master_host
else:
# no need to process 'Is Cloud Member' flag for non GM members
ea_is_cloud_member = utils.get_ea_value(
const.EA_IS_CLOUD_MEMBER, member)
is_cloud_member = (types.Boolean()(ea_is_cloud_member)
if ea_is_cloud_member else False)
if not is_cloud_member:
continue
db_member = utils.find_one_in_list('member_name', member_name,
db_members)
if db_member:
require_db_update = True
member_id = db_member.member_id
else:
member_id = utils.get_hash(str(grid_id) + member_name)
member_dhcp_ip, member_dhcp_ipv6 = self._get_dhcp_ips(
member, dhcp_member_settings)
member_dns_ip, member_dns_ipv6 = self._get_dns_ips(
member, dns_member_settings)
if require_db_update:
dbi.update_member(session,
member_id,
grid_id,
member_name,
member_ip,
member_ipv6,
member_type,
member_status,
member_dhcp_ip,
member_dhcp_ipv6,
member_dns_ip,
member_dns_ipv6,
member_wapi)
else:
dbi.add_member(session,
member_id,
grid_id,
member_name,
member_ip,
member_ipv6,
member_type,
member_status,
member_dhcp_ip,
member_dhcp_ipv6,
member_dns_ip,
member_dns_ipv6,
member_wapi)
discovered_member_ids.append(member_id)
# deleting members are delicate operation so we won't allow it
# but we will set member status to OFF to unused members.
db_member_ids = utils.get_values_from_records('member_id', db_members)
persisted_set = set(db_member_ids)
discovered_set = set(discovered_member_ids)
disable_set = persisted_set.difference(discovered_set)
disabling_member_ids = list(disable_set)
for member_id in disabling_member_ids:
dbi.update_member(session,
member_id,
grid_id,
member_status=const.MEMBER_STATUS_OFF)
session.flush()
