def build_ifs_from_props(node_props: dict) -> InterfaceSliver: """ Build Interface Sliver from the node properties @param node_props Node properties @return Interface Sliver """ ifs = InterfaceSliver() ifs.node_id = node_props[ABCPropertyGraph.NODE_ID] cap_json = node_props.get(ABCPropertyGraph.PROP_CAPACITIES, None) labels_json = node_props.get(ABCPropertyGraph.PROP_LABELS, None) ifs.set_properties(name=node_props[ABCPropertyGraph.PROP_NAME], type=node_props[ABCPropertyGraph.PROP_TYPE]) if cap_json is not None: ifs.set_capacities(cap=Capacities().from_json(cap_json)) if labels_json is not None: ifs.set_labels(lab=Labels().from_json(labels_json)) return ifs
def test_PortMirror(self): # create a NetworkService sliver for FABNetv6 prop = { AmConstants.CONFIG_PROPERTIES_FILE: '../config/net_handler_config.yml' } handler = NetHandler(logger=self.logger, properties=prop, process_lock=threading.Lock()) # # create a network sliver for FABNetv4 and its interfaces # sliver = NetworkServiceSliver() # service name (set by user) - only guaranteed unique within a slice sliver.set_name('PortMirror-UKY') sliver.set_type(ServiceType.PortMirror) sliver.set_layer(NSLayer.L2) # mirror_port is the name of the port being mirrored - actual name the way # service definition needs it. It comes directly from ASM network service sliver # whatever the right name is - user must to know it when creating a slice sliver.mirror_port = "TwentyFiveGigE0/0/0/24" # direction also comes from ASM network service sliver sliver.mirror_direction = MirrorDirection.Both # # interface to which the mirrored traffic is directed to # it is in the slice (ASM) model, the same way all other interfaces for network services are. # stp_to = InterfaceSliver() stp_to.set_name('Interface_To_Which_We_Send_Mirrored_Traffic') stp_to.set_type(InterfaceType.ServicePort) sliver_labels = Labels(local_name='TwentyFiveGigE0/0/0/23/1', device_name='lbnl-data-sw') sliver_capacities = Capacities(bw=2000) stp_to.set_labels(sliver_labels) stp_to.set_capacities(sliver_capacities) # create interface info object, add populated interfaces to it ifi = InterfaceInfo() ifi.add_interface(stp_to) # add interface info object to sliver. All of this happens automagically normally sliver.interface_info = ifi # set a fake unit reservation uid = uuid.uuid3(uuid.NAMESPACE_DNS, 'test_PortMirror') self.unit = Unit(rid=ID(uid=str(uid))) self.unit.set_sliver(sliver=sliver) # # create a service (create needs to parse out sliver information # into exact parameters the service ansible script needs) # r, updated_unit = handler.create(unit=self.unit) self.assertEqual(r[Constants.PROPERTY_TARGET_NAME], Constants.TARGET_CREATE) self.assertEqual(r[Constants.PROPERTY_ACTION_SEQUENCE_NUMBER], 0) self.assertEqual(r[Constants.PROPERTY_TARGET_RESULT_CODE], Constants.RESULT_CODE_OK) time.sleep(30) # # delete - need to make sure the updated unit has the right info to delete the service # r, updated_unit = handler.delete(updated_unit) self.assertEqual(r[Constants.PROPERTY_TARGET_NAME], Constants.TARGET_DELETE) self.assertEqual(r[Constants.PROPERTY_ACTION_SEQUENCE_NUMBER], 0) self.assertEqual(r[Constants.PROPERTY_TARGET_RESULT_CODE], Constants.RESULT_CODE_OK)
def test_FABNetv6(self): # create a NetworkService sliver for FABNetv6 prop = { AmConstants.CONFIG_PROPERTIES_FILE: '../config/net_handler_config.yml' } handler = NetHandler(logger=self.logger, properties=prop, process_lock=threading.Lock()) # # create a network sliver for FABNetv4 and its interfaces # sliver = NetworkServiceSliver() # service name (set by user) - only guaranteed unique within a slice sliver.set_name('L3-UKY-IPv6') # if service name global uniqueness is a requirement use Labels.local_name for that (optional) # e.g. concatenate name + res id (or another unique id) # sliver.set_labels(Labels().set_fields(local_name='test-l2bridge-shortname')) # per @xiyang he uses unit id for service name so this is not needed. sliver.set_type(ServiceType.FABNetv6) sliver.set_layer(NSLayer.L3) # this is the gateway with the IP range picked for this sliver in this slice on this site # can also be specified with ipv6/ipv6_subnet and mac is optional for both. # Q: does that mean that the advertisement needs to maintain information about multiple # subnet, gateway and mac tuples for each site? sliver.set_gateway( Gateway( Labels(ipv6="2602:FCFB:0001::1", ipv6_subnet="2602:FCFB:0001::/64"))) # # create a small number of Interface slivers, set their properties and link to service # # # First interface - let's assume it is SR-IOV # isl1 = InterfaceSliver() # the name is normally set by FIM as '-' concatenation of service name isl1.set_name('Interface1') # this will be a ServicePort in the network service sliver. It is created by FIM automatically when # the user adds a NetworkService to the ASM. The name is set by the FIM as '-' concatenation of service # name and peer interface sliver name. isl1.set_type(InterfaceType.ServicePort) # since this is SR-IOV, orchestrator picks VLAN for this function based on info in advertisement # other information is done in the same way it is done for L2 services sliver_labels = Labels(vlan='121', local_name='HundredGigE0/0/0/5', device_name='uky-data-sw') # capacities (bw in Gbps, burst size is in Mbytes) source: (b) sliver_capacities = Capacities(bw=1) # assign labels and capacities isl1.set_labels(sliver_labels) isl1.set_capacities(sliver_capacities) # # Second interface (let's assume this is a dedicated card) # isl2 = InterfaceSliver() isl2.set_name('Interface2') isl2.set_type(InterfaceType.ServicePort) # Q: who and how picks the VLAN in this case? I think we discussed having an advertised pool of 'Layer 3 # vlans' which need to be kept track of and this would be one of them # other information is done in the same way it is done for L2 services sliver_labels = Labels(vlan='1001', local_name='HundredGigE0/0/0/5', device_name='uky-data-sw') sliver_capacities = Capacities(bw=1) isl2.set_labels(sliver_labels) isl2.set_capacities(sliver_capacities) # create interface info object, add populated interfaces to it ifi = InterfaceInfo() ifi.add_interface(isl1) ifi.add_interface(isl2) # add interface info object to sliver. All of this happens automagically normally sliver.interface_info = ifi # set a fake unit reservation uid = uuid.uuid3(uuid.NAMESPACE_DNS, 'test_FABNetv6') self.unit = Unit(rid=ID(uid=str(uid))) self.unit.set_sliver(sliver=sliver) # # create a service (create needs to parse out sliver information # into exact parameters the service ansible script needs) # r, updated_unit = handler.create(unit=self.unit) self.assertEqual(r[Constants.PROPERTY_TARGET_NAME], Constants.TARGET_CREATE) self.assertEqual(r[Constants.PROPERTY_ACTION_SEQUENCE_NUMBER], 0) self.assertEqual(r[Constants.PROPERTY_TARGET_RESULT_CODE], Constants.RESULT_CODE_OK) time.sleep(30) # # delete - need to make sure the updated unit has the right info to delete the service # r, updated_unit = handler.delete(updated_unit) self.assertEqual(r[Constants.PROPERTY_TARGET_NAME], Constants.TARGET_DELETE) self.assertEqual(r[Constants.PROPERTY_ACTION_SEQUENCE_NUMBER], 0) self.assertEqual(r[Constants.PROPERTY_TARGET_RESULT_CODE], Constants.RESULT_CODE_OK)
def test_L2Bridge(self): # create a NetworkService sliver for L2Bridge prop = { AmConstants.CONFIG_PROPERTIES_FILE: '../config/net_handler_config.yml' } handler = NetHandler(logger=self.logger, properties=prop) # # create a network sliver for L2Bridge and its interfaces # sliver = NetworkServiceSliver() # service name (set by user) - only guaranteed unique within a slice sliver.set_name('L2BridgeServiceTest') # if service name global uniqueness is a requirement use Labels.local_name for that (optional) # e.g. concatenate name + res id (or another unique id) # sliver.set_labels(Labels().set_fields(local_name='test-l2bridge-shortname')) # per @xiyang he uses unit id for service name so this is not needed. sliver.set_type(ServiceType.L2Bridge) sliver.set_layer(NSLayer.L2) # Interface properties # # The service definitions make a distinction between interface which requires # type = parse(InterfaceSliver.Labels.local_name) # id = parse(InterfaceSliver.Labels.local_name) # outervlan = InterfaceSliver.Labels.vlan # innervlan = InterfaceSliver.Labels.inner_vlan # bw = InterfaceSliver.Capacities.bw (0 - best-effort) # burst size = InterfaceSliver.Capacities.burst_size # # and STP which in addition also requires NSO device name. # In deep network sliver NSO Device name goes on *each* interface, then handler.create can parse # out the interfaces and figure out which STP each interface goes with based on that. # NSO device name = InterfaceSliver.Labels.device_name # # The properties of InterfaceSlivers noted above must be copied by Orchestrator from various places # a) the switch TrunkPort port the ASM ServicePort maps to in CBM # b) the Shared or Dedicated ASM port on the card the ServicePort peers with in ASM # c) the Shared or Dedicated CBM port the peer ASM port maps to # Below for each property comments indicate where they come from by a, b, c # Orchestrator determines peer ports in ASM (between ServicePort and corresponding Shared/Dedicated card port) # and sets nodemaps to point from ASM ServicePort to corresponding CBM TrunkPort # as well as between Shared/Dedicated ASM port on the NIC and the corresponding CBM Shared/Dedicated port # # create a small number of Interface slivers, set their properties and link to service # isl1 = InterfaceSliver() # the name is set by FIM as '-' concatenation of service name isl1.set_name('Interface1') # this will be a ServicePort in the network service sliver. It is created by FIM automatically when # the user adds a NetworkService to the ASM. The name is set by the FIM as '-' concatenation of service # name and peer interface sliver name. isl1.set_type(InterfaceType.ServicePort) sliver_labels = Labels() sliver_capacities = Capacities() # inner_vlan - not used for now - user would fill it in directly on the sliver Labels - # need to discuss. # sl1labs.set_fields(inner_vlan='3') # vlan - source: (c) sliver_labels.set_fields(vlan='100') # local_name source: (a) sliver_labels.set_fields(local_name='HundredGigE0/0/0/17') # NSO device name source: (a) - need to find the owner switch of the network service in CBM # and take its .name or labels.local_name sliver_labels.set_fields(device_name='uky-data-sw') # capacities (bw in Gbps, burst size is in Mbytes) source: (b) sliver_capacities.set_fields(bw=1) # assign labels and capacities isl1.set_labels(sliver_labels) isl1.set_capacities(sliver_capacities) # # Second interface (comments for field info origin omitted below) # isl2 = InterfaceSliver() isl2.set_name('Interface2') isl2.set_type(InterfaceType.ServicePort) sliver_labels = Labels() sliver_capacities = Capacities() # sliver_labels.set_fields(vlan='102') sliver_labels.set_fields(local_name='TwentyFiveGigE0/0/0/23/1') sliver_labels.set_fields(device_name='uky-data-sw') sliver_capacities.set_fields(bw=1) isl2.set_labels(sliver_labels) isl2.set_capacities(sliver_capacities) # create interface info object, add populated interfaces to it ifi = InterfaceInfo() ifi.add_interface(isl1) ifi.add_interface(isl2) # add interface info object to sliver. All of this happens automagically normally sliver.interface_info = ifi # set a fake unit reservation uid = uuid.uuid3(uuid.NAMESPACE_DNS, 'test_L2Bridge') self.unit = Unit(rid=ID(uid=str(uid))) self.unit.set_sliver(sliver=sliver) # # create a service (create needs to parse out sliver information # into exact parameters the service ansible script needs) # r, updated_unit = handler.create(unit=self.unit) self.assertEqual(r[Constants.PROPERTY_TARGET_NAME], Constants.TARGET_CREATE) self.assertEqual(r[Constants.PROPERTY_ACTION_SEQUENCE_NUMBER], 0) self.assertEqual(r[Constants.PROPERTY_TARGET_RESULT_CODE], Constants.RESULT_CODE_OK) time.sleep(30) # # delete - need to make sure the updated unit has the right info to delete the service # r, updated_unit = handler.delete(updated_unit) self.assertEqual(r[Constants.PROPERTY_TARGET_NAME], Constants.TARGET_DELETE) self.assertEqual(r[Constants.PROPERTY_ACTION_SEQUENCE_NUMBER], 0) self.assertEqual(r[Constants.PROPERTY_TARGET_RESULT_CODE], Constants.RESULT_CODE_OK)
def test_L2STS(self): # create a NetworkService sliver for L2STS prop = { AmConstants.CONFIG_PROPERTIES_FILE: '../config/net_handler_config.yml' } handler = NetHandler(logger=self.logger, properties=prop) # # create a network sliver for L2Bridge and its interfaces # sliver = NetworkServiceSliver() # service name - can we use the sliver name - only guaranteed unique in the slice sliver.set_name('L2STSServiceTest') sliver.set_type(ServiceType.L2STS) sliver.set_layer(NSLayer.L2) # ERO # first declare a path. Each path is a list of somethings. a2z and z2a maintained separately within Path ero_path = Path() ero_path.set_symmetric(["10.1.1.1", "10.1.1.2"]) # default is loose ERO, set strict=True if want otherwise ero = ERO(strict=False) ero.set(ero_path) sliver.set_ero(ero) # # site A interfaces # stp_a1 = InterfaceSliver() stp_a1.set_name('Interface_A1') stp_a1.set_type(InterfaceType.ServicePort) sliver_labels = Labels() sliver_capacities = Capacities() # untagged w/o vlan label set sliver_labels.set_fields(local_name='TwentyFiveGigE0/0/0/23/1') sliver_labels.set_fields(device_name='lbnl-data-sw') sliver_capacities.set_fields(bw=2000) stp_a1.set_labels(sliver_labels) stp_a1.set_capacities(sliver_capacities) # # site Z interfaces # stp_z1 = InterfaceSliver() stp_z1.set_name('Interface_Z1') stp_z1.set_type(InterfaceType.ServicePort) sliver_labels = Labels() sliver_capacities = Capacities() sliver_labels.set_fields(vlan='235') sliver_labels.set_fields(local_name='HundredGigE0/0/0/13') sliver_labels.set_fields(device_name='uky-data-sw') sliver_capacities.set_fields(bw=1000) stp_z1.set_labels(sliver_labels) stp_z1.set_capacities(sliver_capacities) stp_z2 = InterfaceSliver() stp_z2.set_name('Interface_Z2') stp_z2.set_type(InterfaceType.ServicePort) sliver_labels = Labels() sliver_capacities = Capacities() # untagged w/o vlan label set sliver_labels.set_fields(local_name='TwentyFiveGigE0/0/0/23/2') sliver_labels.set_fields(device_name='uky-data-sw') sliver_capacities.set_fields(bw=1000) stp_z2.set_labels(sliver_labels) stp_z2.set_capacities(sliver_capacities) # create interface info object, add interfaces to it ifi = InterfaceInfo() ifi.add_interface(stp_a1) ifi.add_interface(stp_z1) ifi.add_interface(stp_z2) # All of this happens automagically in FIM sliver.interface_info = ifi uid = uuid.uuid3(uuid.NAMESPACE_DNS, 'test_L2STS') self.unit = Unit(rid=ID(uid=str(uid))) self.unit.set_sliver(sliver=sliver) # # create a service # r, updated_unit = handler.create(unit=self.unit) self.assertEqual(r[Constants.PROPERTY_TARGET_NAME], Constants.TARGET_CREATE) self.assertEqual(r[Constants.PROPERTY_ACTION_SEQUENCE_NUMBER], 0) self.assertEqual(r[Constants.PROPERTY_TARGET_RESULT_CODE], Constants.RESULT_CODE_OK) time.sleep(30) # # delete - need to make sure the updated unit has the right info to delete the service # r, updated_unit = handler.delete(updated_unit) self.assertEqual(r[Constants.PROPERTY_TARGET_NAME], Constants.TARGET_DELETE) self.assertEqual(r[Constants.PROPERTY_ACTION_SEQUENCE_NUMBER], 0) self.assertEqual(r[Constants.PROPERTY_TARGET_RESULT_CODE], Constants.RESULT_CODE_OK)
def testFlagsAndTags(self): isl = InterfaceSliver() isl.flags = Flags(auto_config=True) isl.tags = Tags('blue', 'soft') self.assertTrue('blue' in isl.tags) self.assertTrue(isl.flags.auto_config)
def create_unit(include_pci: bool = True, include_image: bool = True, include_name: bool = True, include_instance_name: bool = False, include_ns: bool = False) -> Unit: """ Create a unit :param include_pci: :param include_image: :param include_name: :param include_instance_name: :param include_ns: :return: """ u = Unit(rid=ID(uid="rid-1")) sliver = NodeSliver() cap = Capacities() cap.set_fields(core=4, ram=64, disk=500) catalog = InstanceCatalog() instance_type = catalog.map_capacities_to_instance(cap=cap) cap_hints = CapacityHints().set_fields(instance_type=instance_type) sliver.set_properties( type=NodeType.VM, site="RENC", capacity_hints=cap_hints, capacity_allocations=catalog.get_instance_capacities( instance_type=instance_type)) sliver.label_allocations = Labels().set_fields( instance_parent="renc-w1.fabric-testbed.net") if include_name: sliver.set_properties(name="n1") if include_image: sliver.set_properties(image_type='qcow2', image_ref='default_centos_8') if include_pci: component = ComponentSliver() labels = Labels() labels.set_fields(bdf=["0000:41:00.0", "0000:41:00.1"]) component.set_properties(type=ComponentType.SmartNIC, model='ConnectX-6', name='nic1', label_allocations=labels) sliver.attached_components_info = AttachedComponentsInfo() sliver.attached_components_info.add_device(device_info=component) if include_instance_name: sliver.label_allocations.set_fields(instance="instance-001") if include_ns: sliver.network_service_info = NetworkServiceInfo() ns = NetworkServiceSliver() ns.interface_info = InterfaceInfo() ifs1 = InterfaceSliver() c = Capacities() c.bw = 100 c.unit = 1 l1 = Labels() l1.ipv4 = '192.168.11.3' l1.vlan = '200' l1.local_name = 'p1' la_1 = Labels() la_1.mac = '0C:42:A1:EA:C7:51' la_1.vlan = '200' ifs1.capacities = c ifs1.labels = l1 ifs1.label_allocations = la_1 ifs2 = InterfaceSliver() ifs2.capacities = c l2 = Labels() l2.ipv4 = '192.168.11.2' l2.local_name = 'p2' la_2 = Labels() la_2.mac = '0C:42:A1:EA:C7:52' ifs2.labels = l2 ifs2.label_allocations = la_1 ns.interface_info.interfaces = {'ifs1': ifs1, 'ifs2': ifs2} sliver.network_service_info.network_services = {'ns1': ns} u.set_sliver(sliver=sliver) return u
def allocate_ifs( self, *, requested_ns: NetworkServiceSliver, requested_ifs: InterfaceSliver, owner_switch: NodeSliver, mpls_ns: NetworkServiceSliver, bqm_ifs_id: str, existing_reservations: List[ABCReservationMixin] ) -> InterfaceSliver: """ Allocate Interface Sliver - For L2 services, validate the VLAN tag specified is within the allowed range - For L3 services, - grab the VLAN from BQM Site specific NetworkService - exclude the VLAN already assigned to other Interface Sliver on the same port - allocate the first available VLAN to the Interface Sliver :param requested_ns: Requested NetworkService :param requested_ifs: Requested Interface Sliver :param owner_switch: BQM Owner site switch identified to serve the InterfaceSliver :param mpls_ns: BQM MPLS NetworkService identified to serve the InterfaceSliver :param bqm_ifs_id: BQM InterfaceSliver identified to serve the InterfaceSliver :param existing_reservations: Existing Reservations which also are served by the owner switch :return Interface Sliver updated with the allocated VLAN tag for FABNetv4 and FABNetv6 services :raises Exception if vlan tag range is not in the valid range for L2 services Return the sliver updated with the VLAN """ if requested_ns.get_layer() == NSLayer.L2: delegation_id, delegated_label = self._get_delegations( lab_cap_delegations=mpls_ns.get_label_delegations()) vlans = None if delegated_label.vlan_range is not None: vlans = delegated_label.vlan_range.split("-") if vlans is not None and requested_ifs.labels.vlan is not None and \ int(vlans[0]) > int(requested_ifs.labels.vlan) > int(vlans[1]): raise BrokerException( error_code=ExceptionErrorCode.FAILURE, msg=f"Vlan for L2 service is outside the allowed range " f"{mpls_ns.label_delegations.vlan_range}") else: for ns in owner_switch.network_service_info.network_services.values( ): if requested_ns.get_type() == ns.get_type(): # Grab Label Delegations delegation_id, delegated_label = self._get_delegations( lab_cap_delegations=ns.get_label_delegations()) # Get the VLAN range vlans = None vlan_range = None if delegated_label.vlan_range is not None: vlans = delegated_label.vlan_range.split("-") vlan_range = list(range(int(vlans[0]), int(vlans[1]))) # Exclude the already allocated VLANs and subnets if existing_reservations is not None: for reservation in existing_reservations: # For Active or Ticketed or Ticketing reservations; reduce the counts from available allocated_sliver = None if reservation.is_ticketing( ) and reservation.get_approved_resources( ) is not None: allocated_sliver = reservation.get_approved_resources( ).get_sliver() if (reservation.is_active() or reservation.is_ticketed()) and \ reservation.get_resources() is not None: allocated_sliver = reservation.get_resources( ).get_sliver() self.logger.debug( f"Existing res# {reservation.get_reservation_id()} allocated: {allocated_sliver}" ) if allocated_sliver is None: continue # Ignore reservations for L2 services if allocated_sliver.get_type() != ServiceType.FABNetv4 or \ allocated_sliver.get_type() != ServiceType.FABNetv6: continue if allocated_sliver.interface_info is None or allocated_sliver.interface_info.interfaces is None: continue for allocated_ifs in allocated_sliver.interface_info.interfaces.values( ): # Ignore the Interface Slivers not on the same port if allocated_ifs.get_node_map( )[0] != bqm_ifs_id: continue self.logger.debug( f"Excluding already allocated VLAN: " f"{allocated_ifs.label_allocations.vlan} to " f"res# {reservation.get_reservation_id()}") # Exclude VLANs on the allocated on the same port if vlan_range is not None and allocated_ifs.label_allocations.vlan in vlan_range: vlan_range.remove( int(allocated_sliver.label_allocations. vlan)) # Allocate the first available VLAN if vlan_range is not None: requested_ifs.labels.vlan = str(vlan_range[0]) requested_ifs.label_allocations = Labels( vlan=str(vlan_range[0])) break return requested_ifs