def handle_create(self):
tenant_id = self.stack.context.tenant_id
project_obj = self.vnc_lib().project_read(id=str(uuid.UUID(tenant_id)))
vn_obj = vnc_api.VirtualNetwork(name=self.properties[self.NAME],
parent_obj=project_obj)
vn_params = vnc_api.VirtualNetworkType()
if self.properties[self.ALLOW_TRANSIT] == "True":
vn_params.set_allow_transit(True)
else:
vn_params.set_allow_transit(False)
vn_params.set_forwarding_mode(self.properties[self.FORWARDING_MODE])
vn_obj.set_virtual_network_properties(vn_params)
vn_obj.set_route_target_list(
vnc_api.RouteTargetList([
"target:" + route
for route in self.properties[self.ROUTE_TARGETS]
]))
if self.properties[self.SHARED] == "True":
vn_obj.set_is_shared(True)
else:
vn_obj.set_is_shared(False)
if self.properties[self.EXTERNAL] == "True":
vn_obj.set_router_external(True)
else:
vn_obj.set_router_external(False)
if self.properties[self.FLOOD_UNKNOWN_UNICAST] == "True":
vn_obj.set_flood_unknown_unicast(True)
else:
vn_obj.set_flood_unknown_unicast(False)
vn_uuid = super(ContrailVirtualNetwork, self).resource_create(vn_obj)
self.resource_id_set(vn_uuid)
def create(self,
v4subnet,
v4gateway,
v6subnet=None,
v6gateway=None,
rtList=None):
try:
ipam_obj = self.vnc_client.network_ipam_read(fq_name=[
'default-domain', 'default-project', 'default-network-ipam'
])
except Exception as e:
logging.debug('ERROR: %s' % (str(e)))
return
cidr = v4subnet.split('/')
subnet = vnc_api.SubnetType(ip_prefix=cidr[0],
ip_prefix_len=int(cidr[1]))
v4DnsServer = IPNetwork(v4subnet)[-2]
if v4gateway:
ipam_subnet = vnc_api.IpamSubnetType(subnet=subnet,
default_gateway=v4gateway)
else:
ipam_subnet = vnc_api.IpamSubnetType(
subnet=subnet, dns_server_address=v4DnsServer)
if v6subnet:
v6DnsServer = IPNetwork(v6subnet)[-2]
v6cidr = v6subnet.split('/')
v6subnet = vnc_api.SubnetType(ip_prefix=v6cidr[0],
ip_prefix_len=int(v6cidr[1]))
if v6gateway:
v6gateway = v6gateway.split('/')[0]
ipam_v6subnet = vnc_api.IpamSubnetType(
subnet=v6subnet, default_gateway=v6gateway)
else:
ipam_v6subnet = vnc_api.IpamSubnetType(
subnet=v6subnet, dns_server_address=v6DnsServer)
self.obj.add_network_ipam(ref_obj=ipam_obj,
ref_data=vnc_api.VnSubnetsType(
[ipam_subnet, ipam_v6subnet]))
else:
self.obj.add_network_ipam(ref_obj=ipam_obj,
ref_data=vnc_api.VnSubnetsType(
[ipam_subnet]))
if rtList:
rtObj = vnc_api.RouteTargetList()
self.obj.set_route_target_list(rtObj)
for rt in rtList:
rtObj.add_route_target('target:%s' % (rt))
try:
self.vnc_client.virtual_network_create(self.obj)
except Exception as e:
logging.debug('ERROR: %s' % (str(e)))
'''
def createNw(self, subnet, gateway=None, rtList=None):
self.createSubnet(subnet, gateway)
if rtList:
rtObj = vnc_api.RouteTargetList()
self.obj.set_route_target_list(rtObj)
for rt in rtList:
rtObj.add_route_target('target:%s' % (rt))
try:
self.vnc_client.virtual_network_create(self.obj)
except Exception as e:
print 'ERROR: %s' % (str(e))
def _neutron_dict_to_bgpvpn(self, bgpvpn_obj, bgpvpn_dict):
if 'name' in bgpvpn_dict:
bgpvpn_obj.set_display_name(bgpvpn_dict['name'])
if 'type' in bgpvpn_dict:
bgpvpn_obj.set_bgpvpn_type(bgpvpn_dict['type'])
if 'route_targets' in bgpvpn_dict:
rt_list = vnc_api.RouteTargetList(
['target:' + rt for rt in bgpvpn_dict['route_targets']])
bgpvpn_obj.set_route_target_list(rt_list)
if 'import_targets' in bgpvpn_dict:
import_rt_list = vnc_api.RouteTargetList(
['target:' + rt for rt in bgpvpn_dict['import_targets']])
bgpvpn_obj.set_import_route_target_list(import_rt_list)
if 'export_targets' in bgpvpn_dict:
export_rt_list = vnc_api.RouteTargetList(
['target:' + rt for rt in bgpvpn_dict['export_targets']])
bgpvpn_obj.set_export_route_target_list(export_rt_list)
return bgpvpn_obj
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
try:
vn_obj = self.vnc_lib().virtual_network_read(id=self.resource_id)
except Exception as ex:
LOG.warn(_("Virtual Network %s not found.") % self.name)
raise ex
vn_params = vnc_api.VirtualNetworkType()
if prop_diff.get(self.ALLOW_TRANSIT) == "True":
vn_params.set_allow_transit(True)
else:
vn_params.set_allow_transit(False)
if prop_diff.get(self.SHARED) == "True":
vn_obj.set_is_shared(True)
else:
vn_obj.set_is_shared(False)
if prop_diff.get(self.EXTERNAL) == "True":
vn_obj.set_router_external(True)
else:
vn_obj.set_router_external(False)
fwd_mode = prop_diff.get(self.FORWARDING_MODE)
if fwd_mode:
vn_params.set_forwarding_mode(fwd_mode)
vn_obj.set_virtual_network_properties(vn_params)
rt_list = prop_diff.get(self.ROUTE_TARGETS)
if rt_list:
vn_obj.set_route_target_list(
vnc_api.RouteTargetList(
["target:" + route for route in rt_list]))
if prop_diff.get(self.FLOOD_UNKNOWN_UNICAST) == "True":
vn_obj.set_flood_unknown_unicast(True)
else:
vn_obj.set_flood_unknown_unicast(False)
self.vnc_lib().virtual_network_update(vn_obj)
def createVirtualNetwork(tenant, vnName, v4subnet, rt):
project = vnc_client.project_read(fq_name_str = 'default-domain:' + tenant)
vn = vnc_api.VirtualNetwork(name = vnName,
parent_obj = project)
ipam_obj = vnc_client.network_ipam_read(fq_name = ['default-domain',
'default-project', 'default-network-ipam'])
cidr = v4subnet.split('/')
subnet = vnc_api.SubnetType(ip_prefix = cidr[0],
ip_prefix_len = int(cidr[1]))
v4DnsServer = str(IPNetwork(v4subnet)[+2])
v4gateway = str(IPNetwork(v4subnet)[+1])
ipam_subnet = vnc_api.IpamSubnetType(subnet = subnet, dns_server_address = v4DnsServer,
default_gateway = v4gateway, enable_dhcp = False)
vn.add_network_ipam(ref_obj = ipam_obj,
ref_data = vnc_api.VnSubnetsType([ipam_subnet]))
rtObj = vnc_api.RouteTargetList()
vn.set_route_target_list(rtObj)
rtObj.add_route_target('target:%s' %(rt))
vnc_client.virtual_network_create(vn)
vnObj = vnc_client.virtual_network_read(fq_name_str = 'default-domain:' + tenant + ':' + vnName)
return vnObj
def handle_update(self, json_snippet, tmpl_diff, prop_diff):
try:
obj_0 = self.vnc_lib().logical_router_read(
id=self.resource_id
)
except:
raise Exception(_('logical-router %s not found.') % self.name)
if prop_diff.get(self.DISPLAY_NAME) is not None:
obj_0.set_display_name(prop_diff.get(self.DISPLAY_NAME))
if prop_diff.get(self.CONFIGURED_ROUTE_TARGET_LIST) is not None:
obj_1 = vnc_api.RouteTargetList()
if prop_diff.get(self.CONFIGURED_ROUTE_TARGET_LIST, {}).get(self.CONFIGURED_ROUTE_TARGET_LIST_ROUTE_TARGET) is not None:
for index_1 in range(len(prop_diff.get(self.CONFIGURED_ROUTE_TARGET_LIST, {}).get(self.CONFIGURED_ROUTE_TARGET_LIST_ROUTE_TARGET))):
obj_1.add_route_target(prop_diff.get(self.CONFIGURED_ROUTE_TARGET_LIST, {}).get(self.CONFIGURED_ROUTE_TARGET_LIST_ROUTE_TARGET)[index_1])
obj_0.set_configured_route_target_list(obj_1)
# reference to virtual_network_refs
ref_obj_list = []
ref_data_list = []
if self.VIRTUAL_NETWORK_REFS in prop_diff:
for index_0 in range(len(prop_diff.get(self.VIRTUAL_NETWORK_REFS) or [])):
try:
ref_obj = self.vnc_lib().virtual_network_read(
id=prop_diff.get(self.VIRTUAL_NETWORK_REFS)[index_0]
)
except:
ref_obj = self.vnc_lib().virtual_network_read(
fq_name_str=prop_diff.get(self.VIRTUAL_NETWORK_REFS)[index_0]
)
ref_obj_list.append(ref_obj.fq_name)
obj_0.set_virtual_network_list(ref_obj_list)
# End: reference to virtual_network_refs
# reference to service_instance_refs
ref_obj_list = []
ref_data_list = []
if self.SERVICE_INSTANCE_REFS in prop_diff:
for index_0 in range(len(prop_diff.get(self.SERVICE_INSTANCE_REFS) or [])):
try:
ref_obj = self.vnc_lib().service_instance_read(
id=prop_diff.get(self.SERVICE_INSTANCE_REFS)[index_0]
)
except:
ref_obj = self.vnc_lib().service_instance_read(
fq_name_str=prop_diff.get(self.SERVICE_INSTANCE_REFS)[index_0]
)
ref_obj_list.append(ref_obj.fq_name)
obj_0.set_service_instance_list(ref_obj_list)
# End: reference to service_instance_refs
# reference to route_table_refs
ref_obj_list = []
ref_data_list = []
if self.ROUTE_TABLE_REFS in prop_diff:
for index_0 in range(len(prop_diff.get(self.ROUTE_TABLE_REFS) or [])):
try:
ref_obj = self.vnc_lib().route_table_read(
id=prop_diff.get(self.ROUTE_TABLE_REFS)[index_0]
)
except:
ref_obj = self.vnc_lib().route_table_read(
fq_name_str=prop_diff.get(self.ROUTE_TABLE_REFS)[index_0]
)
ref_obj_list.append(ref_obj.fq_name)
obj_0.set_route_table_list(ref_obj_list)
# End: reference to route_table_refs
# reference to virtual_machine_interface_refs
ref_obj_list = []
ref_data_list = []
if self.VIRTUAL_MACHINE_INTERFACE_REFS in prop_diff:
for index_0 in range(len(prop_diff.get(self.VIRTUAL_MACHINE_INTERFACE_REFS) or [])):
try:
ref_obj = self.vnc_lib().virtual_machine_interface_read(
id=prop_diff.get(self.VIRTUAL_MACHINE_INTERFACE_REFS)[index_0]
)
except:
ref_obj = self.vnc_lib().virtual_machine_interface_read(
fq_name_str=prop_diff.get(self.VIRTUAL_MACHINE_INTERFACE_REFS)[index_0]
)
ref_obj_list.append(ref_obj.fq_name)
obj_0.set_virtual_machine_interface_list(ref_obj_list)
# End: reference to virtual_machine_interface_refs
# reference to route_target_refs
ref_obj_list = []
ref_data_list = []
if self.ROUTE_TARGET_REFS in prop_diff:
for index_0 in range(len(prop_diff.get(self.ROUTE_TARGET_REFS) or [])):
try:
ref_obj = self.vnc_lib().route_target_read(
id=prop_diff.get(self.ROUTE_TARGET_REFS)[index_0]
)
except:
ref_obj = self.vnc_lib().route_target_read(
fq_name_str=prop_diff.get(self.ROUTE_TARGET_REFS)[index_0]
)
ref_obj_list.append(ref_obj.fq_name)
obj_0.set_route_target_list(ref_obj_list)
# End: reference to route_target_refs
try:
self.vnc_lib().logical_router_update(obj_0)
except:
raise Exception(_('logical-router %s could not be updated.') % self.name)
def handle_create(self):
parent_obj = None
if parent_obj is None and self.properties.get(self.PROJECT):
try:
parent_obj = self.vnc_lib().project_read(id=self.properties.get(self.PROJECT))
except vnc_api.NoIdError:
parent_obj = self.vnc_lib().project_read(fq_name_str=self.properties.get(self.PROJECT))
except:
parent_obj = None
if parent_obj is None:
tenant_id = self.stack.context.tenant_id
parent_obj = self.vnc_lib().project_read(id=str(uuid.UUID(tenant_id)))
if parent_obj is None:
raise Exception('Error: parent is not specified in template!')
obj_0 = vnc_api.LogicalRouter(name=self.properties[self.NAME],
parent_obj=parent_obj)
if self.properties.get(self.DISPLAY_NAME) is not None:
obj_0.set_display_name(self.properties.get(self.DISPLAY_NAME))
if self.properties.get(self.CONFIGURED_ROUTE_TARGET_LIST) is not None:
obj_1 = vnc_api.RouteTargetList()
if self.properties.get(self.CONFIGURED_ROUTE_TARGET_LIST, {}).get(self.CONFIGURED_ROUTE_TARGET_LIST_ROUTE_TARGET) is not None:
for index_1 in range(len(self.properties.get(self.CONFIGURED_ROUTE_TARGET_LIST, {}).get(self.CONFIGURED_ROUTE_TARGET_LIST_ROUTE_TARGET))):
obj_1.add_route_target(self.properties.get(self.CONFIGURED_ROUTE_TARGET_LIST, {}).get(self.CONFIGURED_ROUTE_TARGET_LIST_ROUTE_TARGET)[index_1])
obj_0.set_configured_route_target_list(obj_1)
# reference to virtual_network_refs
if self.properties.get(self.VIRTUAL_NETWORK_REFS):
for index_0 in range(len(self.properties.get(self.VIRTUAL_NETWORK_REFS))):
try:
ref_obj = self.vnc_lib().virtual_network_read(
id=self.properties.get(self.VIRTUAL_NETWORK_REFS)[index_0]
)
except vnc_api.NoIdError:
ref_obj = self.vnc_lib().virtual_network_read(
fq_name_str=self.properties.get(self.VIRTUAL_NETWORK_REFS)[index_0]
)
obj_0.add_virtual_network(ref_obj)
# reference to service_instance_refs
if self.properties.get(self.SERVICE_INSTANCE_REFS):
for index_0 in range(len(self.properties.get(self.SERVICE_INSTANCE_REFS))):
try:
ref_obj = self.vnc_lib().service_instance_read(
id=self.properties.get(self.SERVICE_INSTANCE_REFS)[index_0]
)
except vnc_api.NoIdError:
ref_obj = self.vnc_lib().service_instance_read(
fq_name_str=self.properties.get(self.SERVICE_INSTANCE_REFS)[index_0]
)
obj_0.add_service_instance(ref_obj)
# reference to route_table_refs
if self.properties.get(self.ROUTE_TABLE_REFS):
for index_0 in range(len(self.properties.get(self.ROUTE_TABLE_REFS))):
try:
ref_obj = self.vnc_lib().route_table_read(
id=self.properties.get(self.ROUTE_TABLE_REFS)[index_0]
)
except vnc_api.NoIdError:
ref_obj = self.vnc_lib().route_table_read(
fq_name_str=self.properties.get(self.ROUTE_TABLE_REFS)[index_0]
)
obj_0.add_route_table(ref_obj)
# reference to virtual_machine_interface_refs
if self.properties.get(self.VIRTUAL_MACHINE_INTERFACE_REFS):
for index_0 in range(len(self.properties.get(self.VIRTUAL_MACHINE_INTERFACE_REFS))):
try:
ref_obj = self.vnc_lib().virtual_machine_interface_read(
id=self.properties.get(self.VIRTUAL_MACHINE_INTERFACE_REFS)[index_0]
)
except vnc_api.NoIdError:
ref_obj = self.vnc_lib().virtual_machine_interface_read(
fq_name_str=self.properties.get(self.VIRTUAL_MACHINE_INTERFACE_REFS)[index_0]
)
obj_0.add_virtual_machine_interface(ref_obj)
# reference to route_target_refs
if self.properties.get(self.ROUTE_TARGET_REFS):
for index_0 in range(len(self.properties.get(self.ROUTE_TARGET_REFS))):
try:
ref_obj = self.vnc_lib().route_target_read(
id=self.properties.get(self.ROUTE_TARGET_REFS)[index_0]
)
except vnc_api.NoIdError:
ref_obj = self.vnc_lib().route_target_read(
fq_name_str=self.properties.get(self.ROUTE_TARGET_REFS)[index_0]
)
obj_0.add_route_target(ref_obj)
try:
obj_uuid = super(ContrailLogicalRouter, self).resource_create(obj_0)
except:
raise Exception(_('logical-router %s could not be updated.') % self.name)
self.resource_id_set(obj_uuid)
def create_rt_list(rts, asn):
rtl = vnc_api.RouteTargetList()
for rt in rts:
tar = "target:" + str(asn) + ":" + str(rt)
rtl.add_route_target(tar)
return rtl
vnc = vnc_api.VncApi(username="******",
password="******",
tenant_name="admin",
api_server_host="Contrail_IP")
tenant = vnc.project_read(fq_name=['default-domain', 'vCenter'])
ipam = vnc.network_ipam_read(
fq_name=['default-domain', 'vCenter', 'vCenter-ipam'])
for subnet in subnets:
start_addr = str(subnet[10])
end_addr = str(subnet[100])
vn = vnc_api.VirtualNetwork(name="Customer_" + str(network_number),
parent_obj=tenant)
cidr = str(subnet)
print subnet, "RD", str(AS) + ":" + str(network_number)
prefix, prefix_len = cidr.split('/')
subnet = vnc_api.SubnetType(ip_prefix=prefix, ip_prefix_len=prefix_len)
alloc_pools = []
alloc_pools.append(
vnc_api.AllocationPoolType(start=start_addr, end=end_addr))
ipam_subnet = vnc_api.IpamSubnetType(subnet=subnet,
advertise_default=True,
allocation_pools=alloc_pools)
vn.set_network_ipam(ref_obj=ipam,
ref_data=vnc_api.VnSubnetsType([ipam_subnet]))
route_targets = vnc_api.RouteTargetList(
['target:' + str(AS) + ":" + str(network_number)])
vn.set_route_target_list(route_targets)
vnc.virtual_network_create(vn)
network_number = network_number + 1