def bgp_router_delete(name, **kwargs):
'''
Delete specific Contrail control node
CLI Example:
.. code-block:: bash
salt '*' contrail.bgp_router_delete mx01
'''
vnc_client = _auth(**kwargs)
gsc_obj = _get_control(vnc_client)
bgp_router_obj = BgpRouter(name, gsc_obj)
vnc_client.bgp_router_delete(fq_name=bgp_router_obj.get_fq_name())
def bgp_router_delete(name, **kwargs):
'''
Delete specific Contrail control node
CLI Example:
.. code-block:: bash
salt '*' contrail.bgp_router_delete mx01
'''
vnc_client = _auth(**kwargs)
gsc_obj = _get_control(vnc_client)
bgp_router_obj = BgpRouter(name, gsc_obj)
vnc_client.bgp_router_delete(
fq_name=bgp_router_obj.get_fq_name())
def bgp_router_create(name, type, ip_address, asn=64512, **kwargs):
'''
Create specific Contrail control node
CLI Example:
.. code-block:: bash
salt '*' contrail.bgp_router_create ntw03 control-node 10.10.10.103
salt '*' contrail.bgp_router_create mx01 router 10.10.10.105
'''
ret = {}
vnc_client = _auth(**kwargs)
address_families = [
'route-target', 'inet-vpn', 'e-vpn', 'erm-vpn', 'inet6-vpn'
]
if type != 'control-node':
address_families.remove('erm-vpn')
bgp_addr_fams = AddressFamilies(address_families)
bgp_sess_attrs = [BgpSessionAttributes(address_families=bgp_addr_fams)]
bgp_sessions = [BgpSession(attributes=bgp_sess_attrs)]
bgp_peering_attrs = BgpPeeringAttributes(session=bgp_sessions)
rt_inst_obj = _get_rt_inst_obj(vnc_client)
if type == 'control-node':
vendor = 'contrail'
elif type == 'router':
vendor = 'mx'
else:
vendor = 'unknown'
router_params = BgpRouterParams(router_type=type,
vendor=vendor,
autonomous_system=int(asn),
identifier=_get_ip(ip_address),
address=_get_ip(ip_address),
port=179,
address_families=bgp_addr_fams)
bgp_router_objs = bgp_router_list(**kwargs)
if name in bgp_router_objs:
bgp_router_obj = vnc_client._object_read(
'bgp-router', id=bgp_router_objs[name]['_uuid'])
bgp_router_obj.set_bgp_router_parameters(router_params)
if __opts__['test']:
return "BGP router " + name + " will be updated"
vnc_client.bgp_router_update(bgp_router_obj)
else:
bgp_router_obj = BgpRouter(name,
rt_inst_obj,
bgp_router_parameters=router_params)
if __opts__['test']:
return "BGP router " + name + " will be created"
vnc_client.bgp_router_create(bgp_router_obj)
return "Created"
return {'OK': 'Config node %s already exists' % name}
def bgp_router_delete(name, **kwargs):
'''
Delete specific Contrail control node
CLI Example:
.. code-block:: bash
salt '*' contrail.bgp_router_delete mx01
'''
vnc_client = _auth(**kwargs)
gsc_obj = _get_config(vnc_client)
bgp_router_obj = BgpRouter(name, gsc_obj)
if __opts__['test']:
return "BGP router " + name + " will be deleted"
vnc_client.bgp_router_delete(fq_name=bgp_router_obj.get_fq_name())
return "Deleted"
def update_peering(self, rr_changed=False):
if not ResourceBaseST.get_obj_type_map().get(
'global_system_config').get_ibgp_auto_mesh():
return
if self.router_type in ('bgpaas-server', 'bgpaas-client'):
return
fabric = None
if self.physical_router:
phy_rtr = ResourceBaseST.get_obj_type_map().get(
'physical_router').get(self.physical_router)
fabric = phy_rtr.fabric
global_asn = int(ResourceBaseST.get_obj_type_map().get(
'global_system_config').get_autonomous_system())
# if it's a fabric or sub cluster bgp router, ignore
# global asn check that we do to determine e-bgp router
if (self.sub_cluster is None and fabric is None
and self.asn != global_asn):
return
try:
obj = self.read_vnc_obj(fq_name=self.name)
except NoIdError as e:
self._logger.error("NoIdError while reading bgp router "
"%s: %s" % (self.name, str(e)))
return
cluster_rr_supported, control_rr_supported = \
self._is_route_reflector_supported()
peerings_set = [ref['to'] for ref in (obj.get_bgp_router_refs() or [])]
new_peerings_list = []
new_peerings_attrs = []
for router in self._dict.values():
if router.name == self.name:
continue
if router.sub_cluster != self.sub_cluster:
continue
if router.router_type in ('bgpaas-server', 'bgpaas-client'):
continue
if self._skip_bgp_router_peering_add(router, cluster_rr_supported,
control_rr_supported):
continue
router_fq_name = router.name.split(':')
if router_fq_name in peerings_set and not rr_changed:
continue
router_obj = BgpRouter()
router_obj.fq_name = router_fq_name
af = AddressFamilies(family=[])
bsa = BgpSessionAttributes(address_families=af)
session = BgpSession(attributes=[bsa])
attr = BgpPeeringAttributes(session=[session])
new_peerings_list.append(router_fq_name)
new_peerings_attrs.append(attr)
obj.add_bgp_router(router_obj, attr)
new_peerings_set = [
ref['to'] for ref in (obj.get_bgp_router_refs() or [])
]
if rr_changed:
obj.set_bgp_router_list(new_peerings_list, new_peerings_attrs)
try:
self._vnc_lib.bgp_router_update(obj)
except NoIdError as e:
self._logger.error("NoIdError while updating bgp router "
"%s: %s" % (self.name, str(e)))
elif new_peerings_set != peerings_set:
try:
self._vnc_lib.bgp_router_update(obj)
except NoIdError as e:
self._logger.error("NoIdError while updating bgp router "
"%s: %s" % (self.name, str(e)))
def create_bgp_router(self, name, shared=False):
if shared:
if not self.obj.bgpaas_ip_address:
return
vmi_refs = self.obj.get_virtual_machine_interface_refs()
if not vmi_refs:
return
# all vmis will have link to this bgp-router
vmis = [
ResourceBaseST.get_obj_type_map().get(
'virtual_machine_interface').get(':'.join(ref['to']))
for ref in vmi_refs
]
else:
# only current vmi will have link to this bgp-router
vmi = ResourceBaseST.get_obj_type_map().get(
'virtual_machine_interface').get(name)
if not vmi:
self.virtual_machine_interfaces.discard(name)
return
vmis = [vmi]
vn = ResourceBaseST.get_obj_type_map().get('virtual_network').get(
vmis[0].virtual_network)
if not vn:
return
ri = vn.get_primary_routing_instance()
if not ri:
return
server_fq_name = ri.obj.get_fq_name_str() + ':bgpaas-server'
server_router = ResourceBaseST.get_obj_type_map().get(
'bgp_router').get(server_fq_name)
if not server_router:
server_router = BgpRouter('bgpaas-server', parent_obj=ri.obj)
params = BgpRouterParams(router_type='bgpaas-server')
server_router.set_bgp_router_parameters(params)
self._vnc_lib.bgp_router_create(server_router)
ResourceBaseST.get_obj_type_map().get('bgp_router').locate(
server_fq_name, server_router)
else:
server_router = server_router.obj
bgpr_name = self.obj.name if shared else vmi.obj.name
router_fq_name = ri.obj.get_fq_name_str() + ':' + bgpr_name
bgpr = ResourceBaseST.get_obj_type_map().get('bgp_router').get(
router_fq_name)
create = False
update = False
src_port = None
if not bgpr:
bgp_router = BgpRouter(bgpr_name, parent_obj=ri.obj)
create = True
try:
src_port = self._object_db.alloc_bgpaas_port(router_fq_name)
except ResourceExhaustionError as e:
self._logger.error("Cannot allocate BGPaaS port for %s:%s" %
(router_fq_name, str(e)))
return
else:
bgp_router = self._vnc_lib.bgp_router_read(id=bgpr.obj.uuid)
src_port = bgpr.source_port
ip = self.bgpaas_ip_address or \
vmis[0].get_primary_instance_ip_address()
params = BgpRouterParams(autonomous_system=int(self.autonomous_system)
if self.autonomous_system else None,
address=ip,
identifier=ip,
source_port=src_port,
router_type='bgpaas-client')
if bgp_router.get_bgp_router_parameters() != params:
bgp_router.set_bgp_router(server_router, self.peering_attribs)
update = True
if create:
bgp_router.set_bgp_router_parameters(params)
self._vnc_lib.bgp_router_create(bgp_router)
self.obj.add_bgp_router(bgp_router)
self._vnc_lib.bgp_as_a_service_update(self.obj)
bgpr = ResourceBaseST.get_obj_type_map().get('bgp_router').locate(
router_fq_name)
elif update:
self._vnc_lib.bgp_router_update(bgp_router)
if shared:
self.bgpaas_clients[self.obj.name] = router_fq_name
else:
self.bgpaas_clients[name] = router_fq_name