213 lines
6.7 KiB
Python
213 lines
6.7 KiB
Python
# Copyright 2019 Intel, Inc.
|
|
# 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.
|
|
|
|
from rsd_lib.resources.v2_1.ethernet_switch import vlan
|
|
from rsd_lib import utils as rsd_lib_utils
|
|
|
|
from sushy import exceptions
|
|
from sushy.resources import base
|
|
from sushy import utils
|
|
|
|
|
|
class StatusField(base.CompositeField):
|
|
state = base.Field('State')
|
|
health = base.Field('Health')
|
|
health_rollup = base.Field('HealthRollup')
|
|
|
|
|
|
class IPv4AddressesField(base.ListField):
|
|
address = base.Field("Address")
|
|
"""The IPv4Addresses address"""
|
|
|
|
subnet_mask = base.Field("SubnetMask")
|
|
"""The IPv4Addresses subnetmask"""
|
|
|
|
address_origin = base.Field("AddressOrigin")
|
|
"""The IPv4Addresses addressorigin"""
|
|
|
|
gate_way = base.Field("Gateway")
|
|
"""The IPv4Addresses gateway"""
|
|
|
|
|
|
class IPv6AddressesField(base.ListField):
|
|
address = base.Field("Address")
|
|
"""The IPv4Addresses address"""
|
|
|
|
prefix_length = base.Field("PrefixLength",
|
|
adapter=rsd_lib_utils.num_or_none)
|
|
"""The prefix length of IPv6 addresses"""
|
|
|
|
address_origin = base.Field("AddressOrigin")
|
|
"""The IPv4Addresses address origin"""
|
|
|
|
address_state = base.Field("AddressState")
|
|
"""The address state of IPv6 addresses"""
|
|
|
|
|
|
class IPv6StaticAddressesField(base.ListField):
|
|
address = base.Field("Address")
|
|
"""The IPv6 static addresses"""
|
|
|
|
prefix_length = base.Field("PrefixLength")
|
|
"""The IPv6 prefix length"""
|
|
|
|
|
|
class IPv6AddressPolicyTableField(base.ListField):
|
|
prefix = base.Field("Prefix")
|
|
"""The IPv6 Address Policy Table prefix"""
|
|
|
|
precedence = base.Field("Precedence", adapter=rsd_lib_utils.num_or_none)
|
|
"""The IPv6 Address Policy Table precedence"""
|
|
|
|
label = base.Field("Label", adapter=rsd_lib_utils.num_or_none)
|
|
"""The IPv6 Address Policy Table label"""
|
|
|
|
|
|
class IntelRackScaleField(base.CompositeField):
|
|
neighbor_port = base.Field("NeighborPort",
|
|
adapter=rsd_lib_utils.get_resource_identity)
|
|
"""The neighbor port of Rack ScaleIntel"""
|
|
|
|
|
|
class OemField(base.CompositeField):
|
|
intel_rackScale = IntelRackScaleField("Intel_RackScale")
|
|
"""The Oem Intel_RackScale"""
|
|
|
|
|
|
class LinksField(base.CompositeField):
|
|
oem = OemField("Oem")
|
|
""""The oem of Links"""
|
|
|
|
|
|
class VLANField(base.CompositeField):
|
|
vlan_enable = base.Field("VLANEnable", adapter=bool)
|
|
"""Whether the vlan is enable"""
|
|
|
|
vlan_id = base.Field("VLANId", adapter=rsd_lib_utils.num_or_none)
|
|
"""The vlan id"""
|
|
|
|
|
|
class EthernetInterface(base.ResourceBase):
|
|
identity = base.Field('Id', required=True)
|
|
"""The EthernetInterface identity string"""
|
|
|
|
name = base.Field('Name')
|
|
"""The EthernetInterface identity string"""
|
|
|
|
description = base.Field('Description')
|
|
"""The EthernetInterface description"""
|
|
|
|
status = StatusField('Status')
|
|
"""The EthernetInterface Status"""
|
|
|
|
interface_enabled = base.Field("InterfaceEnabled", adapter=bool)
|
|
"""Whether the interface is enabled"""
|
|
|
|
permanent_mac_address = base.Field("PermanentMACAddress")
|
|
"""The EthernetInterface PermanentMACAddress"""
|
|
|
|
mac_address = base.Field("MACAddress")
|
|
"""The EthernetInterface MACAddress"""
|
|
|
|
speed_mbps = base.Field("SpeedMbps", adapter=rsd_lib_utils.num_or_none)
|
|
"""The EthernetInterface SpeedMbps"""
|
|
|
|
auto_neg = base.Field("AutoNeg", adapter=bool)
|
|
"""Whether the EthernetInterface is AutoNeg"""
|
|
|
|
full_duplex = base.Field("FullDuplex", adapter=bool)
|
|
"""Whether the EthernetInterface is FullDuplex"""
|
|
|
|
mtu_size = base.Field("MTUSize", adapter=rsd_lib_utils.num_or_none)
|
|
"""The EthernetInterface MTUSize"""
|
|
|
|
host_name = base.Field("HostName")
|
|
"""The EthernetInterface hostname"""
|
|
|
|
fqdn = base.Field("FQDN")
|
|
"""The EthernetInterface FQDN"""
|
|
|
|
ipv6_default_gateway = base.Field("IPv6DefaultGateway")
|
|
"""The EthernetInterface IPv6DefaultGateway"""
|
|
|
|
max_ipv6_static_addresses = base.Field("MaxIPv6StaticAddresses",
|
|
adapter=rsd_lib_utils.num_or_none)
|
|
"""The EthernetInterface MaxIPv6StaticAddresses"""
|
|
|
|
name_servers = base.Field("NameServers")
|
|
"""The EthernetInterface nameservers"""
|
|
|
|
ipv4_addresses = IPv4AddressesField("IPv4Addresses")
|
|
"""The EthernetInterface IPv4 addresses"""
|
|
|
|
ipv6_addresses = IPv6AddressesField("IPv6Addresses")
|
|
"""The EthernetInterface IPv4 addresses"""
|
|
|
|
ipv6_static_addresses = IPv6StaticAddressesField("IPv6StaticAddresses")
|
|
"""The EthernetInterface IPv6 Static Addresses"""
|
|
|
|
ipv6_address_policy_table = IPv6AddressPolicyTableField(
|
|
"IPv6AddressPolicyTable")
|
|
"""The EthernetInterface IPv6 Address Policy Table"""
|
|
|
|
vlan = VLANField("VLAN")
|
|
"""The EthernetInterface VLAN"""
|
|
|
|
links = LinksField("Links")
|
|
"""The EthernetInterface links"""
|
|
|
|
def _get_vlan_collection_path(self):
|
|
"""Helper function to find the VLANCollection path"""
|
|
try:
|
|
return utils.get_sub_resource_path_by(self, 'VLANs')
|
|
except exceptions.MissingAttributeError:
|
|
return None
|
|
|
|
@property
|
|
@utils.cache_it
|
|
def vlans(self):
|
|
"""Property to provide reference to `VLANCollection` instance
|
|
|
|
It is calculated once when it is queried for the first time. On
|
|
refresh, this property is reset.
|
|
"""
|
|
path = self._get_vlan_collection_path()
|
|
if path:
|
|
return vlan.VLANCollection(
|
|
self._conn, path,
|
|
redfish_version=self.redfish_version)
|
|
else:
|
|
return None
|
|
|
|
|
|
class EthernetInterfaceCollection(base.ResourceCollectionBase):
|
|
@property
|
|
def _resource_type(self):
|
|
return EthernetInterface
|
|
|
|
def __init__(self, connector, path, redfish_version=None):
|
|
"""A class representing a EthernetInterface Collection
|
|
|
|
:param connector: A Connector instance
|
|
:param path: The canonical path to the EthernetInterface collection
|
|
resource
|
|
:param redfish_version: The version of RedFish. Used to construct
|
|
the object according to schema of the given version.
|
|
"""
|
|
|
|
super(EthernetInterfaceCollection, self).__init__(connector,
|
|
path,
|
|
redfish_version)
|