def autoload_details(self, shell_name):
with self._session_context_manager as session:
autoload_actions = AutoloadActions(session, self._logger)
ports_info = autoload_actions.get_ports_info()
bp_autoload = BPAutoload(ports_info, self._logger)
autoload_builder = AutoloadDetailsBuilder(bp_autoload.collect_details(shell_name))
return autoload_builder.autoload_details()
def autoload_details(self):
"""
:return:
"""
modules = self._tvm_client.get_modules_info()
resource = models.Chassis(shell_name=self._resource_config.shell_name,
name=self._resource_config.name,
unique_id=self._resource_config.fullname)
for module in modules:
mod_res = models.Module(shell_name=self._resource_config.shell_name,
name=module["name"].replace("/", "-"),
unique_id=module["resourceId"])
resource.add_sub_resource(module["number"], mod_res)
for test_agent in module["testAgents"]:
for test_if in test_agent["testInterfaces"]:
port_res = models.Port(shell_name=self._resource_config.shell_name,
name=test_if["name"].replace("/", "-"),
unique_id=test_if["resourceId"])
mod_res.add_sub_resource(test_if["number"], port_res)
return AutoloadDetailsBuilder(resource).autoload_details()
def get_inventory(self, context):
"""Return device structure with all standard attributes
:param AutoLoadCommandContext context: the context the command runs on
:return Attribute and sub-resource information for the Shell resource you can return an AutoLoadDetails object
:rtype: AutoLoadDetails
"""
# === SAMPLE CODE ===
resource = SDNControllerResource(shell_name="shell name",
name="snd controller name",
unique_id="snd controller id")
switch1 = GenericSDNSwitch(shell_name="shell name",
name="sdn switch 1",
unique_id="sdn switch id 1")
resource.add_sub_resource("1", switch1)
port1 = GenericSDNPort(shell_name="shell name",
name="sdn port 1",
unique_id="sdn port id 1")
port1.mac_address = 'fe80::e10c:f055:f7f1:bb7t16'
port1.ipv4_address = '192.168.10.7'
switch1.add_sub_resource("1", port1)
return AutoloadDetailsBuilder(resource).autoload_details()
def discover(self, supported_os):
"""General entry point for autoload,
read device structure and attributes: chassis, modules, submodules, ports, port-channels and power supplies
:return: AutoLoadDetails object
"""
if not self._is_valid_device_os(supported_os):
raise Exception(self.__class__.__name__, 'Unsupported device OS')
self.logger.info("*" * 70)
self.logger.info("Start SNMP discovery process .....")
self.load_additional_mibs()
self.snmp_handler.load_mib([
"ATM-TC-MIB", "TIMETRA-CHASSIS-MIB", "TIMETRA-GLOBAL-MIB",
"TIMETRA-PORT-MIB", "TIMETRA-TC-MIB"
])
self._get_device_details()
self._load_snmp_tables()
self._get_hw_data()
self._get_chassis_info()
self._get_power_ports_info()
self._get_modules_info()
self._get_ports_and_portchannels_info()
autoload_details = AutoloadDetailsBuilder(
self.resource).autoload_details()
self._log_autoload_details(autoload_details)
return autoload_details
def autoload_details(self):
""" """
with self._cli_handler.get_cli_service(
self._cli_handler.enable_mode) as enable_session:
autoload_actions = TRexAutoloadActions(enable_session)
resource = models.Chassis(
shell_name=self._resource_config.shell_name,
name=self._resource_config.name,
unique_id=self._resource_config.fullname)
ports = autoload_actions.get_trex_ports(
self._resource_config.trex_server_path)
for id, port in enumerate(ports):
port_res = models.Port(
shell_name=self._resource_config.shell_name,
name="Port {id}".format(id=id),
unique_id="{res_name}.{port_uid}".format(
res_name=self._resource_config.name, port_uid=port))
resource.add_sub_resource(id, port_res)
return AutoloadDetailsBuilder(resource).autoload_details()
def discover(self, supported_os):
"""General entry point for autoload,
read device structure and attributes: chassis, modules, submodules, ports, port-channels and power supplies
:return: AutoLoadDetails object
:rtype: AutoLoadDetails
"""
if not self._is_valid_device_os(supported_os):
raise Exception(self.__class__.__name__, 'Unsupported device OS')
self.logger.info('*' * 70)
self.logger.info('Start SNMP discovery process .....')
self.load_arista_mib()
self.snmp_service.load_mib(self.PRODUCT_MIBS)
self._get_device_details()
self._load_snmp_tables()
if self.arista_entity.chassis_list:
self._get_chassis_attributes(self.arista_entity.chassis_list)
self._get_power_ports(self.arista_entity.power_port_list)
self._get_module_attributes(self.arista_entity.module_list)
self._get_ports_attributes(self.arista_entity.port_list)
self._get_port_channels()
else:
self.logger.error("Entity table error, no chassis found")
autoload_details = AutoloadDetailsBuilder(self.resource).autoload_details()
self._log_autoload_details(autoload_details)
return autoload_details
def discover(self, supported_os):
"""General entry point for autoload,
read device structure and attributes: chassis, ports, port-channels and power supplies
:return: AutoLoadDetails object
:rtype: AutoLoadDetails
"""
if not self._is_valid_device_os(supported_os):
raise A10Exception('Unsupported device OS')
self.logger.info('*' * 70)
self.logger.info('Start SNMP discovery process .....')
self._load_mibs()
self.snmp_service.load_mib(['A10-COMMON-MIB', 'A10-AX-MIB'])
self._get_device_details()
self._load_snmp_tables()
self._add_chassis()
self._add_ports()
self._add_power_ports()
self._add_port_channels()
autoload_details = AutoloadDetailsBuilder(
self.resource).autoload_details()
self._log_autoload_details(autoload_details)
return autoload_details
def execute_flow(self):
"""
:return:
"""
root_resource = models.CiscoACIEPGController(shell_name=self._resource_config.shell_name,
name="Cisco ACI EPG Controller",
unique_id=self._resource_config.fullname)
tenants_structure = self._aci_api_client.get_tenants_structure()
tenant_name_gen = UniqueNameGenerator()
for tenant in tenants_structure:
unique_tenant_name = tenant_name_gen.get_unique_name(tenant["name"])
tenant_resource = models.CiscoACITenant(shell_name=self._resource_config.shell_name,
name=unique_tenant_name,
unique_id="{}.{}".format(self._resource_config.fullname,
unique_tenant_name))
tenant_resource.aci_name = tenant["name"]
root_resource.add_sub_resource(hash(unique_tenant_name), tenant_resource)
app_profile_name_gen = UniqueNameGenerator()
for app_profile in tenant["app_profiles"]:
unique_app_profile_name = app_profile_name_gen.get_unique_name(app_profile["name"])
app_profile_resource = models.CiscoACIAppProfile(shell_name=self._resource_config.shell_name,
name=unique_app_profile_name,
unique_id="{}.{}.{}"
.format(self._resource_config.fullname,
unique_tenant_name,
unique_app_profile_name))
app_profile_resource.aci_name = app_profile["name"]
tenant_resource.add_sub_resource(hash(unique_app_profile_name), app_profile_resource)
epg_name_gen = UniqueNameGenerator()
for epg in app_profile["epgs"]:
unique_epg_name = epg_name_gen.get_unique_name(epg["name"])
epg_resource = models.CiscoACIEndPointGroup(shell_name=self._resource_config.shell_name,
name=unique_epg_name,
unique_id="{}.{}.{}.{}".format(
self._resource_config.fullname,
unique_tenant_name,
unique_app_profile_name,
unique_epg_name))
epg_resource.aci_name = epg["name"]
app_profile_resource.add_sub_resource(hash(unique_epg_name), epg_resource)
return AutoloadDetailsBuilder(root_resource).autoload_details()
def discover(self, supported_os):
if not self._is_valid_device_os(supported_os):
raise Exception(
self.__class__.__name__,
'Unsupported device OS, see logs for more details')
self._build_root_elements()
self._build_chassis_elements()
self._build_ports()
self._build_port_channels()
# self._root.build_relative_path()
autoload_details = AutoloadDetailsBuilder(
self.resource).autoload_details()
# autoload_details = AutoLoadDetails(self._root.get_resources(), self._root.get_attributes())
return autoload_details
def test_validate_build_resource_structure(self):
"""Check that method will return dictionary with correct prefixes"""
autoload_resource = {
"resource_prefix":
{
"1": ["resource_1", "resource_2"],
"2": ["resource_3", "resource_4"]
}
}
# act
result = AutoloadDetailsBuilder._validate_build_resource_structure(autoload_resource=autoload_resource)
# verify
self.assertEqual(result, {
'resource_prefix1': 'resource_1',
'resource_prefix2': 'resource_3',
'resource_prefix3': 'resource_2',
'resource_prefix4': 'resource_4'
})
def discover(self, supported_os):
"""General entry point for autoload, read device structure and attributes.
Attributes: chassis, modules, submodules, ports,
port-channels and power supplies
:return: AutoLoadDetails object
"""
self.logger.info("*" * 70)
self.logger.info("Start SNMP discovery process .....")
self._load_mibs()
self._get_device_details()
self._load_snmp_tables()
self._build_ports()
autoload_details = AutoloadDetailsBuilder(
self.resource).autoload_details()
self._log_autoload_details(autoload_details)
return autoload_details
def discover(self, supported_os):
"""
Call methods in specific order to build resources and attributes
:return:
"""
if not self._is_valid_device_os(supported_os):
raise Exception(self.__class__.__name__, 'Unsupported device OS')
self._build_root()
self._build_chassis()
self._build_power_modules()
self._build_modules()
self._build_sub_modules()
self._build_ports()
autoload_details = AutoloadDetailsBuilder(
self.resource).autoload_details()
self._log_autoload_details(autoload_details)
return autoload_details
def discover(self, supported_os):
"""General entry point for autoload,
read device structure and attributes: chassis, modules, submodules, ports, port-channels and power supplies
:return: AutoLoadDetails object
"""
if not self._is_valid_device_os(supported_os):
raise Exception(self.__class__.__name__, 'Unsupported device OS')
self.logger.info("*" * 70)
self.logger.info("Start SNMP discovery process .....")
self.load_cisco_mib()
self.snmp_handler.load_mib(
["CISCO-PRODUCTS-MIB", "CISCO-ENTITY-VENDORTYPE-OID-MIB"])
self._get_device_details()
self._load_snmp_tables()
if self.chassis_list:
for chassis in self.chassis_list:
if chassis not in self.exclusion_list:
chassis_id = self._get_resource_id(chassis)
if chassis_id == "-1":
chassis_id = "0"
self.relative_address[chassis] = chassis_id
self._filter_lower_bay_containers()
self._get_module_list()
self._add_relative_addresss()
self._get_chassis_attributes()
self._get_power_ports()
self._get_module_attributes()
self._get_ports_attributes()
self._get_port_channels()
else:
self.logger.error("Entity table error, no chassis found")
autoload_details = AutoloadDetailsBuilder(
self.resource).autoload_details()
self._log_autoload_details(autoload_details)
return autoload_details
def discover(self):
"""
:param str ip: The device IP address
:param str model: The device model in CloudShell
:param str vendor: The device vendor
:param SNMPV2ReadParameters snmp_params: The device vendor
:return: The loaded resources and attributes
:rtype: AutoLoadDetails
"""
self._get_device_details()
self._load_snmp_tables()
self._build_chassis()
self._build_ports()
autoload_details = AutoloadDetailsBuilder(self.resource).autoload_details()
self._log_autoload_details(autoload_details)
return autoload_details
def discover(self, supported_os):
"""General entry point for autoload,
read device structure and attributes: chassis, modules, submodules, ports, port-channels and power supplies
:return: AutoLoadDetails object
"""
if not self._is_valid_device_os(supported_os):
raise Exception(self.__class__.__name__, 'Unsupported device OS')
self.logger.info("*" * 70)
self.logger.info("Start SNMP discovery process .....")
self.load_cisco_mib()
self.snmp_handler.load_mib(
["CISCO-PRODUCTS-MIB", "CISCO-ENTITY-VENDORTYPE-OID-MIB"])
self._get_device_details()
self._load_snmp_tables()
if self.cisco_entity.chassis_list:
self._get_chassis_attributes(self.cisco_entity.chassis_list)
self._get_power_ports(self.cisco_entity.power_port_list)
self._get_module_attributes(self.cisco_entity.module_list)
self._get_ports_attributes(self.cisco_entity.port_list)
self._get_port_channels()
else:
self.logger.error("Entity table error, no chassis found")
autoload_details = AutoloadDetailsBuilder(
self.resource).autoload_details()
if not self.shell_name:
root_model_name = [
x for x in autoload_details.attributes if
x.relative_address == "" and x.attribute_name == "Model Name"
][0]
if root_model_name:
autoload_details.attributes.remove(root_model_name)
self._log_autoload_details(autoload_details)
return autoload_details
def execute_flow(self):
"""
:return:
"""
with self._cli_handler.get_cli_service(
self._cli_handler.default_mode) as session:
output = CommandTemplateExecutor(
session,
command_templates.SHOW_INTERFACES,
).execute_command()
root_resource = models.GenericDeployedApp(
shell_name=self._resource_config.shell_name,
name="VyOS Deployed App",
unique_id=randint(1000, 9999)) # todo: get unique id somehow
interfaces_data = re.search(r".*[-]{2,}(.*)lo", output,
re.DOTALL).groups()[0].split("\n")
for interface_data in interfaces_data:
interface_name_match = re.search(
r"^(?P<interface_name>[a-zA-Z0-9]+?)[ ]{2,}.*",
interface_data)
if interface_name_match:
interface_name = interface_name_match.group(
"interface_name")
unique_id = hash(interface_name)
port = models.GenericVPort(
shell_name=self._resource_config.shell_name,
name=interface_name,
unique_id=unique_id)
root_resource.add_sub_resource(unique_id, port)
return AutoloadDetailsBuilder(root_resource).autoload_details()
def setUp(self):
self.autoload_data = mock.MagicMock()
self.builder = AutoloadDetailsBuilder(autoload_data=self.autoload_data)
def execute_flow(self):
"""
:return:
"""
root_resource = models.CiscoACIController(
shell_name=self._resource_config.shell_name,
name="Cisco ACI Ports Controller",
unique_id=self._resource_config.fullname)
ports_data = self._aci_api_client.get_leaf_ports()
for pod_id, pod_data in ports_data["pods"].iteritems():
pod_resource = models.CiscoACIPod(
shell_name=self._resource_config.shell_name,
name="Pod {}".format(pod_id),
unique_id="{}.{}".format(self._resource_config.fullname,
pod_id))
root_resource.add_sub_resource(pod_id, pod_resource)
for node_id, node_data in pod_data["nodes"].iteritems():
node_resource = models.CiscoACINode(
shell_name=self._resource_config.shell_name,
name="Node {}".format(node_id),
unique_id="{}.{}.{}".format(self._resource_config.fullname,
pod_id, node_id))
pod_resource.add_sub_resource(node_id, node_resource)
for slot_id, slot_data in node_data["slots"].iteritems():
slot_resource = models.CiscoACISlot(
shell_name=self._resource_config.shell_name,
name="Slot {}".format(slot_id),
unique_id="{}.{}.{}.{}".format(
self._resource_config.fullname, pod_id, node_id,
slot_id))
node_resource.add_sub_resource(slot_id, slot_resource)
for port_data in slot_data["ports"]:
port_id = port_data["id"]
port_resource = models.CiscoACIPort(
shell_name=self._resource_config.shell_name,
name="Port {}".format(port_id),
unique_id="{}.{}.{}.{}.{}".format(
self._resource_config.fullname, pod_id,
node_id, slot_id, port_id))
slot_resource.add_sub_resource(port_id, port_resource)
for fex_id, fex_data in node_data["fexs"].iteritems():
fex_resource = models.CiscoACIFex(
shell_name=self._resource_config.shell_name,
name="FEX {}".format(fex_id),
unique_id="{}.{}.{}.{}".format(
self._resource_config.fullname, pod_id, node_id,
fex_id))
node_resource.add_sub_resource(fex_id, fex_resource)
for slot_id, slot_data in fex_data["slots"].iteritems():
slot_resource = models.CiscoACIFexSlot(
shell_name=self._resource_config.shell_name,
name="Slot {}".format(slot_id),
unique_id="{}.{}.{}.{}.{}".format(
self._resource_config.fullname, pod_id,
node_id, fex_id, slot_id))
fex_resource.add_sub_resource(slot_id, slot_resource)
for port_data in slot_data["ports"]:
port_id = port_data["id"]
port_resource = models.CiscoACIFexPort(
shell_name=self._resource_config.shell_name,
name="Port {}".format(port_id),
unique_id="{}.{}.{}.{}.{}.{}".format(
self._resource_config.fullname, pod_id,
node_id, fex_id, slot_id, port_id))
slot_resource.add_sub_resource(
port_id, port_resource)
return AutoloadDetailsBuilder(root_resource).autoload_details()
def get_inventory(self, context):
"""Discovers the resource structure and attributes.
:param AutoLoadCommandContext context: the context the command runs on
:return Attribute and sub-resource information for the Shell resource you can return an AutoLoadDetails object
:rtype: AutoLoadDetails
"""
logger = get_logger_with_thread_id(context)
logger.info("Autoload")
with ErrorHandlingContext(logger):
cs_api = get_api(context)
vblade_resource = TeraVMTrafficGeneratorVBladeResource.from_context(context)
# get VM uuid of the Deployed App
deployed_vm_resource = cs_api.GetResourceDetails(vblade_resource.fullname)
vmuid = deployed_vm_resource.VmDetails.UID
logger.info("Deployed TVM Module App uuid: {}".format(vmuid))
# get vCenter name
app_request_data = json.loads(context.resource.app_context.app_request_json)
vcenter_name = app_request_data["deploymentService"]["cloudProviderName"]
logger.info("vCenter shell resource name: {}".format(vcenter_name))
vsphere = pyVmomiService(SmartConnect, Disconnect, task_waiter=None)
# get vCenter credentials
vcenter_resource = cs_api.GetResourceDetails(resourceFullPath=vcenter_name)
user = self._get_resource_attribute_value(resource=vcenter_resource,
attribute_name=VCENTER_RESOURCE_USER_ATTR)
encrypted_password = self._get_resource_attribute_value(resource=vcenter_resource,
attribute_name=VCENTER_RESOURCE_PASSWORD_ATTR)
password = cs_api.DecryptPassword(encrypted_password).Value
logger.info("Connecting to the vCenter: {}".format(vcenter_name))
si = vsphere.connect(address=vcenter_resource.Address, user=user, password=password)
# find Deployed App VM on the vCenter
vm = vsphere.get_vm_by_uuid(si, vmuid)
phys_interfaces = []
comms_mac_addr = None
for device in vm.config.hardware.device:
if isinstance(device, vim.vm.device.VirtualEthernetCard):
if device.deviceInfo.summary.lower() == vblade_resource.tvm_comms_network.lower():
comms_mac_addr = device.macAddress
else:
phys_interfaces.append(device)
if comms_mac_addr is None:
raise Exception("Unable to find TVM Comms network with name '{}' on the device"
.format(vblade_resource.tvm_comms_network))
logger.info("Found interfaces on the device: {}".format(phys_interfaces))
module_res = models.TeraVMModule(shell_name="",
name="Module {}".format(comms_mac_addr.replace(":", "-")),
unique_id=hash(comms_mac_addr))
logger.info("Updating resource address for the module to {}".format(comms_mac_addr))
cs_api.UpdateResourceAddress(context.resource.fullname, comms_mac_addr)
for port_number, phys_interface in enumerate(phys_interfaces, start=1):
network_adapter_number = phys_interface.deviceInfo.label.lower().strip("network adapter ")
unique_id = hash(phys_interface.macAddress)
port_res = models.TeraVMPort(shell_name="",
name="Port {}".format(port_number),
unique_id=unique_id)
port_res.mac_address = phys_interface.macAddress
port_res.requested_vnic_name = network_adapter_number
module_res.add_sub_resource(unique_id, port_res)
return AutoloadDetailsBuilder(module_res).autoload_details()
class TestAutoloadDetailsBuilder(unittest.TestCase):
def setUp(self):
self.autoload_data = mock.MagicMock()
self.builder = AutoloadDetailsBuilder(autoload_data=self.autoload_data)
def test_autoload_details(self):
self.builder._build_autoload_details = mock.MagicMock()
# act
result = self.builder.autoload_details()
# verify
self.assertEqual(result, self.builder._autoload_details)
self.builder._build_autoload_details.assert_called_once_with(self.autoload_data)
def test_validate_build_resource_structure(self):
"""Check that method will return dictionary with correct prefixes"""
autoload_resource = {
"resource_prefix":
{
"1": ["resource_1", "resource_2"],
"2": ["resource_3", "resource_4"]
}
}
# act
result = AutoloadDetailsBuilder._validate_build_resource_structure(autoload_resource=autoload_resource)
# verify
self.assertEqual(result, {
'resource_prefix1': 'resource_1',
'resource_prefix2': 'resource_3',
'resource_prefix3': 'resource_2',
'resource_prefix4': 'resource_4'
})
@mock.patch("cloudshell.devices.autoload.autoload_builder.AutoLoadResource")
@mock.patch("cloudshell.devices.autoload.autoload_builder.AutoLoadAttribute")
def test_build_autoload_details(self, autoload_attribute_class, autoload_resource_class):
"""Check that method will add attributes and resources to the _autoload_details property"""
autoload_data = mock.MagicMock(attributes={"test_attr": "test_val"})
autoload_attr = mock.MagicMock()
autoload_attribute_class.return_value = autoload_attr
autoload_resource = mock.MagicMock()
autoload_resource_class.return_value = autoload_resource
resource = mock.MagicMock()
self.builder._autoload_details = mock.MagicMock()
self.builder._validate_build_resource_structure = mock.MagicMock(return_value={
"resource_relative_path": resource
})
# need to copy func to prevent recursion
tested_func = self.builder._build_autoload_details
self.builder._build_autoload_details = mock.MagicMock()
# act
tested_func(autoload_data=autoload_data, relative_path="relative_path")
# verify
self.builder._autoload_details.attributes.extend.assert_called_once_with([autoload_attr])
autoload_attribute_class.assert_called_once_with(relative_address="relative_path",
attribute_name="test_attr",
attribute_value="test_val")
self.builder._autoload_details.resources.append.assert_called_once_with(autoload_resource)
autoload_resource_class.assert_called_once_with(model=resource.cloudshell_model_name,
name=resource.name,
relative_address='relative_path/resource_relative_path',
unique_identifier=resource.unique_identifier)
self.builder._build_autoload_details.assert_called_once_with(
autoload_data=resource,
relative_path="relative_path/resource_relative_path")
def get_inventory(self, context):
"""Discovers the resource structure and attributes.
:param AutoLoadCommandContext context: the context the command runs on
:return Attribute and sub-resource information for the Shell resource you can return an AutoLoadDetails object
:rtype: AutoLoadDetails
"""
logger = get_logger_with_thread_id(context)
logger.info("Autoload command started")
with ErrorHandlingContext(logger):
resource_config = TrafficGeneratorVChassisResource.from_context(context,
shell_type=SHELL_TYPE,
shell_name=SHELL_NAME)
if not resource_config.address or resource_config.address.upper() == "NA":
logger.info("Skip 'Autoload' command for now...")
return AutoLoadDetails([], [])
cs_api = get_api(context)
password = cs_api.DecryptPassword(resource_config.password).Value
logger.info("Initializing API client")
api_client = IxVMChassisHTTPClient(address=resource_config.address,
user=resource_config.user,
password=password)
logger.info("Waiting for API service to be deployed")
self._wait_for_service_deployment(api_client, logger)
configuration_operations = IxVMConfigurationRunner(resource_config=resource_config,
cli=self._cli,
cs_api=cs_api,
logger=logger)
logger.info("Executing congfigure license server operation")
configuration_operations.configure_license_server(license_server_ip=resource_config.license_server)
logger.info("Performing API client login")
api_client.login()
logger.info("Waiting for the Chassis data")
self._wait_for_chassis_structure(api_client, logger)
logger.info("Retrieving Chassis data from the API")
chassis_data = api_client.get_chassis()[0]
chassis_id = chassis_data["id"]
chassis_res = models.IxVMChassis(shell_type=SHELL_TYPE,
shell_name=resource_config.shell_name,
name="IxVm Virtual Chassis {}".format(chassis_id),
unique_id=chassis_id)
ports_data = {}
for port_data in api_client.get_ports():
parent_id = port_data["parentId"]
port_number = port_data["portNumber"]
ports_by_module = ports_data.setdefault(parent_id, [])
ports_by_module.append(port_data)
logger.info("Found Port {} under the parent id {}".format(port_number, parent_id))
for module_data in api_client.get_cards():
module_id = module_data["id"]
module_number = module_data["cardNumber"]
module_res = models.IxVMModule(shell_name=resource_config.shell_name,
name="IxVm Virtual Module {}".format(module_number),
unique_id=module_id)
logger.info("Adding Module {} to the Chassis".format(module_number))
chassis_res.add_sub_resource(module_number, module_res)
ports_data = ports_data.get(module_id, [])
ports_data.sort(key=lambda x: int(x["portNumber"]))
for nw_adapter_number, port_data in enumerate(ports_data, start=2): # first nw adapter port is MGMT
port_id = port_data["id"]
port_number = port_data["portNumber"]
port_res = models.IxVMPort(shell_name=resource_config.shell_name,
name="Port {}".format(port_number),
unique_id=port_id)
port_res.requested_vnic_name = nw_adapter_number
logger.info("Adding Port {} under the module {}".format(port_number, module_id))
module_res.add_sub_resource(port_number, port_res)
return AutoloadDetailsBuilder(chassis_res).autoload_details()
