def setUp(self):
super(TestPnfServiceAppliance, self).setUp()
logger.debug("setUp called")
# Create Global system config object
self.gsc_obj = self.api.global_system_config_read(
GlobalSystemConfig().fq_name)
self.default_gsc_name = 'default-global-system-config'
# Create Service Appliance Set object
self.sas_obj = ServiceApplianceSet('sas-' + self.id(), self.gsc_obj)
self.sas_obj.set_service_appliance_set_virtualization_type(
'physical-device')
self.api.service_appliance_set_create(self.sas_obj)
# Create PNF Physical Router object
self.pnf_obj = PhysicalRouter('pnf-' + self.id(), self.gsc_obj)
self.pnf_obj.set_physical_router_role('pnf')
self.api.physical_router_create(self.pnf_obj)
# Create spine Physical Router object
self.spine_obj = PhysicalRouter('spine-' + self.id(), self.gsc_obj)
self.api.physical_router_create(self.spine_obj)
# create left, right PNF PI
self.left_pnf_pi_obj = PhysicalInterface(
'ge-0/0/1-' + self.id(), parent_obj=self.pnf_obj)
self.right_pnf_pi_obj = PhysicalInterface(
'ge-0/0/2-' + self.id(), parent_obj=self.pnf_obj)
self.api.physical_interface_create(self.left_pnf_pi_obj)
self.api.physical_interface_create(self.right_pnf_pi_obj)
# create left, right spine PI
self.left_spine_pi_obj = PhysicalInterface(
'xe-0/0/1-' + self.id(), parent_obj=self.spine_obj)
self.right_spine_pi_obj = PhysicalInterface(
'xe-0/0/2-' + self.id(), parent_obj=self.spine_obj)
self.api.physical_interface_create(self.left_spine_pi_obj)
self.api.physical_interface_create(self.right_spine_pi_obj)
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApiAdmin(self._args.use_admin_api,
self._args.admin_user,
self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/')
vnc = self._vnc_lib
gsc_uuid = vnc.global_system_configs_list(
)['global-system-configs'][0]['uuid']
gsc = vnc.global_system_config_read(id=gsc_uuid)
if hasattr(self._args, 'add'):
print('Add -> ', ', '.join(self._args.add))
g = GlobalSystemConfig()
g.add_user_defined_log_statistics(
UserDefinedLogStat(*self._args.add))
vnc.global_system_config_update(g)
elif hasattr(self._args, 'delete'):
print('Delete -> ', ', '.join(self._args.delete))
if gsc.user_defined_log_statistics:
gsc.user_defined_log_statistics.statlist = [
x for x in gsc.user_defined_log_statistics.statlist
if x.name not in self._args.delete
]
gsc.set_user_defined_log_statistics(
gsc.user_defined_log_statistics)
vnc.global_system_config_update(gsc)
elif hasattr(self._args, 'list'):
print('ls -> ', ', '.join(self._args.list))
print('Configured:')
if gsc.user_defined_log_statistics:
for x in gsc.user_defined_log_statistics.statlist:
if self._chk2print(x.name):
print('Name: "%s", Pattern: "%s"' %
(x.name, x.pattern))
def __init__(self, args_str=None):
self._args = None
if not args_str:
args_str = ' '.join(sys.argv[1:])
self._parse_args(args_str)
self._vnc_lib = VncApi(self._args.admin_user,
self._args.admin_password,
self._args.admin_tenant_name,
self._args.api_server_ip,
self._args.api_server_port, '/')
vnc = self._vnc_lib
gsc_uuid = vnc.global_system_configs_list()['global-system-configs'][
0]['uuid']
gsc = vnc.global_system_config_read(id=gsc_uuid)
if hasattr(self._args, 'add'):
print 'Add -> ', ', '.join(self._args.add)
g=GlobalSystemConfig()
g.add_user_defined_log_statistics(UserDefinedLogStat(
*self._args.add))
vnc.global_system_config_update(g)
elif hasattr(self._args, 'delete'):
print 'Delete -> ', ', '.join(self._args.delete)
if gsc.user_defined_log_statistics:
gsc.user_defined_log_statistics.statlist = filter(
lambda x: x.name not in self._args.delete,
gsc.user_defined_log_statistics.statlist)
gsc.set_user_defined_log_statistics(
gsc.user_defined_log_statistics)
vnc.global_system_config_update(gsc)
elif hasattr(self._args, 'list'):
print 'ls -> ', ', '.join(self._args.list)
print 'Configured:'
if gsc.user_defined_log_statistics:
for x in gsc.user_defined_log_statistics.statlist:
if self._chk2print(x.name):
print 'Name: "%s", Pattern: "%s"' % (x.name, x.pattern)
def _get_config_object(self, config_type, config_dict):
if config_type == 'global-system-config':
return GlobalSystemConfig(name=config_dict['name'])
elif config_type == 'alarm':
alarm_or_list = []
for and_list in config_dict['alarm_rules']['or_list']:
alarm_and_list = []
for exp in and_list['and_list']:
alarm_and_list.append(
AlarmExpression(operation=exp['operation'],
operand1=exp['operand1'],
operand2=exp['operand2'],
variables=exp.get('variables')))
alarm_or_list.append(AlarmAndList(alarm_and_list))
return Alarm(name=config_dict['name'],
uve_keys=UveKeysType(config_dict['uve_keys']),
alarm_severity=config_dict['alarm_severity'],
alarm_rules=AlarmOrList(alarm_or_list),
**config_dict['kwargs'])
return None
def test_more_than_one_sas_per_st(self):
si_obj = self.api.service_instance_read(id=self.si_uuid)
left_lr_obj = self.api.logical_router_read(id=self.left_lr_uuid)
right_lr_obj = self.api.logical_router_read(id=self.right_lr_uuid)
pt_obj = PortTuple('pt-' + self.id(), parent_obj=si_obj)
pt_obj.add_logical_router(left_lr_obj)
pt_obj.add_logical_router(right_lr_obj)
kvp_array = []
kvp = KeyValuePair("left-lr", self.left_lr_uuid)
kvp_array.append(kvp)
kvp = KeyValuePair("right-lr", self.right_lr_uuid)
kvp_array.append(kvp)
kvps = KeyValuePairs()
kvps.set_key_value_pair(kvp_array)
pt_obj.set_annotations(kvps)
# Add another SAS to the ST
gsc_obj = self.api.global_system_config_read(
GlobalSystemConfig().fq_name)
sas_obj = ServiceApplianceSet('sas1-' + self.id(), gsc_obj)
sas_obj.set_service_appliance_set_virtualization_type(
'physical-device')
self.api.service_appliance_set_create(sas_obj)
st_obj = self.api.service_template_read(id=self.st_uuid)
st_obj.add_service_appliance_set(sas_obj)
self.api.service_template_update(st_obj)
st_obj = self.api.service_template_read(id=self.st_uuid)
# Create PT
self.api.port_tuple_create(pt_obj)
# Make sure no LI or IIP is created in this case
li_list_len = \
len(self.api.logical_interfaces_list().get('logical-interfaces'))
self.assertEqual(li_list_len, 0)
iip_list_len = \
len(self.api.instance_ips_list().get('instance-ips'))
self.assertEqual(iip_list_len, 0)
# cleanup
st_obj.del_service_appliance_set(sas_obj)
self.api.service_template_update(st_obj)
self.api.service_appliance_set_delete(id=sas_obj.uuid)
self.api.port_tuple_delete(id=pt_obj.uuid)
pass
def setUp(self):
super(TestPnfServiceInstance, self).setUp()
logger.debug("setUp called")
# Create Global system config object
gsc_obj = self.api.global_system_config_read(
GlobalSystemConfig().fq_name)
# Create Service Appliance Set object
sas_obj = ServiceApplianceSet('sas-' + self.id(), gsc_obj)
sas_obj.set_service_appliance_set_virtualization_type(
'physical-device')
self.sas_uuid = self.api.service_appliance_set_create(sas_obj)
# Create Service template object
self.st_obj = ServiceTemplate(name='st-' + self.id())
self.st_obj.set_service_appliance_set(sas_obj)
svc_properties = ServiceTemplateType()
svc_properties.set_service_virtualization_type('physical-device')
if_type = ServiceTemplateInterfaceType()
if_type.set_service_interface_type('left')
svc_properties.add_interface_type(if_type)
if_type = ServiceTemplateInterfaceType()
if_type.set_service_interface_type('right')
svc_properties.add_interface_type(if_type)
self.st_obj.set_service_template_properties(svc_properties)
self.st_uuid = self.api.service_template_create(self.st_obj)
def setUp(self):
def _carve_out_subnets(subnets, cidr):
carved_subnets = []
for subnet in subnets:
slash_x_subnets = IPNetwork(subnet.get('cidr')).subnet(cidr)
for slash_x_sn in slash_x_subnets:
carved_subnets.append({'cidr': str(slash_x_sn)})
return carved_subnets
# end _carve_out_subnets
def _get_network_ipam(ipam_name, subnets, subnetting):
def _new_subnet(cidr):
split_cidr = cidr.split('/')
return SubnetType(
ip_prefix=split_cidr[0],
ip_prefix_len=split_cidr[1])
# end _new_subnet
ipam = NetworkIpam(
name=ipam_name,
ipam_subnets=IpamSubnets([
IpamSubnetType(
subnet=_new_subnet(sn.get('cidr')),
default_gateway=sn.get('gateway'),
subnet_uuid=str(uuid.uuid1())
) for sn in subnets if int(
sn.get('cidr').split('/')[-1]) < 31
]),
ipam_subnet_method='flat-subnet',
ipam_subnetting=subnetting
)
return ipam
# end _add_network_ipam
super(TestPnfPortTuple, self).setUp()
logger.debug("setUp called")
# Create Global objects
default_gsc_name = 'default-global-system-config'
gsc_obj = self.api.global_system_config_read(
GlobalSystemConfig().fq_name)
proj_obj = self.api.project_read(Project().fq_name)
# Create PNF and spine Physical Router
pnf_obj = PhysicalRouter('pnf-' + self.id(), gsc_obj)
pnf_obj.set_physical_router_role('pnf')
self.pnf_uuid = self.api.physical_router_create(pnf_obj)
# Create spine Physical Router
spine_obj = PhysicalRouter('spine-' + self.id(), gsc_obj)
self.spine_uuid = self.api.physical_router_create(spine_obj)
# Create left/right LR
left_lr_name = 'left_lr-' + self.id()
left_lr_obj = LogicalRouter(name=left_lr_name, parent_obj=proj_obj)
left_lr_obj.add_physical_router(spine_obj)
self.left_lr_uuid = self.api.logical_router_create(left_lr_obj)
right_lr_name = 'right_lr-' + self.id()
right_lr_obj = LogicalRouter(name=right_lr_name, parent_obj=proj_obj)
right_lr_obj.add_physical_router(spine_obj)
self.right_lr_uuid = self.api.logical_router_create(right_lr_obj)
# create left, right PNF PI
left_pnf_pi_obj = PhysicalInterface(
'ge-0/0/1-' + self.id(), parent_obj=pnf_obj)
right_pnf_pi_obj = PhysicalInterface(
'ge-0/0/2-' + self.id(), parent_obj=pnf_obj)
lo_pnf_pi_obj = PhysicalInterface('lo0', parent_obj=pnf_obj)
self.left_pnf_pi_uuid = self.api.physical_interface_create(
left_pnf_pi_obj)
self.right_pnf_pi_uuid = self.api.physical_interface_create(
right_pnf_pi_obj)
self.lo_pnf_pi_uuid = self.api.physical_interface_create(lo_pnf_pi_obj)
# create left, right spine PI
left_spine_pi_obj = PhysicalInterface(
'xe-0/0/1-' + self.id(), parent_obj=spine_obj)
right_spine_pi_obj = PhysicalInterface(
'xe-0/0/2-' + self.id(), parent_obj=spine_obj)
self.left_spine_pi_uuid = self.api.physical_interface_create(
left_spine_pi_obj)
self.right_spine_pi_uuid = self.api.physical_interface_create(
right_spine_pi_obj)
# Create Service Appliance Set
sas_obj = ServiceApplianceSet('sas-' + self.id(), gsc_obj)
sas_obj.set_service_appliance_set_virtualization_type(
'physical-device')
self.sas_uuid = self.api.service_appliance_set_create(sas_obj)
# Create Service template
st_obj = ServiceTemplate(name='st-' + self.id())
st_obj.set_service_appliance_set(sas_obj)
svc_properties = ServiceTemplateType()
svc_properties.set_service_virtualization_type('physical-device')
if_type = ServiceTemplateInterfaceType()
if_type.set_service_interface_type('left')
svc_properties.add_interface_type(if_type)
if_type = ServiceTemplateInterfaceType()
if_type.set_service_interface_type('right')
svc_properties.add_interface_type(if_type)
st_obj.set_service_template_properties(svc_properties)
self.st_uuid = self.api.service_template_create(st_obj)
# Create Service Instance object
si_fqn = ['default-domain', 'default-project', 'si-' + self.id()]
si_obj = ServiceInstance(fq_name=si_fqn)
si_obj.fq_name = si_fqn
si_obj.add_service_template(st_obj)
kvp_array = []
kvp = KeyValuePair("left-svc-vlan", "100")
kvp_array.append(kvp)
kvp = KeyValuePair("right-svc-vlan", "101")
kvp_array.append(kvp)
kvp = KeyValuePair("left-svc-asns", "66000,66001")
kvp_array.append(kvp)
kvp = KeyValuePair("right-svc-asns", "66000,66002")
kvp_array.append(kvp)
kvps = KeyValuePairs()
kvps.set_key_value_pair(kvp_array)
si_obj.set_annotations(kvps)
props = ServiceInstanceType()
props.set_service_virtualization_type('physical-device')
props.set_ha_mode("active-standby")
si_obj.set_service_instance_properties(props)
self.si_uuid = self.api.service_instance_create(si_obj)
# Create service appliance
sa_obj = ServiceAppliance('sa-' + self.id(), parent_obj=sas_obj)
kvp_array = []
kvp = KeyValuePair(
"left-attachment-point",
default_gsc_name +
':' +
'spine-' +
self.id() +
':' +
'xe-0/0/1-' +
self.id())
kvp_array.append(kvp)
kvp = KeyValuePair(
"right-attachment-point",
default_gsc_name +
':' +
'spine-' +
self.id() +
':' +
'xe-0/0/2-' +
self.id())
kvp_array.append(kvp)
kvps = KeyValuePairs()
kvps.set_key_value_pair(kvp_array)
sa_obj.set_service_appliance_properties(kvps)
sa_obj.set_service_appliance_virtualization_type('physical-device')
attr = ServiceApplianceInterfaceType(interface_type='left')
sa_obj.add_physical_interface(left_pnf_pi_obj, attr)
attr = ServiceApplianceInterfaceType(interface_type='right')
sa_obj.add_physical_interface(right_pnf_pi_obj, attr)
self.sa_uuid = self.api.service_appliance_create(sa_obj)
# Create fabric and add it to spine and PNF
fab_obj = Fabric('fab-' + self.id())
self.fab_uuid = self.api.fabric_create(fab_obj)
pnf_obj.add_fabric(fab_obj)
self.api.physical_router_update(pnf_obj)
spine_obj.add_fabric(fab_obj)
self.api.physical_router_update(spine_obj)
fab_obj = self.api.fabric_read(id=self.fab_uuid)
# Create PNF service chain IPAM/network
pnf_cidr = [{'cidr': "10.1.1.0/28"}]
peer_subnets = _carve_out_subnets(pnf_cidr, 29)
pnf_vn_obj = VirtualNetwork(
name='fab-' + self.id() + '-pnf-servicechain-network',
virtual_network_properties=VirtualNetworkType(
forwarding_mode='l3'),
address_allocation_mode='flat-subnet-only')
self.pnf_vn_uuid = self.api.virtual_network_create(pnf_vn_obj)
pnf_ipam_obj = _get_network_ipam(
'fab-' +
self.id() +
'-pnf-servicechain-network-ipam',
peer_subnets,
True)
self.pnf_ipam_uuid = self.api.network_ipam_create(pnf_ipam_obj)
pnf_vn_obj.add_network_ipam(pnf_ipam_obj, VnSubnetsType([]))
self.api.virtual_network_update(pnf_vn_obj)
fab_obj = self.api.fabric_read(id=self.fab_uuid)
fab_obj.add_virtual_network(
pnf_vn_obj, FabricNetworkTag(
network_type='pnf-servicechain'))
self.api.fabric_update(fab_obj)
# Create loopback IPAM/network
lo_cidr = [{'cidr': "100.100.100.0/28"}]
peer_subnets = _carve_out_subnets(lo_cidr, 28)
lo_vn_obj = VirtualNetwork(
name='fab-' + self.id() + '-loopback-network',
virtual_network_properties=VirtualNetworkType(
forwarding_mode='l3'),
address_allocation_mode='flat-subnet-only')
self.lo_vn_uuid = self.api.virtual_network_create(lo_vn_obj)
lo_ipam_obj = _get_network_ipam(
'fab-' +
self.id() +
'-loopback-network-ipam',
peer_subnets,
False)
self.lo_ipam_uuid = self.api.network_ipam_create(lo_ipam_obj)
lo_vn_obj.add_network_ipam(lo_ipam_obj, VnSubnetsType([]))
self.api.virtual_network_update(lo_vn_obj)
fab_obj = self.api.fabric_read(id=self.fab_uuid)
fab_obj.add_virtual_network(
lo_vn_obj, FabricNetworkTag(
network_type='loopback'))
self.api.fabric_update(fab_obj)