# Copyright 2014, 2017 IBM Corp. # # All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. """Wrappers for virtual networking objects.""" import copy from oslo_log import log as logging import pypowervm.const as c import pypowervm.entities as ent from pypowervm.i18n import _ import pypowervm.util as u import pypowervm.wrappers.base_partition as bp import pypowervm.wrappers.entry_wrapper as ewrap LOG = logging.getLogger(__name__) _PVID = 'PortVLANID' _VNETS = 'VirtualNetworks' _DRC_NAME = 'DynamicReconfigurationConnectorName' _VSW_NAME = 'SwitchName' _VSW_ID = 'SwitchID' _VSW_MODE = 'SwitchMode' _VSW_VIRT_NETS = _VNETS VSW_DEFAULT_VSWITCH = 'ETHERNET0' VSW_DEFAULT_VSWITCH_ID = 0 _VSW_DEFAULT_VSWITCH_API = 'ETHERNET0(Default)' _VSW_EL_ORDER = (_VSW_ID, _VSW_MODE, _VSW_NAME, _VSW_VIRT_NETS) SHARED_ETH_ADPT = 'SharedEthernetAdapter' _NB_CONTROL_CHANNEL_ID = 'ControlChannelID' _NB_FAILOVER = 'FailoverEnabled' _NB_LOADBALANCE = 'LoadBalancingEnabled' _NB_LGS = 'LoadGroups' _NB_PVID = _PVID NB_SEAS = 'SharedEthernetAdapters' _NB_DEV_ID = 'UniqueDeviceID' _NB_VNETS = _VNETS _NB_LG = 'LoadGroup' _NB_EL_ORDER = (_NB_CONTROL_CHANNEL_ID, _NB_FAILOVER, _NB_LOADBALANCE, _NB_LGS, _NB_PVID, NB_SEAS, _NB_DEV_ID, _NB_VNETS) ETH_BACK_DEV = 'EthernetBackingDevice' _SEA_VIO_HREF = 'AssignedVirtualIOServer' _SEA_CONTROL_CHANNEL = 'ControlChannelInterfaceName' _SEA_BACKING_DEV = 'BackingDeviceChoice' _SEA_ETH_BACK_DEV = ETH_BACK_DEV _SEA_HA_MODE = 'HighAvailabilityMode' _SEA_DEV_NAME = 'DeviceName' _SEA_JUMBO_FRAMES = 'JumboFramesEnabled' _SEA_PVID = _PVID _SEA_QOS_MODE = 'QualityOfServiceMode' _SEA_QUEUE_SIZE = 'QueueSize' _SEA_THREAD_MODE = 'ThreadModeEnabled' _SEA_IP_INTERFACE = 'IPInterface' _SEA_DEV_ID = 'UniqueDeviceID' _SEA_LARGE_SEND = 'LargeSend' _SEA_ADDRESS_TO_PING = 'AddressToPing' _SEA_IIDP_SERVICE = 'IIDPService' SEA_TRUNKS = 'TrunkAdapters' _SEA_PRIMARY = 'IsPrimary' _SEA_CONFIGURATION_STATE = 'ConfigurationState' _SEA_EL_ORDER = (_SEA_VIO_HREF, _SEA_CONTROL_CHANNEL, _SEA_BACKING_DEV, _SEA_HA_MODE, _SEA_DEV_NAME, _SEA_JUMBO_FRAMES, _SEA_PVID, _SEA_QOS_MODE, _SEA_QUEUE_SIZE, _SEA_THREAD_MODE, _SEA_IP_INTERFACE, _SEA_DEV_ID, _SEA_LARGE_SEND, _SEA_ADDRESS_TO_PING, _SEA_IIDP_SERVICE, SEA_TRUNKS, _SEA_PRIMARY, _SEA_CONFIGURATION_STATE) _SEA_EBD_ADAPTER_ID = 'AdapterID' _SEA_EBD_DESCRIPTION = 'Description' _SEA_EBD_DEV_NAME = 'DeviceName' _SEA_EBD_DEV_TYPE = 'DeviceType' _SEA_EBD_DYN_CONN_NAME = _DRC_NAME _SEA_EBD_PHYS_LOC = 'PhysicalLocation' _SEA_EBD_UDID = 'UniqueDeviceID' _SEA_EBD_ORDER = (_SEA_EBD_ADAPTER_ID, _SEA_EBD_DESCRIPTION, _SEA_EBD_DEV_NAME, _SEA_EBD_DEV_TYPE, _SEA_EBD_DYN_CONN_NAME, _SEA_EBD_PHYS_LOC, _SEA_EBD_UDID) _USE_NEXT_AVAIL_SLOT = 'UseNextAvailableSlotID' _USE_NEXT_AVAIL_HIGH_SLOT = 'UseNextAvailableHighSlotID' TA_ROOT = 'TrunkAdapter' _TA_CONN_NAME = _DRC_NAME _TA_LOC_CODE = 'LocationCode' _TA_REQUIRED = 'RequiredAdapter' _TA_VARIED_ON = 'VariedOn' _TA_VIRTUAL_SLOT = 'VirtualSlotNumber' _TA_USE_NEXT_AVAIL_SLOT = _USE_NEXT_AVAIL_SLOT _TA_USE_NEXT_AVAIL_HIGH_SLOT = _USE_NEXT_AVAIL_HIGH_SLOT _TA_ALLOWED_MAC = 'AllowedOperatingSystemMACAddresses' _TA_MAC = 'MACAddress' _TA_PVID = _PVID _TA_QOS_PRI = 'QualityOfServicePriorityEnabled' _TA_VLAN_IDS = 'TaggedVLANIDs' _TA_TAG_SUPP = 'TaggedVLANSupported' _TA_VS_ID = 'VirtualSwitchID' _TA_DEV_NAME = 'DeviceName' _TA_TRUNK_PRI = 'TrunkPriority' _TA_ASSOC_VSWITCH = 'AssociatedVirtualSwitch' _TA_EL_ORDER = (_TA_CONN_NAME, _TA_LOC_CODE, _TA_REQUIRED, _TA_VARIED_ON, _TA_USE_NEXT_AVAIL_SLOT, _TA_USE_NEXT_AVAIL_HIGH_SLOT, _TA_VIRTUAL_SLOT, _TA_ALLOWED_MAC, _TA_MAC, _TA_PVID, _TA_QOS_PRI, _TA_VLAN_IDS, _TA_TAG_SUPP, _TA_ASSOC_VSWITCH, _TA_VS_ID, _TA_DEV_NAME, _TA_TRUNK_PRI) _LG_PVID = _PVID _LG_TRUNKS = 'TrunkAdapters' _LG_VNETS = _VNETS _VNET_ASSOC_SW = 'AssociatedSwitch' _VNET_NET_NAME = 'NetworkName' _VNET_VLAN_ID = 'NetworkVLANID' _VNET_SW_ID = 'VswitchID' _VNET_TAG = 'TaggedNetwork' _VADPT_TYPE = 'AdapterType' _VADPT_DRC_NAME = _DRC_NAME _VADPT_LOCATION_CODE = 'LocationCode' _VADPT_LOC_PART_ID = 'LocalPartitionID' _VADPT_REQUIRED = _TA_REQUIRED _VADPT_VARIED_ON = _TA_VARIED_ON _VADPT_USE_NEXT_AVAIL_SLOT = _USE_NEXT_AVAIL_SLOT _VADPT_USE_NEXT_AVAIL_HIGH_SLOT = _USE_NEXT_AVAIL_HIGH_SLOT _VADPT_SLOT_NUM = 'VirtualSlotNumber' _VADPT_ENABLED = 'Enabled' _VADPT_ALLOWED_MAC = _TA_ALLOWED_MAC _VADPT_MAC_ADDR = _TA_MAC _VADPT_IP_ADDR = 'IPAddress' _VADPT_SUBNET_MASK = 'SubnetMask' _VADPT_GATEWAY = 'Gateway' _VADPT_PVID = _PVID _VADPT_QOS_PRI = 'QualityOfServicePriority' _VADPT_QOS_PRI_ENABLED = _TA_QOS_PRI _VADPT_TAGGED_VLANS = 'TaggedVLANIDs' _VADPT_TAGGED_VLAN_SUPPORT = 'TaggedVLANSupported' _VADPT_VSI_MANAGER_ID = 'VirtualStationInterfaceManagerID' _VADPT_VSI_TYPE_ID = 'VirtualStationInterfaceTypeID' _VADPT_VSWITCH = 'AssociatedVirtualSwitch' _VADPT_VSWITCH_ID = _TA_VS_ID _VADPT_VSI_TYPE_VERSION = 'VirtualStationInterfaceTypeVersion' _VADPT_DEV_NAME = 'DeviceName' _VADPT_TRUNK_PRI = _TA_TRUNK_PRI _VADPT_VNETS = _VNETS _VADPT_MTU = "ConfiguredMTU" _VADPT_OVS_BRIDGE = "OvsBridge" _VADPT_OVS_EXT_IDS = "OvsPortExternalIds" _VADPT_EL_ORDER = ( _VADPT_TYPE, _VADPT_DRC_NAME, _VADPT_LOCATION_CODE, _VADPT_LOC_PART_ID, _VADPT_REQUIRED, _VADPT_VARIED_ON, _VADPT_USE_NEXT_AVAIL_SLOT, _VADPT_USE_NEXT_AVAIL_HIGH_SLOT, _VADPT_SLOT_NUM, _VADPT_ENABLED, _VADPT_ALLOWED_MAC, _VADPT_MAC_ADDR, _VADPT_PVID, _VADPT_QOS_PRI, _VADPT_QOS_PRI_ENABLED, _VADPT_TAGGED_VLANS, _VADPT_TAGGED_VLAN_SUPPORT, _VADPT_VSI_MANAGER_ID, _VADPT_VSI_TYPE_ID, _VADPT_VSWITCH, _VADPT_VSWITCH_ID, _VADPT_VSI_TYPE_VERSION, _VADPT_DEV_NAME, _VADPT_TRUNK_PRI, _VADPT_MTU, _VADPT_OVS_BRIDGE, _VADPT_OVS_EXT_IDS, _VADPT_VNETS) class VSwitchMode(object): VEB = "Veb" VEPA = "Vepa" class HAMode(object): FAILOVER = 'auto' LOAD_SHARING = 'sharing' DISABLED = 'disabled' class SEAState(object): CONFIGURED = 'Configured' UNCONFIGURED = 'UnConfigured' INVALID = 'InvalidConfiguration' def _order_by_pvid(adapters, pvid): """Orders a list of adapters. Takes in a set of adapter wrappers (either TrunkAdapter or LoadGroups) and returns a list where the adapter that matches the PVID is the first. :param adapters: The list of adapter wrappers (either TrunkAdapter or LoadGroups). Must have a pvid attribute. :param pvid: The pvid to match on. """ resp_list = [] for adapter in adapters: if adapter.pvid == pvid: # If the PVIDs match, put it to the front of the list resp_list.insert(0, adapter) else: # Otherwise, throw it on the back resp_list.append(adapter) return resp_list @ewrap.EntryWrapper.pvm_type('VirtualSwitch', has_metadata=True, child_order=_VSW_EL_ORDER) class VSwitch(ewrap.EntryWrapper): """Wraps the Virtual Switch entries. The virtual switch in PowerVM is an independent plane of traffic. If Ethernet packets are traveling on different virtual switches, the only time they can communicate is on the physical network plane (or if two logical adapters are bridged together). They are important for data plane segregation. """ @classmethod def bld(cls, adapter, name, switch_mode=VSwitchMode.VEB): """Creates a VSwitch that can be used for a create operation. :param adapter: A pypowervm.adapter.Adapter (for traits, etc.) :param name: The name for the virtual switch. Must be unique. :param switch_mode: The mode of virtual switch (see VSwitchMode). :returns: The ElementWrapper that represents the new VSwitch. """ vswitch = super(VSwitch, cls)._bld(adapter) vswitch.name = name vswitch.mode = switch_mode vswitch.vnet_uri_list = [] return vswitch @property def name(self): """The name associated with the Virtual Switch.""" name = self._get_val_str(_VSW_NAME) if name == _VSW_DEFAULT_VSWITCH_API: return VSW_DEFAULT_VSWITCH return name @name.setter def name(self, new_name): self.set_parm_value(_VSW_NAME, new_name) @property def switch_id(self): """The internal ID (not UUID) for the Virtual Switch.""" return self._get_val_int(_VSW_ID) @property def mode(self): """The mode that the switch is in (ex. Veb). This is a string value that represents one of the values in the VSwitchMode enumeration. """ return self._get_val_str(_VSW_MODE) @mode.setter def mode(self, new_mode): self.set_parm_value(_VSW_MODE, new_mode) @property def vnet_uri_list(self): """Returns a list of the Virtual Network URIs. If the vnet_aware trait (see traits.py) is set to False, the user should not modify this. Virtual Networks become 'realized' off of the system's VLANs/vSwitches. However, if set to True, one can add a Virtual Network to the vSwitch before it is used. The task classes (cna.py and network_bridger.py) should abstract the user away from these deviations in traits. """ uri_resp_list = list(self.get_href(u.xpath(_LG_VNETS, c.LINK))) return ewrap.ActionableList(uri_resp_list, self.__update_uri_list) @vnet_uri_list.setter def vnet_uri_list(self, new_list): self.__update_uri_list(new_list) def __update_uri_list(self, new_list): new_vnet_elem = self._bld_link_list(_VSW_VIRT_NETS, new_list) self.inject(new_vnet_elem) @ewrap.EntryWrapper.pvm_type('NetworkBridge', child_order=_NB_EL_ORDER) class NetBridge(ewrap.EntryWrapper): """Wrapper object for the NetBridge entry. A NetworkBridge represents an aggregate entity comprising Shared Ethernet Adapters. If Failover or Load-Balancing is in use, the Network Bridge will have two identically structured Shared Ethernet Adapters belonging to different Virtual I/O Servers. """ @classmethod def bld(cls, adapter, pvid, vios_to_backing_adpts, vswitch, load_balance=False): """Create the NetBridge entry that can be used for a create operation. This is used when creating a NetBridge. :param adapter: A pypowervm.adapter.Adapter (for traits, etc.) :param pvid: The primary VLAN ID (ex. 1) for the Network Bridge. :param vios_to_backing_adpts: An argument containing a list of tuples between VIOS href and the VIOS backing trunk adapter names for 1 or 2 VIOS servers, depending whether failover is required. :param vswitch: The vswitch wrapper to retrieve ID and href. :param load_balance: (Optional) If set to True, the load balancing will be enabled across the two SEAs. This does require multiple backing adapters (two SEAs). :returns: A new NetBridge EntryWrapper that represents the new NetBridge. """ nb = super(NetBridge, cls)._bld(adapter) if not vios_to_backing_adpts: raise ValueError() # Set required failover flag based on number of VIOSs. True for 2, # False for 1. We can determine this based on the number of provided # backing adpts. If its 0 we should throw an exception, 1 means only # 1 VIOS, 2 or more means we are defaulting to failover. nb._failover(len(vios_to_backing_adpts) != 1) # Set required load balancing flag. nb.load_balance = load_balance # Collection must be set based on schema requirements. nb.replace_list(_NB_LGS, []) # Set PVID to user provided value. nb._pvid(pvid) # There should never be more than two VIOSes specified. However, the # API should validate this. Therefore we can loop through and assert # that only the first VIOS is the primary. primary = True nb.seas = [] for vio_tuple in vios_to_backing_adpts: nb.seas.append(SEA.bld(adapter, pvid, vio_tuple[0], vio_tuple[1], vswitch, primary=primary)) primary = False return nb @property def pvid(self): """Returns the Primary VLAN ID of the Network Bridge.""" return self._get_val_int(_NB_PVID) def _pvid(self, value): """Private setter for the PVID used by Network Bridge builder.""" self.set_parm_value(_NB_PVID, value) @property def vnet_uri_list(self): """Returns a list of the Virtual Network URIs. This is a READ-ONLY list. Modification should take place through the LoadGroup vnet_uri_list. As the LoadGroups are modified, this list will be dynamically updated. """ return self.get_href(u.xpath(_NB_VNETS, c.LINK)) def _rebuild_vnet_list(self): """A callback from the Load Group to rebuild the virtual network list. Needed due to the API using both the LoadGroup and Network Bridge as a source. But usage at an API level should be through Load Groups. """ # Find all the children Virtual Networks. search = u.xpath(_NB_LGS, _NB_LG, _NB_VNETS, c.LINK) new_vnets = copy.deepcopy(self.element.findall(search)) # Find and replace the current element. cur_vnets = self.element.find(_NB_VNETS) self.element.replace( cur_vnets, ent.Element(_NB_VNETS, self.adapter, children=new_vnets)) @property def seas(self): """Returns a list of SEA wrappers.""" return ewrap.WrapperElemList(self.entry.element.find(NB_SEAS), SEA) @seas.setter def seas(self, new_list): self.replace_list(NB_SEAS, new_list) @property def load_balance(self): """If set to True, the Load Balancing is enabled on the bridge. Requires two SEAs (sharing is done across the SEAs). """ return self._get_val_bool(_NB_LOADBALANCE, False) @load_balance.setter def load_balance(self, value): self.set_parm_value(_NB_LOADBALANCE, u.sanitize_bool_for_api(value)) @property def load_grps(self): """Returns the load groups. The first in the list is the primary.""" lg_list = [LoadGroup.wrap(x, nb_root=self) for x in self.element.findall(u.xpath(_NB_LGS, _NB_LG))] temp_list = _order_by_pvid(lg_list, self.pvid) return ewrap.ActionableList(temp_list, self._load_grps) @load_grps.setter def load_grps(self, new_list): self._load_grps(new_list) def _load_grps(self, new_list): self.replace_list(_NB_LGS, new_list) @property def vswitch_id(self): return self.seas[0].primary_adpt.vswitch_id @property def arbitrary_pvids(self): """Lists all of the network bridges' arbitrary PVIDs. An arbitrary PVID is a 'primary VLAN ID' attached to an additional Load Group or Trunk Adapter. These typically do not send traffic through them, and are placeholder VLANs required by the backing 'additional' Trunk Adapters. :return: List of arbitrary PVIDs """ if self.traits.vnet_aware: return [x.pvid for x in self.load_grps[1:]] else: return [x.pvid for x in self.seas[0].addl_adpts] def list_vlans(self, pvid=True, arbitrary=False): """Lists all of the VLANs on the Network Bridge. :param pvid: True if the primary VLAN ID should be included in the response. Defaults to True. :param arbitrary: If True, the arbitrary PVIDs (see arbitrary_pvids property) will be included in the response. :response: A list of all the VLANs. """ resp = [] if self.traits.vnet_aware: # Loop through all load groups (even primary) and add the VLANs. for ld_grp in self.load_grps: trunk = ld_grp.trunk_adapters[0] if arbitrary: resp.append(trunk.pvid) resp.extend(trunk.tagged_vlans) # Depending on if the arbitrary flag was set, the primary VLAN may # be in already. This is odd logic here...but keeps the code # efficient. if not pvid and arbitrary: resp.remove(self.pvid) elif pvid and not arbitrary: resp.append(self.pvid) else: # Loop through the first SEA's trunks sea = self.seas[0] if pvid: resp.append(sea.primary_adpt.pvid) resp.extend(sea.primary_adpt.tagged_vlans) for trunk in sea.addl_adpts: if arbitrary: resp.append(trunk.pvid) resp.extend(trunk.tagged_vlans) return resp def supports_vlan(self, vlan): """Determines if the VLAN can flow through the Network Bridge. The VLAN can flow through if either of the following applies: - It is the primary VLAN of the primary Load Group - It is an additional VLAN on any Load Group Therefore, the inverse is true and the VLAN is not supported by the Network Bridge if the following: - The VLAN is not on the Network Bridge - The VLAN is a primary VLAN on a NON-primary Load Group :param vlan: The VLAN to query for. Can be a string or a number. :returns: True or False based on the previous criteria. """ # Make sure we're using string vlan = int(vlan) return vlan in self.list_vlans() def _failover(self, value): """Private setter for the failover attr. Determined by backing adapters on NetworkBridge creation. """ self.set_parm_value(_NB_FAILOVER, u.sanitize_bool_for_api(value)) @property def control_channel_id(self): """Returns the control channel interface ID. Can be None.""" return self._get_val_int(_NB_CONTROL_CHANNEL_ID) @ewrap.ElementWrapper.pvm_type(SHARED_ETH_ADPT, has_metadata=True, child_order=_SEA_EL_ORDER) class SEA(ewrap.ElementWrapper): """Represents the Shared Ethernet Adapter within a NetworkBridge.""" @classmethod def bld(cls, adapter, pvid, vios_href, adpt_name, vswitch, primary=True): """Create the SEA entry that can be used for NetBridge creation. :param adapter: A pypowervm.adapter.Adapter (for traits, etc.) :param pvid: The primary VLAN ID (ex. 1) for the Network Bridge. :param vios_href: The Assigned VIOS href. :param adpt_name: Name of the physical adapter or ether channel that will back the SEA. :param vswitch: The vswitch wrapper to retrieve ID and href. :param primary: Used in a dual Virtual I/O Server environment. If set to True, indicates it is running on the I/O Server that the traffic should run through by default. False indicates it is the SEA on the fail over Virtual I/O Server. If single Virtual I/O Server environment, always set this to True. :returns: A new SEA ElementWrapper that represents the new SEA. """ sea = super(SEA, cls)._bld(adapter) sea._pvid(pvid) sea._vio_uri(vios_href) sea._backing_device(EthernetBackingDevice.bld(adapter, adpt_name)) trunk_pri = 1 if primary else 2 sea._primary_adpt(TrunkAdapter.bld(adapter, pvid, [], vswitch, trunk_pri=trunk_pri)) sea._is_primary(primary) return sea @property def pvid(self): """Returns the Primary VLAN ID of the Shared Ethernet Adapter.""" return self._get_val_int(_SEA_PVID) def _pvid(self, value): self.set_parm_value(_SEA_PVID, value) @property def dev_name(self): return self._get_val_str(_SEA_DEV_NAME) @property def vio_uri(self): """The URI to the corresponding VIOS.""" return self.get_href(_SEA_VIO_HREF, one_result=True) def _vio_uri(self, value): self.set_href(_SEA_VIO_HREF, value) @property def ha_mode(self): """Returns the high availability mode of the SEA. See the HAMode Enumeration. """ # This is a read only attribute. We default to None in the # event this payload was created by a bld method (indicating # that we do not know). All subsequent reads will have this # attribute. return self._get_val_str(_SEA_HA_MODE, None) @property def is_primary(self): """Returns if this is the primary SEA. Only valuable in dual Virtual I/O Server environments where a NetBridge spans multiple I/O Servers. The primary SEA is the one the traffic runs through by default unless in a fail over scenario. """ return self._get_val_bool(_SEA_PRIMARY) def _is_primary(self, val): self.set_parm_value(_SEA_PRIMARY, u.sanitize_bool_for_api(val)) @property def addl_adpts(self): """Non-primary TrunkAdapters on this Shared Ethernet Adapter. If the vnet_aware trait (see traits.py) is set to True, then the modification of a Network Bridge should be driven via the LoadGroup. If set to False, the LoadGroups simply reflect the state of the system and can't be used for modification. In those scenarios, modification should be done directly against the Trunk Adapters. :return: List of TrunkAdapter wrappers. May be the empty list. """ # TODO(thorst): Second return unreachable! Use self.traits.vnet_aware. return ewrap.ActionableList(self._get_trunks()[1:], self._addl_adpts) return tuple(self._get_trunks()[1:]) @addl_adpts.setter def addl_adpts(self, value): self._addl_adpts(value) def _addl_adpts(self, value): """Sets the additional Trunk Adapters on this SEA.""" # TODO(thorst): Condition on self.traits.vnet_aware. new_list = [self.primary_adpt] new_list.extend(value) self.replace_list(SEA_TRUNKS, new_list) @property def primary_adpt(self): """Returns the primary TrunkAdapter for this SEA. """ all_trunks = self._get_trunks() return all_trunks[0] if all_trunks else None def _primary_adpt(self, value): new_list = [value] if self._get_trunks() and len(self._get_trunks()) > 1: # Drop the original primary adapter. new_list.extend(self._get_trunks()[1:]) self.replace_list(SEA_TRUNKS, new_list) def _get_trunks(self): """Returns all of the trunk adapters. The first is the primary adapter. All others are the additional adapters. """ # It is not expected that the API will return the adapters such that # the first is the primary. Yet to reduce complexity in the other # methods that work with the trunks, the returned value from here # will order it as such. trunk_elem_list = [TrunkAdapter.wrap(x) for x in self.element.findall(u.xpath(SEA_TRUNKS, TA_ROOT))] return _order_by_pvid(trunk_elem_list, self.pvid) @property def backing_device(self): """The BackingDeviceChoice for this SEA.""" elem = self.element.find(_SEA_BACKING_DEV) if elem is None: return None return ewrap.ElementWrapper.wrap(elem[0]) def _backing_device(self, eth_back_dev): """The BackingDeviceChoice for this SEA. :param eth_back_dev: The EthernetBackingDevice for this BackingDeviceChoice. """ stor_elem = ent.Element(_SEA_BACKING_DEV, self.adapter, attrib={}, children=[]) stor_elem.inject(eth_back_dev.element) self.inject(stor_elem) @property def control_channel(self): """Returns the control channel interface name. This may be None, indicating the lack of a control channel. Control channels are no longer required for a network bridge to be redundant. """ return self._get_val_str(_SEA_CONTROL_CHANNEL) @property def configuration_state(self): """Returns the configuration state. May be None. Refer to SEAState for valid values. """ return self._get_val_str(_SEA_CONFIGURATION_STATE) def contains_device(self, dev_name): """Returns if one of the child adapters is owned by this SEA. A child adapter is either the primary adapter, control channel, or is one of the additional adapters. :param dev_name: The name of the child device. :return: True if owned by this SEA, False otherwise. """ if self.control_channel == dev_name: return True # If this SEA has no trunk adapters, primary_adpt will be None if self.primary_adpt and (self.primary_adpt.dev_name == dev_name): return True return dev_name in [x.dev_name for x in self.addl_adpts] @ewrap.ElementWrapper.pvm_type('TrunkAdapter', child_order=_TA_EL_ORDER) class TrunkAdapter(ewrap.ElementWrapper): """Represents a Trunk Adapter, either within a LoadGroup or a SEA.""" @classmethod def bld(cls, adapter, pvid, vlan_ids, vswitch, trunk_pri=1): """Create the TrunkAdapter element that can be used for SEA creation. The returned adapter uses the "next available high slot" option, meaning that the API will attempt to assign the next available slot number that's higher than all the existing assigned slot numbers. :param adapter: A pypowervm.adapter.Adapter (for traits, etc.) :param pvid: The primary VLAN ID (ex. 1) for the Network Bridge. :param vlan_ids: Additional VLAN ids for the trunk adapters. :param vswitch: The vswitch wrapper to retrieve ID and href. :param trunk_pri: Trunk priority of this adapter. Defaults to 1. :returns: A new TrunkAdapter ElementWrapper that represents the new TrunkAdapter. """ ta = super(TrunkAdapter, cls)._bld(adapter) ta._required(True) ta.pvid = pvid ta.tagged_vlans = vlan_ids ta.has_tag_support = True if vlan_ids else False ta._vswitch_id(vswitch.switch_id) ta._trunk_pri(trunk_pri) # UseNextAvailableSlotID field - High only if available unasi_field = (_TA_USE_NEXT_AVAIL_HIGH_SLOT if adapter.traits.has_high_slot else _TA_USE_NEXT_AVAIL_SLOT) ta.set_parm_value(unasi_field, u.sanitize_bool_for_api(True)) ta._associated_vswitch_uri(vswitch.related_href) return ta @property def pvid(self): """Returns the Primary VLAN ID of the Trunk Adapter.""" return self._get_val_int(_TA_PVID) @pvid.setter def pvid(self, value): self.set_parm_value(_TA_PVID, value) @property def dev_name(self): """Returns the name of the device as represented by the hosting VIOS. If RMC is down, will not be available. """ return self._get_val_str(_TA_DEV_NAME, 'Unknown') @property def has_tag_support(self): """Does this Trunk Adapter support Tagged VLANs passing through it?""" return self._get_val_bool(_TA_TAG_SUPP) @has_tag_support.setter def has_tag_support(self, new_val): self.set_parm_value(_TA_TAG_SUPP, u.sanitize_bool_for_api(new_val)) @property def tagged_vlans(self): """Returns the tagged VLAN IDs that are allowed to pass through. Assumes has_tag_support() returns True. If not, an empty list will be returned. """ addl_vlans = self._get_val_str(_TA_VLAN_IDS, '') list_data = [] if addl_vlans != '': list_data = [int(i) for i in addl_vlans.split(' ')] def update_list(new_list): data = ' '.join([str(j) for j in new_list]) self.set_parm_value(_TA_VLAN_IDS, data) return ewrap.ActionableList(list_data, update_list) @tagged_vlans.setter def tagged_vlans(self, new_list): data = ' '.join([str(i) for i in new_list]) self.set_parm_value(_TA_VLAN_IDS, data) @property def vswitch_id(self): """Returns the virtual switch identifier.""" return self._get_val_int(_TA_VS_ID) def _vswitch_id(self, value): self.set_parm_value(_TA_VS_ID, value) @property def trunk_pri(self): """Returns the trunk priority of the adapter.""" return self._get_val_int(_TA_TRUNK_PRI) def _trunk_pri(self, value): self.set_parm_value(_TA_TRUNK_PRI, value) def _required(self, value): self.set_parm_value(_TA_REQUIRED, u.sanitize_bool_for_api(value)) @property def virtual_slot_number(self): """Returns the virtual slot number for this adapter.""" return self._get_val_int(_TA_VIRTUAL_SLOT) @property def associated_vswitch_uri(self): """Returns the associated vswitch href.""" return self.get_href(u.xpath(_TA_ASSOC_VSWITCH, c.LINK), one_result=True) def _associated_vswitch_uri(self, href): self.set_href(u.xpath(_TA_ASSOC_VSWITCH, c.LINK), href) @property def varied_on(self): """Returns the VariedOn property.""" return self._get_val_bool(_TA_VARIED_ON) @property def loc_code(self): """Returns the LocationCode property.""" return self._get_val_str(_TA_LOC_CODE) @property def vios_id(self): """Determines and returns the VIOS ID from the loc_code. :return: int representing the short ID of the associated VIOS. """ return u.part_id_by_loc_code(self.loc_code) @ewrap.ElementWrapper.pvm_type('LoadGroup', has_metadata=True) class LoadGroup(ewrap.ElementWrapper): """Load Group (how the I/O load should be distributed) for a Network Bridge. If using failover or load balancing, then the Load Group will have pairs of Trunk Adapters, each with their own unique Trunk Priority. """ @classmethod def bld(cls, adapter, pvid, vnet_uris): """Create the LoadGroup element that can be used for a create operation. This is used when adding a Load Group to a NetBridge. :param adapter: A pypowervm.adapter.Adapter (for traits, etc.) :param pvid: The primary VLAN ID (ex. 1) for the Load Group. :param vnet_uris: The virtual network URI list (mapping to each additional VLAN/vswitch combo). :returns: A new LoadGroup ElementWrapper that represents the new LoadGroup. """ lg = super(LoadGroup, cls)._bld(adapter) lg._pvid(pvid) lg.vnet_uri_list.extend(vnet_uris) return lg @classmethod def wrap(cls, element, **kwargs): wrap = super(LoadGroup, cls).wrap(element) # If created from a Network Bridge this will be set. Else it will # be None (ex. crt_load_group method) wrap._nb_root = kwargs.get('nb_root') return wrap @property def pvid(self): """Returns the Primary VLAN ID of the Load Group.""" return self._get_val_int(_LG_PVID) def _pvid(self, new_pvid): self.set_parm_value(_LG_PVID, new_pvid) @property def trunk_adapters(self): """Returns the Trunk Adapters for the Load Group. There is either one (no redundancy/wrap balancing) or two (typically the case in a multi VIOS scenario). :return: list of TrunkAdapter objects. """ return ewrap.WrapperElemList(self.element.find(_LG_TRUNKS), TrunkAdapter) @trunk_adapters.setter def trunk_adapters(self, new_list): self.replace_list(_LG_TRUNKS, new_list) @property def vnet_uri_list(self): """Returns a list of the Virtual Network URIs. If the vnet_aware trait (see traits.py) is set, then the addition of VLANs is driven via virtual networks rather than straight VLAN modification. This uri list is what drives the modification. If the trait is set to false, then the modification should be driven via the trunk adapters on the SEA directly. This list will also be empty. The task classes (cna.py and network_bridger.py) should abstract the user away from these deviations in traits. """ uri_resp_list = list(self.get_href(u.xpath(_LG_VNETS, c.LINK))) return ewrap.ActionableList(uri_resp_list, self.__update_uri_list) @vnet_uri_list.setter def vnet_uri_list(self, new_list): self.__update_uri_list(new_list) def __update_uri_list(self, new_list): new_vnet_elem = self._bld_link_list(_VSW_VIRT_NETS, new_list) old_elems = self.element.find(_LG_VNETS) # This is a bug where the API isn't returning vnets if just a PVID # on additional VEA if old_elems is not None: self.element.replace(old_elems, new_vnet_elem) else: self.element.append(new_vnet_elem) # If the Network Bridge was set, tell it to rebuild its VirtualNetwork # list. try: self._nb_root._rebuild_vnet_list() except AttributeError: # Network Bridge was not set - ignore pass @property def tagged_vlans(self): """The VLANs supported by this Load Group. Does not include PVID.""" return self.trunk_adapters[0].tagged_vlans @ewrap.EntryWrapper.pvm_type('VirtualNetwork') class VNet(ewrap.EntryWrapper): """The overall definition of a VLAN network within the hypervisor.""" @classmethod def bld(cls, adapter, name, vlan_id, vswitch_uri, tagged): """Creates a VirtualNetwork that can be used for a create operation. This is used when creating a new Virtual Network within the system :param adapter: A pypowervm.adapter.Adapter (for traits, etc.) :param name: The name for the virtual network. :param vlan_id: The VLAN identifier (1 to 4094) for the network. :param vswitch_uri: The URI that points to the appropriate vSwitch. :param tagged: True if packets should have VLAN tags when they leave the system. False if tags should only be on the packets while in the system (but tag-less when on the physical network). :returns: The ElementWrapper that represents the new VirtualNetwork. """ vnet = super(VNet, cls)._bld(adapter) # Assignment order matters vnet.associated_switch_uri = vswitch_uri vnet.name = name vnet.vlan = vlan_id vnet.tagged = tagged return vnet @property def associated_switch_uri(self): return self.get_href(_VNET_ASSOC_SW, one_result=True) @associated_switch_uri.setter def associated_switch_uri(self, uri): self.set_href(_VNET_ASSOC_SW, uri) @property def name(self): return self._get_val_str(_VNET_NET_NAME) @name.setter def name(self, value): self.set_parm_value(_VNET_NET_NAME, value) @property def vlan(self): return self._get_val_int(_VNET_VLAN_ID) @vlan.setter def vlan(self, vlan_id): self.set_parm_value(_VNET_VLAN_ID, vlan_id) @property def vswitch_id(self): """The vSwitch identifier (int). 0 through 15 (max number vSwitches). Is not a UUID. """ return self._get_val_int(_VNET_SW_ID) @property def tagged(self): """If True, the VLAN tag is preserved when the packet leaves system.""" return self._get_val_bool(_VNET_TAG) @tagged.setter def tagged(self, is_tagged): self.set_parm_value(_VNET_TAG, u.sanitize_bool_for_api(is_tagged)) @ewrap.EntryWrapper.pvm_type('ClientNetworkAdapter', child_order=_VADPT_EL_ORDER) class CNA(ewrap.EntryWrapper): """Wrapper object for ClientNetworkAdapter schema.""" @classmethod def bld(cls, adapter, pvid, vswitch_href, slot_num=None, mac_addr=None, addl_tagged_vlans=None, trunk_pri=None, dev_name=None, ovs_bridge=None, ovs_ext_ids=None, configured_mtu=None): """Creates a fresh CNA EntryWrapper. This is used when creating a new CNA for a partition. This can be PUT to LogicalPartition//ClientNetworkAdapter or to VirtualIOServer//ClientNetworkAdapter. :param adapter: A pypowervm.adapter.Adapter (for traits, etc.) :param pvid: The Primary VLAN ID to use. :param vswitch_href: The URI that points to the Virtual Switch that will support this adapter. :param slot_num: The Slot on the Client LPAR that should be used. This defaults to 'None', which means the next available high slot will be used (the API will attempt to assign the next available slot number that's higher than all the existing assigned slot numbers. :param mac_addr: Optional user specified mac address to use. If left as None, the system will generate one. :param addl_tagged_vlans: A set of additional tagged VLANs that can be passed through this adapter (with client VLAN adapters). Input should be a list of int (or int string) Example: [51, 52, 53] Note: The limit is ~18 additional VLANs :param trunk_pri: Optional TrunkPriority integer that, if specified, will create this wrapper as a trunk. :param dev_name: (Optional, Default: None) Can only be set if the CNA is being created against the Management VM. Can be used to specify what the device name should be for the CNA on the Management VM. Ignored for all other LPAR types. :param ovs_bridge: (Optional, Default: None) If hosting through mgmt partition, this attribute specifies which Open vSwitch to connect to. This assumes that Open vSwitch is installed and active on the mgmt partition. :param ovs_ext_ids: (Optional, Default: None) A comma-delimited list of key=value pairs in string format. Ex. iface-id=abc123,iface-status=active This sets a dictionary of values on the Interface element within Open vSwitch. This assumes that Open vSwitch is installed and active on the mgmt partition. :param configured_mtu: (Optional, Default: None) Sets the MTU on the adapter. May only be valid if adapter is being created against mgmt partition. :returns: A CNA EntryWrapper that can be used for create. """ cna = super(CNA, cls)._bld(adapter) # Assignment order matters if slot_num is not None: cna._slot(slot_num) else: cna._use_next_avail_slot_id = True if mac_addr is not None: cna.mac = mac_addr # The primary VLAN ID cna.pvid = pvid # Additional VLANs if addl_tagged_vlans is not None: cna.tagged_vlans = addl_tagged_vlans cna.is_tagged_vlan_supported = True else: cna.is_tagged_vlan_supported = False # vSwitch URI cna.vswitch_uri = vswitch_href # Set the device name if not None if dev_name: cna._dev_name(dev_name) if ovs_bridge is not None: cna.ovs_bridge = ovs_bridge if ovs_ext_ids is not None: cna.ovs_ext_ids = ovs_ext_ids if configured_mtu is not None: cna.configured_mtu = configured_mtu # If a trunk priority is specified, set it. It will make this CNA # build out a trunk adapter. However, if it is not specified, we # do not want to set it as we don't want to include the element in # the payload we send for the CNA creation. if trunk_pri: cna._trunk_pri(trunk_pri) return cna def create(self, parent_type=None, parent_uuid=None, timeout=-1, parent=None, **kwargs): """Override to ensure default slot setting is correct. Create the CNA as specified *except*: If UseNextAvailableHighSlot is True (i.e. slot number was not given); and the parent is a VIOS or the management partition; then change to UseNextAvailableSlot (not High). This is because VIOS and the management partition don't care about slot ordering, and their longevity increases the probability of running out of slot space if we use 'High'. :param parent_type: See superclass. :param parent_uuid: See superclass. :param timeout: See superclass. :param parent: See superclass. """ # These checks are quick, so do them first. el2d = self._find(_TA_USE_NEXT_AVAIL_HIGH_SLOT) # If UseNextAvailableHighSlot is present *and* True. if el2d is not None and self._use_next_avail_slot_id: # If we have the parent wrapper, we don't have to GET. Otherwise... if parent is None: if any(val is None for val in (parent_type, parent_uuid)): raise ValueError(_("Invalid parent spec for CNA.create.")) # If the parent_type isn't a wrapper class, get it if type(parent_type) is str: parent_type = ewrap.Wrapper._pvm_object_registry[ parent_type]['entry'] # Aaaand get the parent parent = parent_type.get(self.adapter, uuid=parent_uuid) # Now we can find out whether the parent is VIOS or mgmt. if parent.env == bp.LPARType.VIOS or parent.is_mgmt_partition: # Delete the existing UNAHSI field self.element.remove(el2d) # Aaaand add the UNASI field self.set_parm_value(_TA_USE_NEXT_AVAIL_SLOT, u.sanitize_bool_for_api(True)) # Superclass does the real work. return super(CNA, self).create( parent_type=parent_type, parent_uuid=parent_uuid, timeout=timeout, parent=parent, **kwargs) @property def slot(self): return self._get_val_int(_VADPT_SLOT_NUM) def _slot(self, sid): self.set_parm_value(_VADPT_SLOT_NUM, sid) @property def lpar_id(self): """Returns the Local Partition ID for this adapter.""" return self._get_val_int(_VADPT_LOC_PART_ID) @property def _use_next_avail_slot_id(self): """Use next available (high) slot ID, true or false.""" # We could be using either next-available-slot field. If either is set, # it counts. return any(self._get_val_bool(unasi_field) for unasi_field in (_TA_USE_NEXT_AVAIL_HIGH_SLOT, _TA_USE_NEXT_AVAIL_SLOT)) @_use_next_avail_slot_id.setter def _use_next_avail_slot_id(self, unasi): """Use next available (high) slot ID. :param unasi: Boolean value to set (True or False) """ # NOTE(efried): We'd like to set this to not-HIGH for VIOS/mgmt, but in # bld(), we don't know what kind of parent we have. unasi_field = (_TA_USE_NEXT_AVAIL_HIGH_SLOT if self.traits.has_high_slot else _TA_USE_NEXT_AVAIL_SLOT) self.set_parm_value(unasi_field, u.sanitize_bool_for_api(unasi)) @property def mac(self): """Returns the Mac Address for the adapter. Typical format would be: AABBCCDDEEFF The API returns a format with no colons and is upper cased. """ return self._get_val_str(_VADPT_MAC_ADDR) @property def vsi_type_id(self): """Returns the virtual station interface type id.""" return self._get_val_str(_VADPT_VSI_TYPE_ID) @property def vsi_type_version(self): """Returns the virtual station interface version.""" return self._get_val_str(_VADPT_VSI_TYPE_VERSION) @property def vsi_type_manager_id(self): """Returns the virtual station interface manager id.""" return self._get_val_str(_VADPT_VSI_MANAGER_ID) @mac.setter def mac(self, new_val): new_mac = u.sanitize_mac_for_api(new_val) self.set_parm_value(_VADPT_MAC_ADDR, new_mac) @property def pvid(self): """Returns the Port VLAN ID (int value).""" return self._get_val_int(_VADPT_PVID) @pvid.setter def pvid(self, new_val): self.set_parm_value(_VADPT_PVID, new_val) @property def enabled(self): """Returns the enabled state (boolean value). A CNA is always created enabled=true. However, certain migration operations of an LPAR (ex. migration via OpenStack when using Open vSwitch) will cause the client's CNA to be disabled. This method can be used to check the state of the adapter. """ return self._get_val_bool(_VADPT_ENABLED) @enabled.setter def enabled(self, new_val): self.set_parm_value(_VADPT_ENABLED, u.sanitize_bool_for_api(new_val)) @property def loc_code(self): """The device's location code.""" return self._get_val_str(_VADPT_LOCATION_CODE) @property def tagged_vlans(self): """Returns a list of additional VLANs on this adapter. Only valid if tagged vlan support is on. """ addl_vlans = self._get_val_str(_VADPT_TAGGED_VLANS, '') list_data = [] if addl_vlans != '': list_data = [int(i) for i in addl_vlans.split(' ')] def update_list(new_list): data = ' '.join([str(j) for j in new_list]) self.set_parm_value(_VADPT_TAGGED_VLANS, data) return ewrap.ActionableList(list_data, update_list) @tagged_vlans.setter def tagged_vlans(self, new_list): data = ' '.join([str(i) for i in new_list]) self.set_parm_value(_VADPT_TAGGED_VLANS, data) @property def is_tagged_vlan_supported(self): """Returns if addl tagged VLANs are supported (bool value).""" return self._get_val_bool(_VADPT_TAGGED_VLAN_SUPPORT) @is_tagged_vlan_supported.setter def is_tagged_vlan_supported(self, new_val): """Parameter new_val is a bool (True or False).""" self.set_parm_value(_VADPT_TAGGED_VLAN_SUPPORT, u.sanitize_bool_for_api(new_val)) @property def vswitch_uri(self): """Returns the URI for the associated vSwitch.""" return self.get_href(u.xpath(_VADPT_VSWITCH, c.LINK), one_result=True) @vswitch_uri.setter def vswitch_uri(self, new_val): self.set_href(u.xpath(_VADPT_VSWITCH, c.LINK), new_val) @property def vswitch_id(self): """Returns the ID (typically 0-15) for the virtual switch.""" return self._get_val_int(_VADPT_VSWITCH_ID) @property def dev_name(self): """Returns the name of the device (if available). If RMC is down, will not be available. """ return self._get_val_str(_VADPT_DEV_NAME, 'Unknown') def _dev_name(self, value): """Sets the device name. This is only available for devices running on the Management VM. If set for any other LPARs, it will be ignored. :param value: The device name. """ self.set_parm_value(_VADPT_DEV_NAME, value) @property def trunk_pri(self): """Returns the Trunk Priority for the adapter. :returns: None if this is not a Trunk Adapter, priority otherwise. """ return self._get_val_int(_TA_TRUNK_PRI) def _trunk_pri(self, new_val): self.set_parm_value(_TA_TRUNK_PRI, new_val) @property def is_trunk(self): """Returns if this adapter was created with a trunk priority. If the adapter was created without a trunk priority, it is just a client network adapter. However, if it was given a trunk priority on creation, it is a wrapper for a trunk adapter. """ return self.trunk_pri is not None @property def configured_mtu(self): """The MTU of the adapter. May only be valid if adapter is being created against mgmt partition. """ return self._get_val_int(_VADPT_MTU) @configured_mtu.setter def configured_mtu(self, value): self.set_parm_value(_VADPT_MTU, value, attrib=c.ATTR_KSV160) @property def ovs_bridge(self): """The Open vSwitch bridge it is connected to. Otherwise None.""" return self._get_val_str(_VADPT_OVS_BRIDGE) @ovs_bridge.setter def ovs_bridge(self, value): self.set_parm_value(_VADPT_OVS_BRIDGE, value, attrib=c.ATTR_KSV160) @property def ovs_ext_ids(self): """If connected to an Open vSwitch, returns the external ids. This is a comma-delimited list of key=value pairs. Ex: 'iface-id=123asdf,iface-status=active' This maps directly to the Open vSwitch Interface object's 'external_id' field. """ return self._get_val_str(_VADPT_OVS_EXT_IDS) @ovs_ext_ids.setter def ovs_ext_ids(self, value): self.set_parm_value(_VADPT_OVS_EXT_IDS, value, attrib=c.ATTR_KSV160) @ewrap.Wrapper.xag_property(c.XAG.ADV) def ip_address(self): """Returns the IP Address of the network interface. Typical format would be: 255.255.255.255 (IPv4) and ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff (IPv6) or other short forms of IPv6 address """ return self._get_val_str(_VADPT_IP_ADDR) @ewrap.Wrapper.xag_property(c.XAG.ADV) def subnet_mask(self): """Returns the subnet mask of the network interface. Typical format would be: 255.255.255.0 (IPv4) and ffff:ffff:ffff:ffff:: (IPv6) or other forms of IPv6 address """ return self._get_val_str(_VADPT_SUBNET_MASK) @ewrap.Wrapper.xag_property(c.XAG.ADV) def gateway(self): """Returns the gateway of the network interface. Typical format would be: 10.0.0.1 (IPv4) and cafe::1 (IPv6) or other forms of IPv6 address """ return self._get_val_str(_VADPT_GATEWAY) @ewrap.ElementWrapper.pvm_type(_SEA_ETH_BACK_DEV, has_metadata=True, child_order=_SEA_EBD_ORDER) class EthernetBackingDevice(ewrap.ElementWrapper): """Represents the SEA EthernetBackingDevice.""" @classmethod def bld(cls, adapter, dev_name): """Creates the EthernetBackingDevice element. :param adapter: A pypowervm.adapter.Adapter (for traits, etc.) :param dev_name: The device name (e.g. eth0). :returns: The EthernetBackingDevice element for SEAs. """ cfg = super(EthernetBackingDevice, cls)._bld(adapter) cfg._dev_name(dev_name) # This is required by the schema, setting it to 1 # just for legacy support. cfg._adapter_id(1) return cfg @property def dev_name(self): return self._get_val_str(_SEA_DEV_NAME) def _dev_name(self, dev_name): self.set_parm_value(_SEA_DEV_NAME, str(dev_name)) @property def adapter_id(self): return self._get_val_int(_SEA_EBD_ADAPTER_ID) def _adapter_id(self, value): # TODO(IBM) remove this once the schema no longer requires it. return self.set_parm_value(_SEA_EBD_ADAPTER_ID, value)