pyghmi 1.5.72__py3-none-any.whl → 1.5.76__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):
@@ -179,6 +184,7 @@ class AttrDependencyHandler(object):
 
 class OEMHandler(object):
     hostnic = None
+    usegenericsensors = True
 
     def __init__(self, sysinfo, sysurl, webclient, cache, gpool=None):
         self._gpool = gpool
@@ -187,6 +193,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'))
@@ -226,9 +348,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
@@ -520,8 +641,15 @@ class OEMHandler(object):
         return None
 
     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, fishclient):
         return []
 
@@ -561,15 +689,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((
@@ -584,13 +727,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((
@@ -600,32 +744,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):
@@ -652,34 +778,55 @@ 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:
                         continue
                     nicname = nadinfo['Name']
+                    if nicname == 'NetworkAdapter':
+                        nicname = nadinfo.get('Model', nicname)
                     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', [])]
-                            for mac in macs:
-                                label = 'MAC Address {}'.format(macidx)
-                                yieldinf[label] = _normalize_mac(mac)
-                                macidx += 1
-                                foundmacs = True
-                    macinfobyadpname[nicname] = yieldinf
+                    if 'Ports' in nadinfo:
+                        for portinfo in self._get_expanded_data(
+                                nadinfo['Ports']['@odata.id']).get('Members', []):
+                            ethinfo = portinfo.get('Ethernet', {})
+                            if ethinfo:
+                                macs = [x for x in ethinfo.get('AssociatedMACAddresses', [])]
+                                for mac in macs:
+                                    label = 'MAC Address {}'.format(macidx)
+                                    yieldinf[label] = _normalize_mac(mac)
+                                    macidx += 1
+                                    foundmacs = True
+                            ibinfo = portinfo.get('InfiniBand', {})
+                            if ibinfo:
+                                macs = [x for x in ibinfo.get('AssociatedPortGUIDs', [])]
+                                for mac in macs:
+                                    label = 'Port GUID {}'.format(macidx)
+                                    yieldinf[label] = mac
+                                    macidx += 1
+                                    foundmacs = True
+                            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):
@@ -730,6 +877,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]
@@ -774,12 +923,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
@@ -804,21 +950,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
@@ -847,13 +992,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(
@@ -875,8 +1038,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:
@@ -895,7 +1059,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():
@@ -976,6 +1140,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:
@@ -984,6 +1168,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

@@ -16,7 +16,7 @@ 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', {})
@@ -45,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)

pyghmi/redfish/oem/lenovo/smm3.py

@@ -0,0 +1,85 @@
+# Copyright 2025 Lenovo Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pyghmi.redfish.oem.generic as generic
+import pyghmi.constants as pygconst
+
+healthlookup = {
+    'ok': pygconst.Health.Ok,
+    'critical': pygconst.Health.Critical
+}
+
+def _baytonumber(bay):
+    try:
+        return int(bay)
+    except ValueError:
+        if len(bay) == 2:
+            # Treat a hexadecimal system as a leading decimal digit and letter compile
+            # 1a == slot 1, 1b == slot 2, 2a == slot 1, etc..
+            try:
+                tmp = int(bay, 16)
+                return (2 * (tmp >> 4) - 1) + ((tmp & 15) % 10)
+            except ValueError:
+                return None
+    return None
+
+
+def _baytolabel(bay):
+    try:
+        baynum =  int(bay)
+        # need to convert to 1a, 1b, etc...
+        vertidx = ((baynum - 1) // 2 + 1) << 4
+        horizidx = (baynum - 1) % 2 + 10
+        bayid = vertidx | horizidx
+        return '{:02x}'.format(bayid)
+    except ValueError:
+        return bay
+    return None
+
+class OEMHandler(generic.OEMHandler):
+    def get_health(self, fishclient, verbose=True):
+        rsp = self._do_web_request('/redfish/v1/Chassis/chassis1')
+        health = rsp.get('Status', {}).get('Health', 'Unknown').lower()
+        health = healthlookup.get(health, pygconst.Health.Critical)
+        return {'health': health}
+
+    def get_system_configuration(self, hideadvanced=True, fishclient=None):
+        return {}
+
+    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)
+        nodeinfo['SKU'] = nodeinfo['Model']
+        nodeinfo['Model'] = 'N1380 Enclosure'
+        return nodeinfo
+
+    def reseat_bay(self, bay):
+        bayid = _baytolabel(bay)
+        url = '/redfish/v1/Chassis/chassis1/Oem/Lenovo/Nodes/{}/Actions/Node.Reseat'.format(bayid)
+        rsp = self._do_web_request(url, method='POST')
+
+    def get_event_log(self, clear=False, fishclient=None):
+        return super().get_event_log(clear, fishclient, extraurls=[{'@odata.id':'/redfish/v1/Chassis/chassis1/LogServices/EventLog'}])
+
+    def get_description(self, fishclient):
+        return {'height': 13, 'slot': 0, 'slots': [8, 2]}

pyghmi/redfish/oem/lenovo/xcc.py

@@ -119,6 +119,7 @@ def str_to_size(sizestr):
 
 
 class OEMHandler(generic.OEMHandler):
+    usegenericsensors = False
     logouturl = '/api/providers/logout'
     bmcname = 'XCC'
     ADP_URL = '/api/dataset/imm_adapters?params=pci_GetAdapters'