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

pyghmi/ipmi/command.py

@@ -551,7 +551,7 @@ class Command(object):
         return {'powerstate': self._get_power_state(
             bridge_request=bridge_request)}
 
-    def set_identify(self, on=True, duration=None):
+    def set_identify(self, on=True, duration=None, blink=False):
         """Request identify light
 
         Request the identify light to turn off, on for a duration,
@@ -563,10 +563,14 @@ class Command(object):
         """
         self.oem_init()
         try:
-            self._oem.set_identify(on, duration)
+            self._oem.set_identify(on, duration, blink)
+            return
+        except exc.BypassGenericBehavior:
             return
         except exc.UnsupportedFunctionality:
             pass
+        if blink:
+            raise exc.IpmiException('Blink not supported with generic IPMI')
         if duration is not None:
             duration = int(duration)
             if duration > 255:

pyghmi/ipmi/oem/generic.py

@@ -104,6 +104,8 @@ class OEMHandler(object):
             if sensor.sensor_type != 'Temperature':
                 continue
             if sensor.entity == 'External environment':
+                if 'exhaust' in sensor.sensor_name.lower():
+                    continue
                 extenv.append(sensor.sensor_name)
             if sensor.entity == 'Air inlet':
                 airinlets.append(sensor.sensor_name)
@@ -377,7 +379,7 @@ class OEMHandler(object):
     def list_media(self):
         raise exc.UnsupportedFunctionality()
 
-    def set_identify(self, on, duration):
+    def set_identify(self, on, duration, blink):
         """Provide an OEM override for set_identify
 
         Some systems may require an override for set identify.

pyghmi/ipmi/oem/lenovo/handler.py

@@ -671,9 +671,11 @@ class OEMHandler(generic.OEMHandler):
                                         led_status_default)
             yield (name, {'status': status})
 
-    def set_identify(self, on, duration):
+    def set_identify(self, on, duration, blink):
         if on and not duration and self.is_sd350:
             self.ipmicmd.xraw_command(netfn=0x3a, command=6, data=(1, 1))
+        elif self.has_xcc:
+            self.immhandler.set_identify(on, duration, blink)
         else:
             raise pygexc.UnsupportedFunctionality()
 

pyghmi/ipmi/oem/lenovo/imm.py

@@ -968,6 +968,15 @@ class XCCClient(IMMClient):
                 fru['manufacturer'] = memi['memory_manufacturer']
                 break
 
+    def set_identify(self, on, duration, blink):
+        if blink:
+            self.grab_redfish_response_with_status(
+                '/redfish/v1/Systems/1',
+                {'IndicatorLED': 'Blinking'},
+                method='PATCH')
+            raise pygexc.BypassGenericBehavior()
+        raise pygexc.UnsupportedFunctionality()
+
     def get_description(self):
         dsc = self.wc.grab_json_response('/DeviceDescription.json')
         dsc = dsc[0]

pyghmi/redfish/command.py

@@ -1,5 +1,5 @@
 # coding: utf8
-# Copyright 2021 Lenovo
+# Copyright 2025 Lenovo
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -81,20 +81,6 @@ def _mask_to_cidr(mask):
     return cidr
 
 
-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 _cidr_to_mask(cidr):
     return socket.inet_ntop(
         socket.AF_INET, struct.pack(
@@ -127,6 +113,7 @@ def natural_sort(iterable):
 class SensorReading(object):
     def __init__(self, healthinfo, sensor=None, value=None, units=None,
                  unavailable=False):
+        self.states = []
         if sensor:
             self.name = sensor['name']
         else:
@@ -136,7 +123,8 @@ class SensorReading(object):
             self.states = [healthinfo.get('Status', {}).get('Health',
                                                             'Unknown')]
             self.health = _healthmap[healthinfo['Status']['Health']]
-            self.states = [healthinfo['Status']['Health']]
+            if healthinfo['Status']['Health'].lower() == 'ok':
+                self.states = []
         self.value = value
         self.state_ids = None
         self.imprecision = None
@@ -175,6 +163,7 @@ class Command(object):
         self._gpool = pool
         self._bmcv4ip = None
         self._bmcv6ip = None
+        self.xauthtoken = None
         for addrinf in socket.getaddrinfo(bmc, 0, 0, socket.SOCK_STREAM):
             if addrinf[0] == socket.AF_INET:
                 self._bmcv4ip = socket.inet_pton(addrinf[0], addrinf[-1][0])
@@ -187,38 +176,76 @@ class Command(object):
         self.wc.set_header('Accept-Encoding', 'gzip')
         self.wc.set_header('OData-Version', '4.0')
         overview = self.wc.grab_json_response('/redfish/v1/')
-        self.wc.set_basic_credentials(userid, password)
         self.username = userid
         self.password = password
+        self.wc.set_basic_credentials(self.username, self.password)
         self.wc.set_header('Content-Type', 'application/json')
-        if 'Systems' not in overview:
+        if 'Systems' not in overview and 'Managers' not in overview:
             raise exc.PyghmiException('Redfish not ready')
-        systems = overview['Systems']['@odata.id']
-        res = self.wc.grab_json_response_with_status(systems)
-        if res[1] == 401:
-            raise exc.PyghmiException('Access Denied')
-        elif res[1] < 200 or res[1] >= 300:
-            raise exc.PyghmiException(repr(res[0]))
-        members = res[0]
+        if 'SessionService' in overview:
+            self._get_session_token(self.wc)
         self._varsensormap = {}
-        systems = members['Members']
-        if sysurl:
-            for system in systems:
-                if system['@odata.id'] == sysurl or system['@odata.id'].split('/')[-1] == sysurl:
-                    self.sysurl = system['@odata.id']
-                    break
+        self.powerurl = None
+        self.sysurl = None
+        if 'Managers' in overview:
+            bmcoll = systems = overview['Managers']['@odata.id']
+            res = self.wc.grab_json_response_with_status(bmcoll)
+            if res[1] == 401:
+                raise exc.PyghmiException('Access Denied')
+            elif res[1] < 200 or res[1] >= 300:
+                raise exc.PyghmiException(repr(res[0]))
+            bmcs = res[0]['Members']
+            if len(bmcs) == 1:
+                self._varbmcurl = bmcs[0]['@odata.id']
+        if 'Systems' in overview:
+            systems = overview['Systems']['@odata.id']
+            res = self.wc.grab_json_response_with_status(systems)
+            if res[1] == 401:
+                raise exc.PyghmiException('Access Denied')
+            elif res[1] < 200 or res[1] >= 300:
+                raise exc.PyghmiException(repr(res[0]))
+            members = res[0]
+            systems = members['Members']
+            if sysurl:
+                for system in systems:
+                    if system['@odata.id'] == sysurl or system['@odata.id'].split('/')[-1] == sysurl:
+                        self.sysurl = system['@odata.id']
+                        break
+                else:
+                    raise exc.PyghmiException(
+                        'Specified sysurl not found: {0}'.format(sysurl))
             else:
-                raise exc.PyghmiException(
-                    'Specified sysurl not found: {0}'.format(sysurl))
-        else:
-            if len(systems) != 1:
-                systems = [x for x in systems if 'DPU' not in x['@odata.id']]
-            if len(systems) != 1:
-                raise exc.PyghmiException(
-                    'Multi system manager, sysurl is required parameter')
-            self.sysurl = systems[0]['@odata.id']
-        self.powerurl = self.sysinfo.get('Actions', {}).get(
-            '#ComputerSystem.Reset', {}).get('target', None)
+                if len(systems) > 1:
+                    systems = [x for x in systems if 'DPU' not in x['@odata.id']]
+                if len(systems) > 1:
+                    raise exc.PyghmiException(
+                        'Multi system manager, sysurl is required parameter')
+                if len(systems):
+                    self.sysurl = systems[0]['@odata.id']
+                else:
+                    self.sysurl = None
+            self.powerurl = self.sysinfo.get('Actions', {}).get(
+                '#ComputerSystem.Reset', {}).get('target', None)
+
+    def _get_session_token(self, wc):
+        # specification actually indicates we can skip straight to this url
+        username = self.username
+        password = self.password
+        if not isinstance(username, str):
+            username = username.decode()
+        if not isinstance(password, str):
+            password = password.decode()
+        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.wc.stdheaders:
+                del self.wc.stdheaders['Authorization']
+            wc.stdheaders['X-Auth-Token'] = self.xauthtoken
+            self.wc.stdheaders['X-Auth-Token'] = self.xauthtoken
 
     @property
     def _accountserviceurl(self):
@@ -445,7 +472,13 @@ class Command(object):
 
     @property
     def sysinfo(self):
-        return self._do_web_request(self.sysurl)
+        if not self.sysurl:
+            return {}
+        try:
+            return self._do_web_request(self.sysurl)
+        except exc.RedfishError:
+            self.sysurl = None
+            return {}
 
     @property
     def bmcinfo(self):
@@ -534,6 +567,17 @@ class Command(object):
         finally:
             if 'If-Match' in wc.stdheaders:
                 del wc.stdheaders['If-Match']
+        if res[1] == 401 and self.xauthtoken:
+            wc.set_basic_credentials(self.username, self.password)
+            self._get_session_token(wc)
+            if etag:
+                wc.stdheaders['If-Match'] = etag
+            try:
+                res = wc.grab_json_response_with_status(url, payload,
+                                                        method=method)
+            finally:
+                if 'If-Match' in wc.stdheaders:
+                    del wc.stdheaders['If-Match']
         if res[1] < 200 or res[1] >= 300:
             try:
                 info = json.loads(res[0])
@@ -547,7 +591,7 @@ class Command(object):
                 msgid = ','.join(msgid)
                 raise exc.RedfishError(errmsg, msgid=msgid)
             except (ValueError, KeyError):
-                raise exc.PyghmiException(str(url) + ":" + res[0])
+                raise exc.PyghmiException(str(url) + ":" + str(res[0]))
         if payload is None and method is None:
             self._urlcache[url] = {'contents': res[0],
                                    'vintage': os.times()[4]}
@@ -633,34 +677,53 @@ class Command(object):
     @property
     def _sensormap(self):
         if not self._varsensormap:
-            for chassis in self.sysinfo.get('Links', {}).get('Chassis', []):
-                self._mapchassissensors(chassis)
+            if self.sysinfo:
+                for chassis in self.sysinfo.get('Links', {}).get('Chassis', []):
+                    self._mapchassissensors(chassis)
+            else:  # no system, but check if this is a singular chassis
+                rootinfo = self._do_web_request('/redfish/v1/')
+                chassiscol = rootinfo.get('Chassis', {}).get('@odata.id', '')
+                if chassiscol:
+                    chassislist = self._do_web_request(chassiscol)
+                    if len(chassislist.get('Members', [])) == 1:
+                        self._mapchassissensors(chassislist['Members'][0])
         return self._varsensormap
 
     def _mapchassissensors(self, chassis):
         chassisurl = chassis['@odata.id']
         chassisinfo = self._do_web_request(chassisurl)
-        powurl = chassisinfo.get('Power', {}).get('@odata.id', '')
-        if powurl:
-            powinf = self._do_web_request(powurl)
-            for voltage in powinf.get('Voltages', []):
-                if 'Name' in voltage:
-                    self._varsensormap[voltage['Name']] = {
-                        'name': voltage['Name'], 'url': powurl,
-                        'type': 'Voltage'}
-        thermurl = chassisinfo.get('Thermal', {}).get('@odata.id', '')
-        if thermurl:
-            therminf = self._do_web_request(thermurl)
-            for fan in therminf.get('Fans', []):
-                if 'Name' in fan:
-                    self._varsensormap[fan['Name']] = {
-                        'name': fan['Name'], 'type': 'Fan',
-                        'url': thermurl}
-            for temp in therminf.get('Temperatures', []):
-                if 'Name' in temp:
-                    self._varsensormap[temp['Name']] = {
-                        'name': temp['Name'], 'type': 'Temperature',
-                        'url': thermurl}
+        sensors = chassisinfo.get('Sensors', {}).get('@odata.id', '')
+        if sensors:
+            sensorinf = self._do_web_request(sensors)
+            for sensor in sensorinf.get('Members', []):
+                sensedata = self._do_web_request(sensor['@odata.id'])
+                if 'Name' in sensedata:
+                    sensetype = sensedata.get('ReadingType', 'Unknown')
+                    self._varsensormap[sensedata['Name']] = {
+                        'name': sensedata['Name'], 'type': sensetype,
+                        'url': sensor['@odata.id'], 'generic': True}
+        else:
+            powurl = chassisinfo.get('Power', {}).get('@odata.id', '')
+            if powurl:
+                powinf = self._do_web_request(powurl)
+                for voltage in powinf.get('Voltages', []):
+                    if 'Name' in voltage:
+                        self._varsensormap[voltage['Name']] = {
+                            'name': voltage['Name'], 'url': powurl,
+                            'type': 'Voltage'}
+            thermurl = chassisinfo.get('Thermal', {}).get('@odata.id', '')
+            if thermurl:
+                therminf = self._do_web_request(thermurl)
+                for fan in therminf.get('Fans', []):
+                    if 'Name' in fan:
+                        self._varsensormap[fan['Name']] = {
+                            'name': fan['Name'], 'type': 'Fan',
+                            'url': thermurl}
+                for temp in therminf.get('Temperatures', []):
+                    if 'Name' in temp:
+                        self._varsensormap[temp['Name']] = {
+                            'name': temp['Name'], 'type': 'Temperature',
+                            'url': thermurl}
         for subchassis in chassisinfo.get('Links', {}).get('Contains', []):
             self._mapchassissensors(subchassis)
 
@@ -771,8 +834,18 @@ class Command(object):
         self._do_web_request(url, {'ResetType': action})
 
     def set_identify(self, on=True, blink=None):
+        targurl = self.sysurl
+        if not targurl:
+            root = self._do_web_request('/redfish/v1')
+            systemsurl = root.get('Systems', {}).get('@odata.id', None)
+            if systemsurl:
+                targurl = self._do_web_request(systemsurl)
+                if len(targurl.get('Members', [])) == 1:
+                    targurl = targurl['Members'][0]['@odata.id']
+        if not targurl:
+            raise Exception("Unable to identify system url")
         self._do_web_request(
-            self.sysurl,
+            targurl,
             {'IndicatorLED': 'Blinking' if blink else 'Lit' if on else 'Off'},
             method='PATCH', etag='*')
 
@@ -819,6 +892,54 @@ class Command(object):
     def set_system_configuration(self, changeset):
         return self.oem.set_system_configuration(changeset, self)
 
+    def get_ntp_enabled(self):
+        bmcinfo = self._do_web_request(self._bmcurl)
+        netprotocols = bmcinfo.get('NetworkProtocol', {}).get('@odata.id', None)
+        if netprotocols:
+            netprotoinfo = self._do_web_request(netprotocols)
+            enabled = netprotoinfo.get('NTP', {}).get('ProtocolEnabled', False)
+            return enabled
+        return False
+
+    def set_ntp_enabled(self, enable):
+        bmcinfo = self._do_web_request(self._bmcurl)
+        netprotocols = bmcinfo.get('NetworkProtocol', {}).get('@odata.id', None)
+        if netprotocols:
+            request = {'NTP':{'ProtocolEnabled': enable}}
+            self._do_web_request(netprotocols, request, method='PATCH')
+            self._do_web_request(netprotocols, cache=0)
+
+    def get_ntp_servers(self):
+        bmcinfo = self._do_web_request(self._bmcurl)
+        netprotocols = bmcinfo.get('NetworkProtocol', {}).get('@odata.id', None)
+        if not netprotocols:
+            return []
+        netprotoinfo = self._do_web_request(netprotocols)
+        return netprotoinfo.get('NTP', {}).get('NTPServers', [])
+
+    def set_ntp_server(self, server, index=None):
+        bmcinfo = self._do_web_request(self._bmcurl)
+        netprotocols = bmcinfo.get('NetworkProtocol', {}).get('@odata.id', None)
+        currntpservers = self.get_ntp_servers()
+        if index is None:
+            if server in currntpservers:
+                return
+            currntpservers = [server] + currntpservers
+        else:
+            if (index + 1) > len(currntpservers):
+                if not server:
+                    return
+                currntpservers.append(server)
+            else:
+                if not server:
+                    del currntpservers[index]
+                else:
+                    currntpservers[index] = server
+        request = {'NTP':{'NTPServers': currntpservers}}
+        self._do_web_request(netprotocols, request, method='PATCH')
+        self._do_web_request(netprotocols, cache=0)
+
+
     def clear_bmc_configuration(self):
         """Reset BMC to factory default
 
@@ -830,7 +951,7 @@ class Command(object):
         rc = bmcinfo.get('Actions', {}).get('#Manager.ResetToDefaults', {})
         actinf = rc.get('ResetType@Redfish.AllowableValues', [])
         if 'ResetAll' in actinf:
-            acturl = actinf.get('target', None)
+            acturl = rc.get('target', None)
             if acturl:
                 self._do_web_request(acturl, {'ResetType': 'ResetAll'})
                 return
@@ -976,14 +1097,14 @@ class Command(object):
                              {'HostName': hostname}, 'PATCH')
 
     def get_firmware(self, components=()):
+        self._fwnamemap = {}
         try:
-            for firminfo in self.oem.get_firmware_inventory(components):
+            for firminfo in self.oem.get_firmware_inventory(components, self):
                 yield firminfo
         except exc.BypassGenericBehavior:
             return
         fwlist = self._do_web_request(self._fwinventory)
         fwurls = [x['@odata.id'] for x in fwlist.get('Members', [])]
-        self._fwnamemap = {}
         for res in self._do_bulk_requests(fwurls):
             res = self._extract_fwinfo(res)
             if res[0] is None:
@@ -1086,79 +1207,20 @@ class Command(object):
     @property
     def oem(self):
         if not self._oem:
+            if self.sysurl:
+                self._do_web_request(self.sysurl, cache=False)  # This is to trigger token validation and renewel
+            elif self._varbmcurl:
+                self._do_web_request(self._varbmcurl, cache=False)  # This is to trigger token validation and renewel
             self._oem = oem.get_oem_handler(
                 self.sysinfo, self.sysurl, self.wc, self._urlcache, self)
             self._oem.set_credentials(self.username, self.password)
         return self._oem
 
     def get_description(self):
-        return self.oem.get_description()
+        return self.oem.get_description(self)
 
     def get_event_log(self, clear=False):
-        bmcinfo = self._do_web_request(self._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', [])
-        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 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
+        return self.oem.get_event_log(clear, self)
 
     def _get_chassis_env(self, chassis):
         chassisurl = chassis['@odata.id']
@@ -1174,35 +1236,11 @@ class Command(object):
         return retval
 
     def get_average_processor_temperature(self):
-        cputemps = []
-        for chassis in self.sysinfo.get('Links', {}).get('Chassis', []):
-            thermals = self._get_thermals(chassis)
-            for temp in thermals:
-                if temp.get('PhysicalContext', '') != 'CPU':
-                    continue
-                if temp.get('ReadingCelsius', None) is None:
-                    continue
-                cputemps.append(temp['ReadingCelsius'])
-        if not cputemps:
-            return  SensorReading(
-            None, {'name': 'Average Processor Temperature'}, value=None, units='°C',
-                   unavailable=True)
-        avgtemp = sum(cputemps) / len(cputemps)
-        return SensorReading(
-            None, {'name': 'Average Processor Temperature'}, value=avgtemp, units='°C')
+        return self.oem.get_average_processor_temperature(self)
+
 
     def get_system_power_watts(self):
-        totalwatts = 0
-        gotpower = False
-        for chassis in self.sysinfo.get('Links', {}).get('Chassis', []):
-            envinfo = self._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
+        return self.oem.get_system_power_watts(self)
 
     def get_inlet_temperature(self):
         inlets = []
@@ -1236,6 +1274,16 @@ class Command(object):
             yield self.get_sensor_reading(sensor)
 
     def _extract_reading(self, sensor, reading):
+        if sensor.get('generic', False):  # generic sensor
+            val = reading.get('Reading', None)
+            unavail = val is None
+            units = reading.get('ReadingUnits', None)
+            if units == 'Cel':
+                units = '°C'
+            if units == 'cft_i/min':
+                units = 'CFM'
+            return SensorReading(reading, None, value=val, units=units,
+                          unavailable=unavail)
         if sensor['type'] == 'Fan':
             for fan in reading['Fans']:
                 if fan['Name'] == sensor['name']:
@@ -1444,3 +1492,4 @@ if __name__ == '__main__':
     print(repr(
         Command(sys.argv[1], os.environ['BMCUSER'], os.environ['BMCPASS'],
                 verifycallback=lambda x: True).get_power()))
+