Exemple #1
0
    def _create_target_fchba_details(self, remote_descriptors):
        result = []
        if remote_descriptors:
            for remote_descriptor in remote_descriptors:
                try:
                    port_id = Sfn(int)(remote_descriptor.target_n_port_id, 16)
                    wwpn = wwn.normalize(remote_descriptor.target_port_wwn)
                    wwnn = wwn.normalize(remote_descriptor.target_node_wwn)
                    port_type = remote_descriptor.port_type
                    port_name = ''
                    node_name = ''
                    if remote_descriptor.symbolic_port_name and remote_descriptor.symbolic_port_name.lower(
                    ) != 'none':
                        port_name = remote_descriptor.symbolic_port_name
                    if remote_descriptor.symbolic_node_name and remote_descriptor.symbolic_node_name.lower(
                    ) != 'none':
                        node_name = remote_descriptor.symbolic_node_name

                    fchba = fc_hba_model.FcHba('', node_name, wwn=wwnn)
                    fcport = fc_hba_model.FcPort(port_id,
                                                 wwpn,
                                                 type=port_type,
                                                 name=port_name)
                    result.append((fchba, fcport, None))
                except (TypeError, ValueError):
                    logger.debugException(
                        'Failed to create target fchba/fcport data object')
        return tuple(result)
Exemple #2
0
    def get_fc_hbas(self, shell):
        result = []
        executor = command.cmdlet.executeCommand(shell)
        lsdev = lsdev_aix.find(executor)
        vpd_discoverer = vital_product_data.Discoverer.find_impl(executor)

        exec_ = Sfn(self.__get_produce_result_executor(shell).process)
        fcadapters = self.list_fc_adapter_names(lsdev, exec_)
        for fcs in fcadapters:
            try:
                descriptor = vpd_discoverer.get_fc_vpd_by_devicename(
                    fcs, executor)
                id_ = descriptor.hardware_location_code
                nodewwn = descriptor.device_specific.get('Z8')
                fw_version = None
                if 'Z9' in descriptor.device_specific:
                    fw_version = descriptor.device_specific.get('Z9')
                    _, fw_version = fw_version.split('.')
                nodewwn = wwn.parse_from_str(nodewwn)

                portwwn = descriptor.network_address
                serialnum = descriptor.serial_number
                model = descriptor.platform_specific.model

                driverid = descriptor.driverid
                vendor = Sfn(self.parse_vendor_from_driverid)(driverid)

                driver_version = self.get_driver_version(driverid, exec_)
                fchba = fc_hba_model.FcHba(id_,
                                           fcs,
                                           wwn=nodewwn,
                                           vendor=vendor,
                                           model=model,
                                           serial_number=serialnum,
                                           driver_version=driver_version,
                                           firmware_version=fw_version)
                ports = []
                try:
                    port_wwn = wwn.parse_from_str(portwwn)
                    fcstat = Sfn(fcstat_aix.find)(executor)
                    port_id = None
                    type_ = None
                    if fcstat:
                        fcstat_descriptor = exec_(fcstat(fcs))
                        if fcstat_descriptor:
                            port_id = Sfn(int)(fcstat_descriptor.port_fc_id,
                                               16)
                            type_ = fcstat_descriptor.port_type
                            port_speed = fcstat_descriptor.running_port_speed
                    ports.append((fc_hba_model.FcPort(port_id, port_wwn, type_,
                                                      None, port_speed), ()))
                except (command.ExecuteException, TypeError, ValueError), ex:
                    logger.debugException(
                        'Failed to create fcport data object')

                result.append((fchba, ports))

            except (command.ExecuteException, TypeError, ValueError), ex:
                logger.debugException('Failed to create fchba data object')
Exemple #3
0
 def _create_target_fchba_details(self, scsi_paths):
     result = []
     if scsi_paths:
         for path in scsi_paths:
             try:
                 identifier = path.get('TargetIdentifier')
                 wwnn, wwpn = self._decompose_adapter_identifier(identifier)
                 fchba = fc_hba_model.FcHba('', '', wwn=wwnn)
                 fcport = fc_hba_model.FcPort(None, wwpn)
                 result.append((fchba, fcport, None))
             except (TypeError, ValueError):
                 logger.debugException('Failed to create target fchba/fcport data object')
     return tuple(result)
Exemple #4
0
 def _create_target_fchba_details(self, remote_port_descriptors):
     result = []
     if remote_port_descriptors:
         for descriptor in remote_port_descriptors:
             try:
                 wwpn = wwn.parse_from_str(descriptor.remote_port_wwn)
                 wwnn = wwn.parse_from_str(descriptor.node_wwn)
                 fchba = fc_hba_model.FcHba('', '', wwn=wwnn)
                 fcport = fc_hba_model.FcPort(None, wwpn)
                 result.append((fchba, fcport, None))
             except (TypeError, ValueError):
                 logger.debugException('Failed to create target fchba/fcport data object')
     return tuple(result)
Exemple #5
0
    def get_fc_hbas(self, shell):
        executor = self.__get_produce_result_executor(shell)
        list_file_names_fn = self._get_list_dir_fullnames_fn(shell)
        get_content_fn = self._get_file_content_fn(shell)
        result = defaultdict(list)
        for path in self.list_fc_host_instances(list_file_names_fn):
            try:
                name = path.basename
                driver_version = Sfn(self.get_driver_version)(get_content_fn,
                                                              name)
                fw_version = Sfn(self.get_fw_version)(get_content_fn, name)
                model = Sfn(self.get_model_name)(get_content_fn, name)
                portwwn = self.get_port_name(get_content_fn, name)
                nodewwn = self.get_node_name(get_content_fn, name)
                nodewwn = wwn.parse_from_str(nodewwn)
                serialnum = Sfn(self.get_serial_num)(get_content_fn, name)
                vendor = Sfn(self.get_vendor_by_device_path)(path, executor)

                fchba = fc_hba_model.FcHba(name,
                                           unicode(path),
                                           wwn=nodewwn,
                                           vendor=vendor,
                                           model=model,
                                           serial_number=serialnum,
                                           driver_version=driver_version,
                                           firmware_version=fw_version)

                remote_ports = self.get_remote_port_descriptors(
                    list_file_names_fn, get_content_fn, name)
                ports = []
                try:
                    port_id = self.get_port_id(get_content_fn, name)
                    port_id = Sfn(int)(port_id, 16)
                    port_wwn = wwn.parse_from_str(portwwn)
                    type_ = self.get_port_type(get_content_fn, name)
                    port_speed = _parse_port_speed(
                        self.get_port_speed(get_content_fn, name))
                    ports.append(
                        (fc_hba_model.FcPort(port_id, port_wwn, type_, None,
                                             port_speed),
                         self._create_target_fchba_details(remote_ports)))
                except (command.ExecuteException, TypeError, ValueError), ex:
                    logger.debugException(
                        'Failed to create fcport data object')

                result[fchba].extend(ports)
            except (command.ExecuteException, TypeError, ValueError), ex:
                logger.debugException('Failed to create fchba data object')
Exemple #6
0
    def get_fc_hbas(self, shell):
        result = []
        descriptors = fc_hba_descriptors_by_hpux_fcmsutil.get_fc_hba_descriptors(
            shell)
        find_name_by_id_in_hex = Sfn(vendors.find_name_by_id_in_hex)
        for ioscan_dscriptor, fc_descriptor, fc_vpd_descriptor in descriptors:
            try:
                hba_id = ioscan_dscriptor.device_filename
                name = ioscan_dscriptor.device_filename
                node_wwn = fc_descriptor.n_port_node_world_wide_name
                node_wwn = wwn.normalize(node_wwn)
                vendor = find_name_by_id_in_hex(fc_descriptor.vendor_id)
                model = fc_vpd_descriptor.part_number
                serial_number = fc_vpd_descriptor.part_serial_number
                driver_version = fc_descriptor.driver_version
                firmware_version = fc_vpd_descriptor.rom_firmware_version
                port_speed = fc_descriptor.link_speed
                fchba = fc_hba_model.FcHba(hba_id,
                                           name,
                                           wwn=node_wwn,
                                           vendor=vendor,
                                           model=model,
                                           serial_number=serial_number,
                                           driver_version=driver_version,
                                           firmware_version=firmware_version)
                port_id = fc_descriptor.local_n_port_id
                port_wwn = wwn.normalize(
                    fc_descriptor.n_port_port_world_wide_name)
                type_ = fc_descriptor.topology
                ports = []

                port_id = Sfn(int)(port_id, 16)
                speed = _parse_port_speed(port_speed)

                remote_descriptors = Sfn(fc_hba_descriptors_by_hpux_fcmsutil.
                                         get_remote_fc_hba_descriptors)(
                                             shell,
                                             ioscan_dscriptor.device_filename)
                target_fchbas = self._create_target_fchba_details(
                    remote_descriptors)
                ports.append((fc_hba_model.FcPort(port_id, port_wwn, type_,
                                                  None, speed), target_fchbas))
                result.append((fchba, tuple(ports)))
            except (TypeError, ValueError), ex:
                logger.debugException('Failed to create fchba data object')
Exemple #7
0
    def get_fc_hbas(self, shell):
        executor = command.cmdlet.executeCommand(shell)
        fcinfo_impl = find_fcinfo_impl(executor)()
        exec_ = command.get_exec_fn(executor)
        safe_exec_ = command.get_safe_exec_fn(executor)

        descriptors = exec_(fcinfo_impl.hba_port())
        result = []
        for fchba_descriptor in descriptors:
            try:
                name = fchba_descriptor.name
                nodewwn = wwn.parse_from_str(fchba_descriptor.node_wwn)
                portwwn = fchba_descriptor.port_wwn
                model = fchba_descriptor.model
                vendor = fchba_descriptor.vendor
                type_ = fchba_descriptor.type
                serialnum = fchba_descriptor.serial_number
                driver_version = fchba_descriptor.driver_version
                fw_version = fchba_descriptor.firmware_version
                port_speed = fchba_descriptor.port_speed
                fchba = fc_hba_model.FcHba(name, name,
                                           wwn=nodewwn,
                                           vendor=vendor, model=model,
                                           serial_number=serialnum,
                                           driver_version=driver_version,
                                           firmware_version=fw_version)
                ports = []
                try:
                    port_id = None
                    port_wwn = wwn.parse_from_str(portwwn)
                    speed = _parse_port_speed(port_speed)
                    remote_port_descriptors = safe_exec_(fcinfo_impl.remote_port.p(portwwn))
                    target_fchbas = self._create_target_fchba_details(remote_port_descriptors)
                    ports.append((fc_hba_model.FcPort(port_id, port_wwn,
                                                      type_, None, speed),
                                  target_fchbas))
                except (command.ExecuteException, TypeError, ValueError), ex:
                    logger.debugException('Failed to create fcport data object')
                result.append((fchba, ports))
            except (command.ExecuteException, TypeError, ValueError), ex:
                logger.debugException('Failed to create fchba data object')
    def get_fc_hbas(self, shell):
        result = []
        executor = self.get_executor(shell)
        pairs = get_fc_hba_descriptors(executor)
        parse_wwn_ = Sfn(parse_wwn)
        for adapter_descriptor, port_descriptors in pairs:
            hba_id = adapter_descriptor.UniqueAdapterId
            name = adapter_descriptor.InstanceName
            node_wwn = adapter_descriptor.NodeWWN
            node_wwn = node_wwn and parse_wwn_(node_wwn)
            vendor = adapter_descriptor.Manufacturer
            model = adapter_descriptor.Model
            serial_number = adapter_descriptor.SerialNumber
            driver_version = adapter_descriptor.DriverVersion
            firmware_version = adapter_descriptor.FirmwareVersion
            fchba = fc_hba_model.FcHba(hba_id,
                                       name,
                                       wwn=node_wwn,
                                       vendor=vendor,
                                       model=model,
                                       serial_number=serial_number,
                                       driver_version=driver_version,
                                       firmware_version=firmware_version)
            ports = []
            for port_descriptor in port_descriptors:
                try:
                    port_id = port_descriptor.UniquePortId
                    portname = port_descriptor.InstanceName
                    port_wwn = parse_wwn_(port_descriptor.Attributes.PortWWN)
                    type_ = Sfn(parse_port_type)(
                        port_descriptor.Attributes.PortType)
                    port_speed = float(port_descriptor.Attributes.PortSpeed)
                    ports.append((fc_hba_model.FcPort(port_id,
                                                      port_wwn,
                                                      type_,
                                                      portname,
                                                      speed=port_speed), ()))
                except (TypeError, ValueError), ex:
                    logger.debugException('Failed to create fchba data object')

            result.append((fchba, tuple(ports)))
Exemple #9
0
 def _create_target_fchba_details(self, remote_descriptors):
     result = []
     if remote_descriptors:
         for nodewwn, port_descriptors in remote_descriptors.items():
             for port_descriptor in port_descriptors:
                 portid, portwwn = port_descriptor
                 try:
                     port_id = Sfn(int)(portid, 16)
                     wwpn = wwn.normalize(portwwn)
                     wwnn = wwn.normalize(nodewwn)
                     port_name = ''
                     node_name = ''
                     fchba = fc_hba_model.FcHba('', node_name, wwn=wwnn)
                     fcport = fc_hba_model.FcPort(port_id,
                                                  wwpn,
                                                  type=None,
                                                  name=port_name)
                     result.append((fchba, fcport, None))
                 except (TypeError, ValueError):
                     logger.debugException(
                         'Failed to create target fchba/fcport data object')
     return tuple(result)
Exemple #10
0
    def get_fc_hbas(self, shell):
        result = defaultdict(list)
        executor = command.cmdlet.executeCommand(shell)
        esxcli = find_esxcli_impl(executor)()
        esxcli = esxcli.formatter('csv')
        esxcli_exec = command.get_exec_fn(esxcli, executor)
        storage = EsxcliStorageNamespace(esxcli)
        software = EsxcliSoftwareNamespace(esxcli)

        scsi_path_by_adapter_identifier = fptools.groupby(methodcaller('get', 'AdapterIdentifier'), esxcli_exec(storage.core.path.list()))

        adapters = esxcli_exec(storage.core.adapter.list())
        grouped_adapters = dict((adapter.get('HBAName'), adapter)
                                    for adapter in adapters)

        grouped = defaultdict(list)
        for descriptor in esxcli_exec(storage.san.fc.list()):
            grouped[(descriptor.get('Adapter'),
                     descriptor.get('NodeName'))].append(descriptor)

        get_vendor = Sfn(self.get_vendor)
        get_fchba_descriptor = Sfn(self._get_fchba_descriptor)
        for key, descriptors in grouped.iteritems():
            try:
                vmhba, nodewwn = key
                nodewwn = wwn.parse_from_str(nodewwn)
                name = vmhba
                id_ = vmhba
                adapter_descriptor = grouped_adapters.get(vmhba)
                driverversion = None
                vendor = get_vendor(vmhba, executor)
                model = None
                fwversion = None
                serialnum = None
                if adapter_descriptor:
                    id_ = adapter_descriptor.get('UID')
                    driver = adapter_descriptor.get('Driver')
                    vib_descriptor = esxcli_exec(software.vib.get(vibname=driver))
                    driverversion = vib_descriptor.get('Version')
                    fchabdescriptor = get_fchba_descriptor(driver, vmhba, executor)
                    if fchabdescriptor:
                        model = fchabdescriptor.model
                        fwversion = fchabdescriptor.firmwareversion
                        serialnum = fchabdescriptor.serialnumber
                        driverversion = fchabdescriptor.driverversion

                fchba = fc_hba_model.FcHba(id_, name,
                                           wwn=nodewwn,
                                           vendor=vendor, model=model,
                                           serial_number=serialnum,
                                           driver_version=driverversion,
                                           firmware_version=fwversion)

                ports = []
                for fcdescriptor in descriptors:
                    try:
                        portwwn = fcdescriptor.get('PortName')
                        porttype = fcdescriptor.get('PortType')
                        portwwn = wwn.parse_from_str(portwwn)
                        portid = fcdescriptor.get('PortID')
                        port_speed = _parse_port_speed(fcdescriptor.get('Speed'))
                        portid = Sfn(int)(portid, 16)

                        adapter_identifier = self._compose_adapter_identifier(nodewwn, portwwn)
                        scsi_paths = scsi_path_by_adapter_identifier.get(adapter_identifier)
                        target_fcdescriptors = self._create_target_fchba_details(scsi_paths)
                        ports.append((fc_hba_model.FcPort(portid, portwwn,
                                                          porttype, None, port_speed),
                                      target_fcdescriptors))
                    except (command.ExecuteException, TypeError, ValueError), ex:
                        logger.debugException('Failed to create fcport data object')
                result[fchba].extend(ports)
            except (command.ExecuteException, TypeError, ValueError), ex:
                logger.debugException('Failed to create fchba data object')