pyghmi 1.5.71__py3-none-any.whl → 1.5.75__py3-none-any.whl

pyghmi/redfish/oem/generic.py

@@ -17,12 +17,17 @@ from fnmatch import fnmatch
 import json
 import os
 import re
+from datetime import datetime
+from datetime import timedelta
+from dateutil import tz
 import time
 
 import pyghmi.constants as const
 import pyghmi.exceptions as exc
 import pyghmi.media as media
 import pyghmi.util.webclient as webclient
+from pyghmi.util.parse import parse_time
+
 
 
 class SensorReading(object):
@@ -44,11 +49,29 @@ class SensorReading(object):
         self.units = units
         self.unavailable = unavailable
 
+
+def _to_boolean(attrval):
+    attrval = attrval.lower()
+    if not attrval:
+        return False
+    if ('true'.startswith(attrval) or 'yes'.startswith(attrval)
+            or 'enabled'.startswith(attrval) or attrval == '1'):
+        return True
+    if ('false'.startswith(attrval) or 'no'.startswith(attrval)
+            or 'disabled'.startswith(attrval) or attrval == '0'):
+        return False
+    raise Exception(
+        'Unrecognized candidate for boolean: {0}'.format(attrval))
+
+
 def _normalize_mac(mac):
     if ':' not in mac:
-        mac = ':'.join((mac[:2], mac[2:4], mac[4:6], mac[6:8], mac[8:10], mac[10:12]))
+        mac = ':'.join((
+            mac[:2], mac[2:4], mac[4:6],
+            mac[6:8], mac[8:10], mac[10:12]))
     return mac.lower()
 
+
 _healthmap = {
     'Critical': const.Health.Critical,
     'Unknown': const.Health.Warning,
@@ -169,6 +192,122 @@ class OEMHandler(object):
         self._urlcache = cache
         self.webclient = webclient
 
+    def supports_expand(self, url):
+        # Unfortunately, the state of expand in redfish is pretty dicey,
+        # so an OEM handler must opt into this behavior
+        # There is a way an implementation advertises support, however
+        # this isn't to be trusted.
+        # Even among some generally reputable implementations, they will fail in some scenarios
+        # and you'll see in their documentation "some urls will fail if you try to expand them"
+        # perhaps being specific, but other times being vague, but in either case,
+        # nothing programattic to consume to know when to do or not do an expand..
+        return False
+
+    def get_system_power_watts(self, fishclient):
+        totalwatts = 0
+        gotpower = False
+        for chassis in fishclient.sysinfo.get('Links', {}).get('Chassis', []):
+            envinfo = fishclient._get_chassis_env(chassis)
+            currwatts = envinfo.get('watts', None)
+            if currwatts is not None:
+                gotpower = True
+                totalwatts += envinfo['watts']
+        if not gotpower:
+            raise exc.UnsupportedFunctionality("System does not provide Power under redfish EnvironmentMetrics")
+        return totalwatts
+
+    def _get_cpu_temps(self, fishclient):
+        cputemps = []
+        for chassis in fishclient.sysinfo.get('Links', {}).get('Chassis', []):
+            thermals = fishclient._get_thermals(chassis)
+            for temp in thermals:
+                if temp.get('PhysicalContext', '') != 'CPU':
+                    continue
+                if temp.get('ReadingCelsius', None) is None:
+                    continue
+                cputemps.append(temp)
+        return cputemps
+
+    def get_event_log(self, clear=False, fishclient=None, extraurls=[]):
+        bmcinfo = self._do_web_request(fishclient._bmcurl)
+        lsurl = bmcinfo.get('LogServices', {}).get('@odata.id', None)
+        if not lsurl:
+            return
+        currtime = bmcinfo.get('DateTime', None)
+        correction = timedelta(0)
+        utz = tz.tzoffset('', 0)
+        ltz = tz.gettz()
+        if currtime:
+            currtime = parse_time(currtime)
+        if currtime:
+            now = datetime.now(utz)
+            try:
+                correction = now - currtime
+            except TypeError:
+                correction = now - currtime.replace(tzinfo=utz)
+        lurls = self._do_web_request(lsurl).get('Members', [])
+        lurls.extend(extraurls)
+        for lurl in lurls:
+            lurl = lurl['@odata.id']
+            loginfo = self._do_web_request(lurl, cache=(not clear))
+            entriesurl = loginfo.get('Entries', {}).get('@odata.id', None)
+            if not entriesurl:
+                continue
+            logid = loginfo.get('Id', '')
+            entries = self._do_web_request(entriesurl, cache=False)
+            if clear:
+                # The clear is against the log service etag, not entries
+                # so we have to fetch service etag after we fetch entries
+                # until we can verify that the etag is consistent to prove
+                # that the clear is atomic
+                newloginfo = self._do_web_request(lurl, cache=False)
+                clearurl = newloginfo.get('Actions', {}).get(
+                    '#LogService.ClearLog', {}).get('target', '')
+                while clearurl:
+                    try:
+                        self._do_web_request(clearurl, method='POST',
+                                            payload={})
+                        clearurl = False
+                    except exc.PyghmiException as e:
+                        if 'EtagPreconditionalFailed' not in str(e):
+                            raise
+                        # This doesn't guarantee atomicity, but it mitigates
+                        # greatly.  Unfortunately some implementations
+                        # mutate the tag endlessly and we have no hope
+                        entries = self._do_web_request(entriesurl, cache=False)
+                        newloginfo = self._do_web_request(lurl, cache=False)
+            for log in entries.get('Members', []):
+                if ('Created' not in log and 'Message' not in log
+                        and 'Severity' not in log):
+                    # without any data, this log entry isn't actionable
+                    continue
+                record = {}
+                record['log_id'] = logid
+                parsedtime = parse_time(log.get('Created', ''))
+                if not parsedtime:
+                    parsedtime = parse_time(log.get('EventTimestamp', ''))
+                if parsedtime:
+                    entime = parsedtime + correction
+                    entime = entime.astimezone(ltz)
+                    record['timestamp'] = entime.strftime('%Y-%m-%dT%H:%M:%S')
+                else:
+                    record['timestamp'] = log.get('Created', '')
+                record['message'] = log.get('Message', None)
+                record['severity'] = _healthmap.get(
+                    log.get('Severity', 'Warning'), const.Health.Ok)
+                yield record
+
+    def get_average_processor_temperature(self, fishclient):
+        cputemps = self._get_cpu_temps(fishclient)
+        if not cputemps:
+            return  SensorReading(
+            None, {'name': 'Average Processor Temperature'}, value=None, units='°C',
+                   unavailable=True)
+        cputemps = [x['ReadingCelsius'] for x in cputemps]
+        avgtemp = sum(cputemps) / len(cputemps)
+        return SensorReading(
+            None, {'name': 'Average Processor Temperature'}, value=avgtemp, units='°C')
+
     def get_health(self, fishclient, verbose=True):
         health = fishclient.sysinfo.get('Status', {})
         health = health.get('HealthRollup', health.get('Health', 'Unknown'))
@@ -208,9 +347,8 @@ class OEMHandler(object):
                                             memsumstatus.get('Health', None))
             if memsumstatus != 'OK':
                 dimmfound = False
-                for mem in fishclient._do_web_request(
-                        fishclient.sysinfo['Memory']['@odata.id'])['Members']:
-                    dimminfo = fishclient._do_web_request(mem['@odata.id'])
+                dimmdata = self._get_mem_data()
+                for dimminfo in dimmdata['Members']:
                     if dimminfo.get('Status', {}).get(
                             'State', None) == 'Absent':
                         continue
@@ -345,6 +483,38 @@ class OEMHandler(object):
     def get_system_configuration(self, hideadvanced=True, fishclient=None):
         return self._getsyscfg(fishclient)[0]
 
+    def _get_attrib_registry(self, fishclient, attribreg):
+        overview = fishclient._do_web_request('/redfish/v1/')
+        reglist = overview['Registries']['@odata.id']
+        reglist = fishclient._do_web_request(reglist)
+        regurl = None
+        for cand in reglist.get('Members', []):
+            cand = cand.get('@odata.id', '')
+            candname = cand.split('/')[-1]
+            if candname == '':  # implementation uses trailing slash
+                candname = cand.split('/')[-2]
+            if candname == attribreg:
+                regurl = cand
+                break
+        if not regurl:
+            # Workaround a vendor bug where they link to a
+            # non-existant name
+            for cand in reglist.get('Members', []):
+                cand = cand.get('@odata.id', '')
+                candname = cand.split('/')[-1]
+                candname = candname.split('.')[0]
+                if candname == attribreg.split('.')[0]:
+                    regurl = cand
+                    break
+        if regurl:
+            reginfo = fishclient._do_web_request(regurl)
+            for reg in reginfo.get('Location', []):
+                if reg.get('Language', 'en').startswith('en'):
+                    reguri = reg['Uri']
+                    reginfo = self._get_biosreg(reguri, fishclient)
+                    return reginfo
+                    extrainfo, valtodisplay, _, self.attrdeps = reginfo
+
     def _getsyscfg(self, fishclient):
         biosinfo = self._do_web_request(fishclient._biosurl, cache=False)
         reginfo = ({}, {}, {}, {})
@@ -352,36 +522,9 @@ class OEMHandler(object):
         valtodisplay = {}
         self.attrdeps = {'Dependencies': [], 'Attributes': []}
         if 'AttributeRegistry' in biosinfo:
-            overview = fishclient._do_web_request('/redfish/v1/')
-            reglist = overview['Registries']['@odata.id']
-            reglist = fishclient._do_web_request(reglist)
-            regurl = None
-            for cand in reglist.get('Members', []):
-                cand = cand.get('@odata.id', '')
-                candname = cand.split('/')[-1]
-                if candname == '':  # implementation uses trailing slash
-                    candname = cand.split('/')[-2]
-                if candname == biosinfo['AttributeRegistry']:
-                    regurl = cand
-                    break
-            if not regurl:
-                # Workaround a vendor bug where they link to a
-                # non-existant name
-                for cand in reglist.get('Members', []):
-                    cand = cand.get('@odata.id', '')
-                    candname = cand.split('/')[-1]
-                    candname = candname.split('.')[0]
-                    if candname == biosinfo[
-                            'AttributeRegistry'].split('.')[0]:
-                        regurl = cand
-                        break
-            if regurl:
-                reginfo = fishclient._do_web_request(regurl)
-                for reg in reginfo.get('Location', []):
-                    if reg.get('Language', 'en').startswith('en'):
-                        reguri = reg['Uri']
-                        reginfo = self._get_biosreg(reguri, fishclient)
-                        extrainfo, valtodisplay, _, self.attrdeps = reginfo
+            reginfo = self._get_attrib_registry(fishclient, biosinfo['AttributeRegistry'])
+            if reginfo:
+                extrainfo, valtodisplay, _, self.attrdeps = reginfo
         currsettings = {}
         try:
             pendingsettings = fishclient._do_web_request(
@@ -418,10 +561,19 @@ class OEMHandler(object):
         rawsettings = fishclient._do_web_request(fishclient._biosurl,
                                                  cache=False)
         rawsettings = rawsettings.get('Attributes', {})
-        pendingsettings = fishclient._do_web_request(fishclient._setbiosurl)
+        pendingsettings = fishclient._do_web_request(
+            fishclient._setbiosurl)
+        return self._set_redfish_settings(
+            changeset, fishclient, currsettings, rawsettings,
+            pendingsettings, self.attrdeps, reginfo,
+            fishclient._setbiosurl)
+
+    def _set_redfish_settings(self, changeset, fishclient, currsettings,
+                              rawsettings, pendingsettings, attrdeps, reginfo,
+                              seturl):
         etag = pendingsettings.get('@odata.etag', None)
         pendingsettings = pendingsettings.get('Attributes', {})
-        dephandler = AttrDependencyHandler(self.attrdeps, rawsettings,
+        dephandler = AttrDependencyHandler(attrdeps, rawsettings,
                                            pendingsettings)
         for change in list(changeset):
             if change not in currsettings:
@@ -440,7 +592,7 @@ class OEMHandler(object):
             changeval = changeset[change]
             overrides, blameattrs = dephandler.get_overrides(change)
             meta = {}
-            for attr in self.attrdeps['Attributes']:
+            for attr in attrdeps['Attributes']:
                 if attr['AttributeName'] == change:
                     meta = dict(attr)
                     break
@@ -479,7 +631,7 @@ class OEMHandler(object):
                         changeset[change] = _to_boolean(changeset[change])
         redfishsettings = {'Attributes': changeset}
         fishclient._do_web_request(
-            fishclient._setbiosurl, redfishsettings, 'PATCH', etag=etag)
+            seturl, redfishsettings, 'PATCH', etag=etag)
 
     def attach_remote_media(self, url, username, password, vmurls):
         return None
@@ -487,10 +639,17 @@ class OEMHandler(object):
     def detach_remote_media(self):
         return None
 
-    def get_description(self):
+    def get_description(self, fishclient):
+        for chassis in fishclient.sysinfo.get('Links', {}).get('Chassis', []):
+            chassisurl = chassis['@odata.id']
+            chassisinfo = self._do_web_request(chassisurl)
+            hmm = chassisinfo.get('HeightMm', None)
+            if hmm:
+                return {'height': hmm/44.45}
         return {}
 
-    def get_firmware_inventory(self, components):
+
+    def get_firmware_inventory(self, components, fishclient):
         return []
 
     def set_credentials(self, username, password):
@@ -529,15 +688,30 @@ class OEMHandler(object):
         for adp in self._get_adp_inventory(True, withids):
             yield adp
 
+    def _get_node_info(self):
+        nodeinfo = self._varsysinfo
+        if not nodeinfo:
+            overview = self._do_web_request('/redfish/v1/')
+            chassismembs = overview.get('Chassis', {}).get('@odata.id', None)
+            if not chassismembs:
+                return nodeinfo
+            chassislist = self._do_web_request(chassismembs)
+            chassismembs = chassislist.get('Members', [])
+            if len(chassismembs) == 1:
+                chassisurl = chassismembs[0]['@odata.id']
+                nodeinfo = self._do_web_request(chassisurl)
+        return nodeinfo
+
     def get_inventory_of_component(self, component):
         if component.lower() == 'system':
+            nodeinfo = self._get_node_info()
             sysinfo = {
-                'UUID': self._varsysinfo.get('UUID', ''),
-                'Serial Number': self._varsysinfo.get('SerialNumber', ''),
-                'Manufacturer': self._varsysinfo.get('Manufacturer', ''),
-                'Product name': self._varsysinfo.get('Model', ''),
-                'Model': self._varsysinfo.get(
-                    'SKU', self._varsysinfo.get('PartNumber', '')),
+                'UUID': nodeinfo.get('UUID', ''),
+                'Serial Number': nodeinfo.get('SerialNumber', ''),
+                'Manufacturer': nodeinfo.get('Manufacturer', ''),
+                'Product name': nodeinfo.get('Model', ''),
+                'Model': nodeinfo.get(
+                    'SKU', nodeinfo.get('PartNumber', '')),
             }
             if sysinfo['UUID'] and '-' not in sysinfo['UUID']:
                 sysinfo['UUID'] = '-'.join((
@@ -552,13 +726,14 @@ class OEMHandler(object):
                     return invpair[1]
 
     def get_inventory(self, withids=False):
+        nodeinfo = self._get_node_info()
         sysinfo = {
-            'UUID': self._varsysinfo.get('UUID', ''),
-            'Serial Number': self._varsysinfo.get('SerialNumber', ''),
-            'Manufacturer': self._varsysinfo.get('Manufacturer', ''),
-            'Product name': self._varsysinfo.get('Model', ''),
-            'Model': self._varsysinfo.get(
-                'SKU', self._varsysinfo.get('PartNumber', '')),
+            'UUID': nodeinfo.get('UUID', ''),
+            'Serial Number': nodeinfo.get('SerialNumber', ''),
+            'Manufacturer': nodeinfo.get('Manufacturer', ''),
+            'Product name': nodeinfo.get('Model', ''),
+            'Model': nodeinfo.get(
+                'SKU', nodeinfo.get('PartNumber', '')),
         }
         if sysinfo['UUID'] and '-' not in sysinfo['UUID']:
             sysinfo['UUID'] = '-'.join((
@@ -568,32 +743,14 @@ class OEMHandler(object):
         sysinfo['UUID'] = sysinfo['UUID'].lower()
         yield ('System', sysinfo)
         self._hwnamemap = {}
-        cpumemurls = []
-        memurl = self._varsysinfo.get('Memory', {}).get('@odata.id', None)
-        if memurl:
-            cpumemurls.append(memurl)
-        cpurl = self._varsysinfo.get('Processors', {}).get('@odata.id', None)
-        if cpurl:
-            cpumemurls.append(cpurl)
-        list(self._do_bulk_requests(cpumemurls))
         adpurls = self._get_adp_urls()
-        if cpurl:
-            cpurls = self._get_cpu_urls()
-        else:
-            cpurls = []
-        if memurl:
-            memurls = self._get_mem_urls()
-        else:
-            memurls = []
         diskurls = self._get_disk_urls()
-        allurls = adpurls + cpurls + memurls + diskurls
+        allurls = adpurls + diskurls
         list(self._do_bulk_requests(allurls))
-        if cpurl:
-            for cpu in self._get_cpu_inventory(withids=withids, urls=cpurls):
-                yield cpu
-        if memurl:
-            for mem in self._get_mem_inventory(withids=withids, urls=memurls):
-                yield mem
+        for cpu in self._get_cpu_inventory(withids=withids):
+            yield cpu
+        for mem in self._get_mem_inventory(withids=withids):
+            yield mem
         for adp in self._get_adp_inventory(withids=withids, urls=adpurls):
             yield adp
         for disk in self._get_disk_inventory(withids=withids, urls=diskurls):
@@ -620,13 +777,11 @@ class OEMHandler(object):
         foundmacs = False
         macinfobyadpname = {}
         if 'NetworkInterfaces' in self._varsysinfo:
-            nifurls = self._do_web_request(self._varsysinfo['NetworkInterfaces']['@odata.id'])
-            nifurls = nifurls.get('Members', [])
-            nifurls = [x['@odata.id'] for x in nifurls]
-            for nifurl in nifurls:
-                nifinfo = self._do_web_request(nifurl)
-
-                nadurl = nifinfo.get('Links', {}).get('NetworkAdapter', {}).get("@odata.id")
+            nifdata = self._get_expanded_data(
+                self._varsysinfo['NetworkInterfaces']['@odata.id'])
+            for nifinfo in nifdata.get('Members', []):
+                nadurl = nifinfo.get(
+                    'Links', {}).get('NetworkAdapter', {}).get("@odata.id")
                 if nadurl:
                     nadinfo = self._do_web_request(nadurl)
                     if 'Name' not in nadinfo:
@@ -634,20 +789,31 @@ class OEMHandler(object):
                     nicname = nadinfo['Name']
                     yieldinf = {}
                     macidx = 1
-                    for ctrlr in nadinfo.get('Controllers', []):
-                        porturls = [x['@odata.id'] for x in ctrlr.get(
-                            'Links', {}).get('Ports', [])]
-                        for porturl in porturls:
-                            portinfo = self._do_web_request(porturl)
-                            macs = [x for x in portinfo.get(
-                                'Ethernet', {}).get(
-                                    'AssociatedMACAddresses', [])]
+                    if 'Ports' in nadinfo:
+                        for portinfo in self._get_expanded_data(
+                                nadinfo['Ports']['@odata.id']).get('Members', []):
+                            macs = [x for x in portinfo.get('Ethernet', {}).get('AssociatedMACAddresses', [])]
                             for mac in macs:
                                 label = 'MAC Address {}'.format(macidx)
                                 yieldinf[label] = _normalize_mac(mac)
                                 macidx += 1
                                 foundmacs = True
-                    macinfobyadpname[nicname] = yieldinf
+                            macinfobyadpname[nicname] = yieldinf
+                    else:
+                        for ctrlr in nadinfo.get('Controllers', []):
+                            porturls = [x['@odata.id'] for x in ctrlr.get(
+                                'Links', {}).get('Ports', [])]
+                            for porturl in porturls:
+                                portinfo = self._do_web_request(porturl)
+                                macs = [x for x in portinfo.get(
+                                    'Ethernet', {}).get(
+                                        'AssociatedMACAddresses', [])]
+                                for mac in macs:
+                                    label = 'MAC Address {}'.format(macidx)
+                                    yieldinf[label] = _normalize_mac(mac)
+                                    macidx += 1
+                                    foundmacs = True
+                        macinfobyadpname[nicname] = yieldinf
         if not urls:
             urls = self._get_adp_urls()
         for inf in self._do_bulk_requests(urls):
@@ -698,6 +864,8 @@ class OEMHandler(object):
             if aname in macinfobyadpname:
                 del macinfobyadpname[aname]
             yield aname, yieldinf
+        if onlyname:
+            return
         if macinfobyadpname:
             for adp in macinfobyadpname:
                 yield adp, macinfobyadpname[adp]
@@ -742,12 +910,9 @@ class OEMHandler(object):
         return urls
 
     def _get_cpu_inventory(self, onlynames=False, withids=False, urls=None):
-        if not urls:
-            urls = self._get_cpu_urls()
-        if not urls:
-            return
-        for res in self._do_bulk_requests(urls):
-            currcpuinfo, url = res
+        for currcpuinfo in self._get_cpu_data().get(
+                'Members', []):
+            url = currcpuinfo['@odata.id']
             name = currcpuinfo.get('Name', 'CPU')
             if name in self._hwnamemap:
                 self._hwnamemap[name] = None
@@ -772,21 +937,20 @@ class OEMHandler(object):
         return urls
 
     def _get_cpu_urls(self):
+        md = self._get_cpu_data(False)
+        return [x['@odata.id'] for x in md.get('Members', [])]
+
+    def _get_cpu_data(self, expand='.'):
         cpurl = self._varsysinfo.get('Processors', {}).get('@odata.id', None)
-        if cpurl is None:
-            urls = []
-        else:
-            cpurl = self._do_web_request(cpurl)
-            urls = [x['@odata.id'] for x in cpurl.get('Members', [])]
-        return urls
+        if not cpurl:
+            return {}
+        return self._get_expanded_data(cpurl, expand)
+
 
     def _get_mem_inventory(self, onlyname=False, withids=False, urls=None):
-        if not urls:
-            urls = self._get_mem_urls()
-        if not urls:
-            return
-        for mem in self._do_bulk_requests(urls):
-            currmeminfo, url = mem
+        memdata = self._get_mem_data()
+        for currmeminfo in memdata.get('Members', []): # self._do_bulk_requests(urls):
+            url = currmeminfo['@odata.id']
             name = currmeminfo.get('Name', 'Memory')
             if name in self._hwnamemap:
                 self._hwnamemap[name] = None
@@ -815,13 +979,31 @@ class OEMHandler(object):
             yield (name, meminfo)
 
     def _get_mem_urls(self):
+        md = self._get_mem_data(False)
+        return [x['@odata.id'] for x in md.get('Members', [])]
+
+    def _get_mem_data(self, expand='.'):
         memurl = self._varsysinfo.get('Memory', {}).get('@odata.id', None)
         if not memurl:
-            urls = []
-        else:
-            memurl = self._do_web_request(memurl)
-            urls = [x['@odata.id'] for x in memurl.get('Members', [])]
-        return urls
+            return {}
+        return self._get_expanded_data(memurl, expand)
+
+    def _get_expanded_data(self, url, expand='.'):
+        topdata = []
+        if not url:
+            return topdata
+        if not expand:
+            return self._do_web_request(url)
+        elif self.supports_expand(url):
+            return self._do_web_request(url + '?$expand=' + expand)
+        else:  # emulate expand behavior
+            topdata = self._do_web_request(url)
+            newmembers = []
+            for x in topdata.get('Members', []):
+                newmembers.append(self._do_web_request(x['@odata.id']))
+            topdata['Members'] = newmembers
+            return topdata
+        return topdata
 
     def get_storage_configuration(self):
         raise exc.UnsupportedFunctionality(
@@ -843,8 +1025,9 @@ class OEMHandler(object):
         raise exc.UnsupportedFunctionality(
             'Remote media upload not supported on this platform')
 
-    def update_firmware(self, filename, data=None, progress=None, bank=None):
-        usd = self._do_web_request('/redfish/v1/UpdateService')
+    def update_firmware(self, filename, data=None, progress=None, bank=None, otherfields=()):
+        # disable cache to make sure we trigger the token renewal logic if needed
+        usd = self._do_web_request('/redfish/v1/UpdateService', cache=False)
         upurl = usd.get('MultipartHttpPushUri', None)
         ismultipart = True
         if not upurl:
@@ -863,7 +1046,7 @@ class OEMHandler(object):
         try:
             uploadthread = webclient.FileUploader(
                 self.webclient, upurl, filename, data, formwrap=ismultipart,
-                excepterror=False)
+                excepterror=False, otherfields=otherfields)
             uploadthread.start()
             wc = self.webclient
             while uploadthread.isAlive():
@@ -944,6 +1127,26 @@ class OEMHandler(object):
                                 cache=True):
         return self._do_web_request(url, payload, method, cache), url
 
+    def _get_session_token(self, wc):
+        username = self.username
+        password = self.password
+        if not isinstance(username, str):
+            username = username.decode()
+        if not isinstance(password, str):
+            password = password.decode()
+        # specification actually indicates we can skip straight to this url
+        rsp = wc.grab_rsp('/redfish/v1/SessionService/Sessions',
+                          {'UserName': username, 'Password': password})
+        rsp.read()
+        self.xauthtoken = rsp.getheader('X-Auth-Token')
+        if self.xauthtoken:
+            if 'Authorization' in wc.stdheaders:
+                del wc.stdheaders['Authorization']
+            if 'Authorization' in self.webclient.stdheaders:
+                del self.webclient.stdheaders['Authorization']
+            wc.stdheaders['X-Auth-Token'] = self.xauthtoken
+            self.webclient.stdheaders['X-Auth-Token'] = self.xauthtoken
+
     def _do_web_request(self, url, payload=None, method=None, cache=True):
         res = None
         if cache and payload is None and method is None:
@@ -952,6 +1155,11 @@ class OEMHandler(object):
             return res
         wc = self.webclient.dupe()
         res = wc.grab_json_response_with_status(url, payload, method=method)
+        if res[1] == 401 and 'X-Auth-Token' in self.webclient.stdheaders:
+            wc.set_basic_credentials(self.username, self.password)
+            self._get_session_token(wc)
+            res = wc.grab_json_response_with_status(url, payload,
+                                                    method=method)
         if res[1] < 200 or res[1] >= 300:
             try:
                 info = json.loads(res[0])

pyghmi/redfish/oem/lenovo/main.py

@@ -15,15 +15,28 @@
 import pyghmi.redfish.oem.generic as generic
 from pyghmi.redfish.oem.lenovo import tsma
 from pyghmi.redfish.oem.lenovo import xcc
-
+from pyghmi.redfish.oem.lenovo import xcc3
+from pyghmi.redfish.oem.lenovo import smm3
 
 def get_handler(sysinfo, sysurl, webclient, cache, cmd):
     leninf = sysinfo.get('Oem', {}).get('Lenovo', {})
+    mgrinfo = {}
+    if leninf:
+        mgrinf, status = webclient.grab_json_response_with_status('/redfish/v1/Managers/1')
+        if status != 200:
+            mgrinfo = {}
     if not leninf:
         bmcinfo = cmd.bmcinfo
         if 'Ami' in bmcinfo.get('Oem', {}):
             return tsma.TsmHandler(sysinfo, sysurl, webclient, cache)
-    if 'FrontPanelUSB' in leninf or 'USBManagementPortAssignment' in leninf or sysinfo.get('SKU', '').startswith('7X58'):
+    elif 'xclarity controller' in mgrinf.get('Model', '').lower():
+        if mgrinf['Model'].endswith('3'):
+            return xcc3.OEMHandler(sysinfo, sysurl, webclient, cache,
+                                    gpool=cmd._gpool)
+        else:
+            return xcc.OEMHandler(sysinfo, sysurl, webclient, cache,
+                              gpool=cmd._gpool)
+    elif 'FrontPanelUSB' in leninf or 'USBManagementPortAssignment' in leninf or sysinfo.get('SKU', '').startswith('7X58'):
         return xcc.OEMHandler(sysinfo, sysurl, webclient, cache,
                               gpool=cmd._gpool)
     else:
@@ -32,5 +45,12 @@ def get_handler(sysinfo, sysurl, webclient, cache, cmd):
         if 'hdd' in leninv and 'hostMAC' in leninv and 'backPlane' in leninv:
             return tsma.TsmHandler(sysinfo, sysurl, webclient, cache,
                                    gpool=cmd._gpool)
-        return generic.OEMHandler(sysinfo, sysurl, webclient, cache,
-                                  gpool=cmd._gpool)
+    try:
+        devdesc = webclient.grab_json_response_with_status('/DeviceDescription.json')
+        if devdesc[1] == 200:
+            if devdesc[0]['type'].lower() == 'lenovo-smm3':
+                return smm3.OEMHandler(sysinfo, sysurl, webclient, cache, gpool=cmd._gpool)
+    except Exception:
+        pass
+    return generic.OEMHandler(sysinfo, sysurl, webclient, cache,
+                                gpool=cmd._gpool)