def test_check_backup_edge_pools_with_vdr(self):
self.edge_manager.edge_pool_dicts = self.vdr_edge_pool_dicts
pool_edges = (self._create_edge_pools(1, 2, 3, 4, 5) +
self._create_edge_pools(
1, 2, 3, 4, 5, size=nsxv_constants.COMPACT) +
self._create_edge_pools(
1, 2, 3, 4, 5, edge_type=nsxv_constants.VDR_EDGE))
self._populate_vcns_router_binding(pool_edges)
self.edge_manager._check_backup_edge_pools()
router_bindings = nsxv_db.get_nsxv_router_bindings(self.ctx.session)
expect_vdr_bindings = self._create_backup_router_bindings(
1, 2, 3, 4, 5,
error_status=constants.PENDING_DELETE,
error_at_backend_status=constants.PENDING_DELETE,
edge_type=nsxv_constants.VDR_EDGE)
vdr_bindings = [
binding
for binding in router_bindings
if (binding['appliance_size'] == nsxv_constants.LARGE and
binding['edge_type'] == nsxv_constants.VDR_EDGE)]
self._verify_router_bindings(expect_vdr_bindings, vdr_bindings)
service_bindings = [
binding
for binding in router_bindings
if binding['edge_type'] == nsxv_constants.SERVICE_EDGE]
for binding in service_bindings:
self.assertEqual(constants.PENDING_DELETE, binding['status'])
def run(self, context, readonly=False):
super(ErrorBackupEdgeJob, self).run(context)
error_count = 0
fixed_count = 0
error_info = ''
# Gather ERROR state backup edges into dict
filters = {'status': [constants.ERROR]}
like_filters = {'router_id': vcns_const.BACKUP_ROUTER_PREFIX + "%"}
with locking.LockManager.get_lock('nsx-edge-backup-pool'):
error_edge_bindings = nsxv_db.get_nsxv_router_bindings(
context.session, filters=filters, like_filters=like_filters)
if not error_edge_bindings:
LOG.debug('Housekeeping: no backup edges in ERROR state detected')
return {'error_count': 0,
'fixed_count': 0,
'error_info': 'No backup edges in ERROR state detected'}
# Keep list of current broken backup edges - as it may change while
# HK is running
for binding in error_edge_bindings:
error_count += 1
error_info = base_job.housekeeper_warning(
error_info, 'Backup Edge appliance %s is in ERROR state',
binding['edge_id'])
if not readonly:
with locking.LockManager.get_lock(binding['edge_id']):
if self._handle_backup_edge(context, binding):
fixed_count += 1
return {'error_count': error_count,
'fixed_count': fixed_count,
'error_info': error_info}
def test_check_backup_edge_pool_with_min(self):
appliance_size = nsxv_constants.LARGE
edge_type = nsxv_constants.SERVICE_EDGE
pool_edges = (self._create_edge_pools(1, 2, 3, 0, 5) +
self._create_edge_pools(
1, 2, 3, 4, 5, size=nsxv_constants.COMPACT))
self._populate_vcns_router_binding(pool_edges)
edge_utils.eventlet = mock.Mock()
edge_utils.eventlet.spawn_n.return_value = None
self.edge_manager._check_backup_edge_pool(
5,
10,
appliance_size=appliance_size,
edge_type=edge_type,
availability_zone=self.az)
router_bindings = [
binding
for binding in nsxv_db.get_nsxv_router_bindings(self.ctx.session)
if binding['edge_id'] is None
and binding['status'] == plugin_const.PENDING_CREATE
]
binding_ids = [bind.router_id for bind in router_bindings]
self.assertEqual(2, len(router_bindings))
edge_utils.eventlet.spawn_n.assert_called_with(mock.ANY, binding_ids,
appliance_size,
edge_type, self.az)
def test_get_available_router_bindings(self):
appliance_size = nsxv_constants.LARGE
edge_type = nsxv_constants.SERVICE_EDGE
pool_edges = (self._create_edge_pools(1, 2, 3, 0, 5) +
self._create_edge_pools(
1, 2, 3, 0, 5, size=nsxv_constants.COMPACT))
self._populate_vcns_router_binding(pool_edges)
expect_backup_bindings = self._create_backup_router_bindings(
1, 2, 3, 0, 5, error_status=plugin_const.ERROR)
binding = self.edge_manager._get_available_router_binding(
self.ctx,
appliance_size=appliance_size,
edge_type=edge_type,
availability_zone=self.az)
router_bindings = [
binding_db for binding_db in nsxv_db.get_nsxv_router_bindings(
self.ctx.session)
if (binding_db['appliance_size'] == appliance_size
and binding_db['edge_type'] == edge_type
and binding_db['availability_zone'] == 'default')
]
self._verify_router_bindings(expect_backup_bindings, router_bindings)
edge_id = (EDGE_AVAIL + appliance_size + '-' + edge_type + '-edge-' +
str(0))
self.assertEqual(edge_id, binding['edge_id'])
def test_check_backup_edge_pool_with_max(self):
appliance_size = nsxv_constants.LARGE
edge_type = nsxv_constants.SERVICE_EDGE
pool_edges = (self._create_edge_pools(1, 2, 3, 4, 5) +
self._create_edge_pools(
1, 2, 3, 4, 5, size=nsxv_constants.COMPACT))
self._populate_vcns_router_binding(pool_edges)
expect_pool_bindings = self._create_backup_router_bindings(
1,
2,
3,
4,
5,
error_status=plugin_const.ERROR,
error_at_backend_status=plugin_const.PENDING_DELETE)
self.edge_manager._check_backup_edge_pool(
0,
3,
appliance_size=appliance_size,
edge_type=edge_type,
availability_zone=self.az)
router_bindings = [
binding
for binding in nsxv_db.get_nsxv_router_bindings(self.ctx.session)
if (binding['appliance_size'] == appliance_size
and binding['edge_type'] == edge_type)
]
self._verify_router_bindings(expect_pool_bindings, router_bindings)
def test_check_backup_edge_pools_with_vdr(self):
self.edge_manager.edge_pool_dicts = self.vdr_edge_pool_dicts
pool_edges = (self._create_edge_pools(1, 2, 3, 4, 5) +
self._create_edge_pools(
1, 2, 3, 4, 5, size=nsxv_constants.COMPACT) +
self._create_edge_pools(
1, 2, 3, 4, 5, edge_type=nsxv_constants.VDR_EDGE))
self._populate_vcns_router_binding(pool_edges)
self.edge_manager._check_backup_edge_pools()
router_bindings = nsxv_db.get_nsxv_router_bindings(self.ctx.session)
expect_vdr_bindings = self._create_backup_router_bindings(
1,
2,
3,
4,
5,
error_status=plugin_const.PENDING_DELETE,
error_at_backend_status=plugin_const.PENDING_DELETE,
edge_type=nsxv_constants.VDR_EDGE)
vdr_bindings = [
binding for binding in router_bindings
if (binding['appliance_size'] == nsxv_constants.LARGE
and binding['edge_type'] == nsxv_constants.VDR_EDGE)
]
self._verify_router_bindings(expect_vdr_bindings, vdr_bindings)
service_bindings = [
binding for binding in router_bindings
if binding['edge_type'] == nsxv_constants.SERVICE_EDGE
]
for binding in service_bindings:
self.assertEqual(plugin_const.PENDING_DELETE, binding['status'])
def get_metadata_status(resource, event, trigger, **kwargs):
if kwargs.get('property'):
properties = admin_utils.parse_multi_keyval_opt(kwargs['property'])
net_id = properties.get('network_id')
else:
net_id = None
edgeapi = utils.NeutronDbClient()
edge_list = nsxv_db.get_nsxv_internal_edges_by_purpose(
edgeapi.context.session,
vcns_constants.InternalEdgePurposes.INTER_EDGE_PURPOSE)
md_rtr_ids = [edge['router_id'] for edge in edge_list]
router_bindings = nsxv_db.get_nsxv_router_bindings(
edgeapi.context.session,
filters={'router_id': md_rtr_ids})
edge_ids = [b['edge_id'] for b in router_bindings]
_md_member_status('Metadata edge appliance: %s members', edge_ids)
if net_id:
as_provider_data = nsxv_db.get_edge_vnic_bindings_by_int_lswitch(
edgeapi.context.session, net_id)
providers = [asp['edge_id'] for asp in as_provider_data]
if providers:
LOG.info('Metadata providers for network %s', net_id)
_md_member_status('Edge %s', providers)
else:
LOG.info('No providers found for network %s', net_id)
def update_shared_secret(resource, event, trigger, **kwargs):
edgeapi = utils.NeutronDbClient()
edge_list = nsxv_db.get_nsxv_internal_edges_by_purpose(
edgeapi.context.session,
vcns_constants.InternalEdgePurposes.INTER_EDGE_PURPOSE)
md_rtr_ids = [edge['router_id'] for edge in edge_list]
router_bindings = nsxv_db.get_nsxv_router_bindings(
edgeapi.context.session,
filters={'edge_type': [nsxv_constants.SERVICE_EDGE]})
edge_ids = list(set([binding['edge_id'] for binding in router_bindings
if (binding['router_id'] not in set(md_rtr_ids) and
not binding['router_id'].startswith(
vcns_constants.BACKUP_ROUTER_PREFIX) and
not binding['router_id'].startswith(
vcns_constants.PLR_EDGE_PREFIX))]))
for edge_id in edge_ids:
with locking.LockManager.get_lock(edge_id):
lb = nsxv_lb.NsxvLoadbalancer.get_loadbalancer(nsxv, edge_id)
virt = lb.virtual_servers.get(md_proxy.METADATA_VSE_NAME)
if not virt:
LOG.error("Virtual server not found for edge: %s", edge_id)
continue
virt.del_app_rule('insert-auth')
if cfg.CONF.nsxv.metadata_shared_secret:
signature = hmac.new(
bytearray(cfg.CONF.nsxv.metadata_shared_secret, 'ascii'),
bytearray(edge_id, 'ascii'),
hashlib.sha256).hexdigest()
sign = 'reqadd X-Metadata-Provider-Signature:' + signature
sign_app_rule = nsxv_lb.NsxvLBAppRule('insert-auth', sign)
virt.add_app_rule(sign_app_rule)
lb.submit_to_backend(nsxv, edge_id)
def get_metadata_status(resource, event, trigger, **kwargs):
if kwargs.get('property'):
properties = admin_utils.parse_multi_keyval_opt(kwargs['property'])
net_id = properties.get('network_id')
else:
net_id = None
edgeapi = utils.NeutronDbClient()
edge_list = nsxv_db.get_nsxv_internal_edges_by_purpose(
edgeapi.context.session,
vcns_constants.InternalEdgePurposes.INTER_EDGE_PURPOSE)
md_rtr_ids = [edge['router_id'] for edge in edge_list]
router_bindings = nsxv_db.get_nsxv_router_bindings(
edgeapi.context.session, filters={'router_id': md_rtr_ids})
edge_ids = [b['edge_id'] for b in router_bindings]
_md_member_status('Metadata edge appliance: %s members', edge_ids)
if net_id:
as_provider_data = nsxv_db.get_edge_vnic_bindings_by_int_lswitch(
edgeapi.context.session, net_id)
providers = [asp['edge_id'] for asp in as_provider_data]
if providers:
LOG.info('Metadata providers for network %s', net_id)
_md_member_status('Edge %s', providers)
else:
LOG.info('No providers found for network %s', net_id)
def get_edge_id(self):
edgeapi = nsxv_utils.NeutronDbClient()
bindings = nsxv_db.get_nsxv_router_bindings(edgeapi.context.session)
for binding in bindings:
if binding.edge_id:
return binding.edge_id
# use a dummy edge
return "edge-1"
def test_check_backup_edge_pools_with_empty_conf(self):
pool_edges = (self._create_edge_pools(1, 2, 3, 4, 5) +
self._create_edge_pools(
1, 2, 3, 4, 5, size=nsxv_constants.COMPACT) +
self._create_edge_pools(
1, 2, 3, 4, 5, edge_type=nsxv_constants.VDR_EDGE))
self._populate_vcns_router_binding(pool_edges)
self.edge_manager._check_backup_edge_pools()
router_bindings = nsxv_db.get_nsxv_router_bindings(self.ctx.session)
for binding in router_bindings:
self.assertEqual(constants.PENDING_DELETE, binding['status'])
def run(self, context, readonly=False):
super(ErrorDhcpEdgeJob, self).run(context)
self.error_count = 0
self.fixed_count = 0
self.fixed_sub_if_count = 0
self.error_info = ''
# Gather ERROR state DHCP edges into dict
filters = {'status': [constants.ERROR]}
error_edge_bindings = nsxv_db.get_nsxv_router_bindings(context.session,
filters=filters)
if not error_edge_bindings:
LOG.debug('Housekeeping: no DHCP edges in ERROR state detected')
return {
'error_count': self.error_count,
'fixed_count': self.fixed_count,
'error_info': 'No DHCP error state edges detected'
}
with locking.LockManager.get_lock('nsx-dhcp-edge-pool'):
edge_dict = {}
for binding in error_edge_bindings:
if binding['router_id'].startswith(
vcns_const.DHCP_EDGE_PREFIX):
bind_list = edge_dict.get(binding['edge_id'], [])
bind_list.append(binding)
edge_dict[binding['edge_id']] = bind_list
# Get valid neutron networks and create a prefix dict.
networks = [
net['id']
for net in self.plugin.get_networks(context, fields=['id'])
]
pfx_dict = {
net[:36 - len(vcns_const.DHCP_EDGE_PREFIX)]: net
for net in networks
}
for edge_id in edge_dict.keys():
try:
self._validate_dhcp_edge(context, edge_dict, pfx_dict,
networks, edge_id, readonly)
except Exception as e:
self.error_count += 1
self.error_info = base_job.housekeeper_warning(
self.error_info, 'Failed to recover DHCP Edge %s (%s)',
edge_id, e)
return {
'error_count': self.error_count,
'fixed_count': self.fixed_count,
'error_info': self.error_info
}
def test_check_backup_edge_pools_with_empty_conf(self):
pool_edges = (self._create_edge_pools(1, 2, 3, 4, 5) +
self._create_edge_pools(
1, 2, 3, 4, 5, size=nsxv_constants.COMPACT) +
self._create_edge_pools(
1, 2, 3, 4, 5, edge_type=nsxv_constants.VDR_EDGE))
self._populate_vcns_router_binding(pool_edges)
self.edge_manager._check_backup_edge_pools()
router_bindings = nsxv_db.get_nsxv_router_bindings(self.ctx.session)
for binding in router_bindings:
self.assertEqual(plugin_const.PENDING_DELETE, binding['status'])
def nsx_list_name_mismatches(resource, event, trigger, **kwargs):
edges = utils.get_nsxv_backend_edges()
plugin_nsx_mismatch = []
backend_edge_ids = []
edgeapi = utils.NeutronDbClient()
# Look for edges with the wrong names:
for edge in edges:
backend_edge_ids.append(edge['id'])
rtr_binding = nsxv_db.get_nsxv_router_binding_by_edge(
edgeapi.context.session, edge['id'])
if (rtr_binding and edge['name'].startswith('backup-')
and rtr_binding['router_id'] != edge['name']):
plugin_nsx_mismatch.append({
'edge_id': edge['id'],
'edge_name': edge['name'],
'router_id': rtr_binding['router_id']
})
LOG.info(
formatters.output_formatter(
constants.BACKUP_EDGES + ' with name mismatch:',
plugin_nsx_mismatch, ['edge_id', 'edge_name', 'router_id']))
# Also look for missing edges
like_filters = {'router_id': vcns_const.BACKUP_ROUTER_PREFIX + "%"}
rtr_bindings = nsxv_db.get_nsxv_router_bindings(edgeapi.context.session,
like_filters=like_filters)
plugin_nsx_missing = []
for rtr_binding in rtr_bindings:
if rtr_binding['edge_id'] not in backend_edge_ids:
plugin_nsx_missing.append({
'edge_id': rtr_binding['edge_id'],
'router_id': rtr_binding['router_id'],
'db_status': rtr_binding['status']
})
LOG.info(
formatters.output_formatter(
constants.BACKUP_EDGES + ' missing from backend:',
plugin_nsx_missing, ['edge_id', 'router_id', 'db_status']))
def test_check_backup_edge_pool_with_max(self):
appliance_size = nsxv_constants.LARGE
edge_type = nsxv_constants.SERVICE_EDGE
pool_edges = (self._create_edge_pools(1, 2, 3, 4, 5) +
self._create_edge_pools(
1, 2, 3, 4, 5, size=nsxv_constants.COMPACT))
self._populate_vcns_router_binding(pool_edges)
expect_pool_bindings = self._create_backup_router_bindings(
1, 2, 3, 4, 5,
error_status=plugin_const.ERROR,
error_at_backend_status=plugin_const.PENDING_DELETE)
self.edge_manager._check_backup_edge_pool(
0, 3,
appliance_size=appliance_size, edge_type=edge_type)
router_bindings = [
binding
for binding in nsxv_db.get_nsxv_router_bindings(self.ctx.session)
if (binding['appliance_size'] == appliance_size and
binding['edge_type'] == edge_type)]
self._verify_router_bindings(expect_pool_bindings, router_bindings)
def test_get_available_router_bindings(self):
appliance_size = nsxv_constants.LARGE
edge_type = nsxv_constants.SERVICE_EDGE
pool_edges = (self._create_edge_pools(1, 2, 3, 0, 5) +
self._create_edge_pools(
1, 2, 3, 0, 5, size=nsxv_constants.COMPACT))
self._populate_vcns_router_binding(pool_edges)
expect_backup_bindings = self._create_backup_router_bindings(
1, 2, 3, 0, 5, error_status=plugin_const.ERROR)
binding = self.edge_manager._get_available_router_binding(
self.ctx, appliance_size=appliance_size, edge_type=edge_type)
router_bindings = [
binding_db
for binding_db in nsxv_db.get_nsxv_router_bindings(
self.ctx.session)
if (binding_db['appliance_size'] == appliance_size and
binding_db['edge_type'] == edge_type)]
self._verify_router_bindings(expect_backup_bindings, router_bindings)
edge_id = (EDGE_AVAIL + appliance_size + '-' +
edge_type + '-edge-' + str(0))
self.assertEqual(edge_id, binding['edge_id'])
def run(self, context, readonly=False):
super(ErrorBackupEdgeJob, self).run(context)
error_count = 0
fixed_count = 0
error_info = ''
# Gather ERROR state backup edges into dict
filters = {'status': [constants.ERROR]}
like_filters = {'router_id': vcns_const.BACKUP_ROUTER_PREFIX + "%"}
with locking.LockManager.get_lock('nsx-edge-backup-pool'):
error_edge_bindings = nsxv_db.get_nsxv_router_bindings(
context.session, filters=filters, like_filters=like_filters)
if not error_edge_bindings:
LOG.debug('Housekeeping: no backup edges in ERROR state detected')
return {
'error_count': 0,
'fixed_count': 0,
'error_info': 'No backup edges in ERROR state detected'
}
# Keep list of current broken backup edges - as it may change while
# HK is running
for binding in error_edge_bindings:
error_count += 1
error_info = base_job.housekeeper_warning(
error_info, 'Backup Edge appliance %s is in ERROR state',
binding['edge_id'])
if not readonly:
with locking.LockManager.get_lock(binding['edge_id']):
if self._handle_backup_edge(context, binding):
fixed_count += 1
return {
'error_count': error_count,
'fixed_count': fixed_count,
'error_info': error_info
}
def test_check_backup_edge_pool_with_min(self):
appliance_size = nsxv_constants.LARGE
edge_type = nsxv_constants.SERVICE_EDGE
pool_edges = (self._create_edge_pools(1, 2, 3, 0, 5) +
self._create_edge_pools(
1, 2, 3, 4, 5, size=nsxv_constants.COMPACT))
self._populate_vcns_router_binding(pool_edges)
edge_utils.eventlet = mock.Mock()
edge_utils.eventlet.spawn_n.return_value = None
self.edge_manager._check_backup_edge_pool(
5, 10, appliance_size=appliance_size, edge_type=edge_type)
router_bindings = [
binding
for binding in nsxv_db.get_nsxv_router_bindings(self.ctx.session)
if binding['edge_id'] is None
and binding['status'] == plugin_const.PENDING_CREATE]
binding_ids = [bind.router_id for bind in router_bindings]
self.assertEqual(2, len(router_bindings))
edge_utils.eventlet.spawn_n.assert_called_with(
mock.ANY, mock.ANY, binding_ids, appliance_size, edge_type)
def nsx_redo_metadata_cfg_for_az(context, plugin, az_name, check_az=True):
LOG.info("Updating MetaData for availability zone: %s", az_name)
if check_az:
conf_az = nsx_az.NsxVAvailabilityZones()
az = conf_az.availability_zones.get(az_name)
if not az:
LOG.error('Availability zone %s not found', az_name)
return
if not az.supports_metadata():
LOG.error('Availability zone %s is not configured with metadata',
az_name)
return
edge_internal_ips, md_rtr_ids = _get_internal_edge_ips(context,
az_name)
if not edge_internal_ips and not md_rtr_ids:
LOG.error("Metadata infrastructure is missing or broken. "
"It is recommended to restart neutron service before "
"proceeding with configuration restoration")
return
router_bindings = nsxv_db.get_nsxv_router_bindings(
context.session,
filters={'edge_type': [nsxv_constants.SERVICE_EDGE],
'availability_zone': [az_name]})
edge_ids = list(set([binding['edge_id'] for binding in router_bindings
if (binding['router_id'] not in set(md_rtr_ids) and
not binding['router_id'].startswith(
vcns_constants.BACKUP_ROUTER_PREFIX) and
not binding['router_id'].startswith(
vcns_constants.PLR_EDGE_PREFIX)and
not binding['router_id'].startswith(
lb_common.RESOURCE_ID_PFX))]))
for edge_id in edge_ids:
_handle_edge(context, plugin, az_name, edge_id, edge_internal_ips)
def run(self, context):
super(ErrorBackupEdgeJob, self).run(context)
# Gather ERROR state backup edges into dict
filters = {'status': [constants.ERROR]}
like_filters = {'router_id': vcns_const.BACKUP_ROUTER_PREFIX + "%"}
with locking.LockManager.get_lock('nsx-edge-backup-pool'):
error_edge_bindings = nsxv_db.get_nsxv_router_bindings(
context.session, filters=filters, like_filters=like_filters)
if not error_edge_bindings:
LOG.debug('Housekeeping: no backup edges in ERROR state detected')
return
# Keep list of current broken backup edges - as it may change while
# HK is running
for binding in error_edge_bindings:
LOG.warning(
'Housekeeping: Backup Edge appliance %s is in ERROR'
' state', binding['edge_id'])
if not self.readonly:
with locking.LockManager.get_lock(binding['edge_id']):
self._handle_backup_edge(context, binding)
def get_router_edge_bindings():
edgeapi = utils.NeutronDbClient()
return nsxv_db.get_nsxv_router_bindings(edgeapi.context)
def get_router_edge_bindings():
edgeapi = utils.NeutronDbClient()
return nsxv_db.get_nsxv_router_bindings(edgeapi.context)
def nsx_redo_metadata_cfg_for_az(az, edgeapi):
LOG.info("Updating MetaData for availability zone: %s", az.name)
# Get the list of internal networks for this AZ
db_net = nsxv_db.get_nsxv_internal_network(
edgeapi.context.session,
vcns_constants.InternalEdgePurposes.INTER_EDGE_PURPOSE, az.name)
internal_net = None
internal_subnet = None
if db_net:
internal_net = db_net['network_id']
internal_subnet = edgeapi.context.session.query(
models_v2.Subnet).filter_by(
network_id=internal_net).first().get('id')
# Get the list of internal edges for this AZ
edge_list = nsxv_db.get_nsxv_internal_edges_by_purpose(
edgeapi.context.session,
vcns_constants.InternalEdgePurposes.INTER_EDGE_PURPOSE)
edge_az_list = [
edge for edge in edge_list if nsxv_db.get_router_availability_zone(
edgeapi.context.session, edge['router_id']) == az.name
]
md_rtr_ids = [edge['router_id'] for edge in edge_az_list]
edge_internal_ips = []
for edge in edge_az_list:
edge_internal_port = edgeapi.context.session.query(
models_v2.Port).filter_by(network_id=internal_net,
device_id=edge['router_id']).first()
if edge_internal_port:
edge_internal_ip = edgeapi.context.session.query(
models_v2.IPAllocation).filter_by(
port_id=edge_internal_port['id']).first()
edge_internal_ips.append(edge_internal_ip['ip_address'])
if not internal_net or not internal_subnet or not edge_internal_ips:
LOG.error("Metadata infrastructure is missing or broken. "
"It is recommended to restart neutron service before "
"proceeding with configuration restoration")
return
router_bindings = nsxv_db.get_nsxv_router_bindings(
edgeapi.context.session,
filters={
'edge_type': [nsxv_constants.SERVICE_EDGE],
'availability_zones': az.name
})
edge_ids = list(
set([
binding['edge_id'] for binding in router_bindings
if (binding['router_id'] not in set(md_rtr_ids)
and not binding['router_id'].startswith(
vcns_constants.BACKUP_ROUTER_PREFIX)
and not binding['router_id'].startswith(
vcns_constants.PLR_EDGE_PREFIX))
]))
for edge_id in edge_ids:
with locking.LockManager.get_lock(edge_id):
lb = nsxv_lb.NsxvLoadbalancer.get_loadbalancer(nsxv, edge_id)
virt = lb.virtual_servers.get(md_proxy.METADATA_VSE_NAME)
if virt:
pool = virt.default_pool
pool.members = {}
i = 0
s_port = cfg.CONF.nsxv.nova_metadata_port
for member_ip in edge_internal_ips:
i += 1
member = nsxv_lb.NsxvLBPoolMember(name='Member-%d' % i,
ip_address=member_ip,
port=s_port,
monitor_port=s_port)
pool.add_member(member)
lb.submit_to_backend(nsxv, edge_id)
def nsx_redo_metadata_cfg(resource, event, trigger, **kwargs):
edgeapi = utils.NeutronDbClient()
net_list = nsxv_db.get_nsxv_internal_network(
edgeapi.context.session,
vcns_constants.InternalEdgePurposes.INTER_EDGE_PURPOSE)
internal_net = None
internal_subnet = None
if net_list:
internal_net = net_list[0]['network_id']
internal_subnet = edgeapi.context.session.query(
models_v2.Subnet).filter_by(
network_id=internal_net).first().get('id')
edge_list = nsxv_db.get_nsxv_internal_edges_by_purpose(
edgeapi.context.session,
vcns_constants.InternalEdgePurposes.INTER_EDGE_PURPOSE)
md_rtr_ids = [edge['router_id'] for edge in edge_list]
edge_internal_ips = []
for edge in edge_list:
edge_internal_port = edgeapi.context.session.query(
models_v2.Port).filter_by(network_id=internal_net,
device_id=edge['router_id']).first()
if edge_internal_port:
edge_internal_ip = edgeapi.context.session.query(
models_v2.IPAllocation).filter_by(
port_id=edge_internal_port['id']).first()
edge_internal_ips.append(edge_internal_ip['ip_address'])
if not internal_net or not internal_subnet or not edge_internal_ips:
LOG.error(_LE("Metadata infrastructure is missing or broken. "
"It is recommended to restart neutron service before "
"proceeding with configuration restoration"))
return
router_bindings = nsxv_db.get_nsxv_router_bindings(
edgeapi.context.session,
filters={'edge_type': [nsxv_constants.SERVICE_EDGE]})
edge_ids = list(set([binding['edge_id'] for binding in router_bindings
if (binding['router_id'] not in set(md_rtr_ids)
and not binding['router_id'].startswith(
vcns_constants.BACKUP_ROUTER_PREFIX)
and not binding['router_id'].startswith(
vcns_constants.PLR_EDGE_PREFIX))]))
for edge_id in edge_ids:
with locking.LockManager.get_lock(edge_id):
lb = nsxv_lb.NsxvLoadbalancer.get_loadbalancer(nsxv, edge_id)
virt = lb.virtual_servers.get(md_proxy.METADATA_VSE_NAME)
if virt:
pool = virt.default_pool
pool.members = {}
i = 0
s_port = cfg.CONF.nsxv.nova_metadata_port
for member_ip in edge_internal_ips:
i += 1
member = nsxv_lb.NsxvLBPoolMember(
name='Member-%d' % i,
ip_address=member_ip,
port=s_port,
monitor_port=s_port)
pool.add_member(member)
lb.submit_to_backend(nsxv, edge_id)
