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 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 """ 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 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 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 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 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. 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): """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 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()
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 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()