[tempershow]: Read SFP temperature from xcvrd-managed tables

thermalctld no longer publishes per-SFP entries into TEMPERATURE_INFO.
Update tempershow to additionally read SFP temperatures from the
xcvrd-managed TRANSCEIVER_DOM_TEMPERATURE table, with thresholds from
TRANSCEIVER_DOM_THRESHOLD:

  High TH       <- temphighwarning
  Low TH        <- templowwarning
  Crit High TH  <- temphighalarm
  Crit Low TH   <- templowalarm

Existing TEMPERATURE_INFO consumers (chassis/PSU/fan sensors) continue
to be displayed. Missing fields default to N/A instead of raising
KeyError; the table key glob is also tightened to '<table>|*'.

Signed-off-by: Vasundhara Volam <vvolam@microsoft.com>

Author: vvolam

scripts/tempershow

@@ -5,11 +5,23 @@
 """
 import argparse
 import json
+from datetime import datetime
 
 from tabulate import tabulate
 from swsscommon.swsscommon import SonicV2Connector
 from natsort import natsorted
 
+try:
+    from sonic_platform_base.sonic_sfp.sfputilhelper import SfpUtilHelper
+except ImportError:
+    SfpUtilHelper = None
+
+try:
+    from sonic_py_common import device_info, multi_asic
+except ImportError:
+    device_info = None
+    multi_asic = None
+
 
 header = ['Sensor', 'Temperature', 'High TH', 'Low TH', 'Crit High TH', 'Crit Low TH', 'Warning', 'Timestamp']
 
@@ -22,59 +34,186 @@ CRIT_HIGH_THRESH_FIELD_NAME = 'critical_high_threshold'
 CRIT_LOW_THRESH_FIELD_NAME = 'critical_low_threshold'
 WARNING_STATUS_FIELD_NAME = 'warning_status'
 
+# SFP/transceiver temperature is published by xcvrd (not thermalctld) into
+# the dedicated TRANSCEIVER_DOM_TEMPERATURE table; thresholds come from
+# TRANSCEIVER_DOM_THRESHOLD; per-flag warning/alarm state comes from
+# TRANSCEIVER_DOM_FLAG. Field names are defined by xcvrd.
+SFP_TEMPER_TABLE_NAME = 'TRANSCEIVER_DOM_TEMPERATURE'
+SFP_THRESHOLD_TABLE_NAME = 'TRANSCEIVER_DOM_THRESHOLD'
+SFP_FLAG_TABLE_NAME = 'TRANSCEIVER_DOM_FLAG'
+SFP_DISPLAY_TIME_FORMAT = '%Y%m%d %H:%M:%S'
+SFP_TEMPER_FIELD_NAME = 'temperature'
+SFP_TEMP_HIGH_WARN_FIELD = 'temphighwarning'
+SFP_TEMP_LOW_WARN_FIELD = 'templowwarning'
+SFP_TEMP_HIGH_ALARM_FIELD = 'temphighalarm'
+SFP_TEMP_LOW_ALARM_FIELD = 'templowalarm'
+SFP_TEMP_FLAG_FIELDS = (
+    SFP_TEMP_HIGH_WARN_FIELD,
+    SFP_TEMP_LOW_WARN_FIELD,
+    SFP_TEMP_HIGH_ALARM_FIELD,
+    SFP_TEMP_LOW_ALARM_FIELD,
+)
+
+NA = 'N/A'
+
 
 class TemperShow(object):
     def __init__(self):
         self.db = SonicV2Connector(host="127.0.0.1")
         self.db.connect(self.db.STATE_DB)
+        self.sfp_util = self._init_sfp_util_helper()
 
-    def show(self, output_json):
-        keys = self.db.keys(self.db.STATE_DB, TEMPER_TABLE_NAME + '*')
-        if not keys:
-            print('Thermal Not detected\n')
-            return
+    def _init_sfp_util_helper(self):
+        """Initialize SfpUtilHelper for logical-port -> physical-port mapping.
 
-        table = []
-        json_output = []
+        Returns None if the helper or platform info is unavailable; SFP rows
+        will then fall back to displaying the logical port name.
+        """
+        if SfpUtilHelper is None or device_info is None or multi_asic is None:
+            return None
+        try:
+            sfp_util = SfpUtilHelper()
+            if multi_asic.is_multi_asic():
+                _, hwsku_path = device_info.get_paths_to_platform_and_hwsku_dirs()
+                sfp_util.read_all_porttab_mappings(hwsku_path, multi_asic.get_num_asics())
+            else:
+                port_config_file_path = device_info.get_path_to_port_config_file()
+                sfp_util.read_porttab_mappings(port_config_file_path, 0)
+            return sfp_util
+        except Exception:
+            return None
+
+    def _sfp_display_name(self, port_name):
+        """Map a logical port name (e.g. 'Ethernet0') to 'xSFP module <N> Temp'.
+
+        Falls back to the logical port name if the mapping is unavailable.
+        This matches the legacy thermalctld naming convention so existing
+        consumers/operators see the same sensor labels.
+        """
+        if self.sfp_util is None:
+            return port_name
+        try:
+            physical = self.sfp_util.get_logical_to_physical(port_name)
+            if physical and len(physical) > 0 and physical[0] is not None:
+                # physical port index from SfpUtilHelper is already 1-based
+                return 'xSFP module {} Temp'.format(physical[0])
+        except Exception:
+            pass
+        return port_name
+
+    def _collect_platform_sensors(self):
+        """Collect chassis/PSU/fan thermal sensors from TEMPERATURE_INFO."""
+        rows = []
+        keys = self.db.keys(self.db.STATE_DB, TEMPER_TABLE_NAME + '|*')
+        if not keys:
+            return rows
         for key in natsorted(keys):
             key_list = key.split('|')
-            if len(key_list) != 2: # error data in DB, log it and ignore
+            if len(key_list) != 2:
                 print('Warn: Invalid key in table {}: {}'.format(TEMPER_TABLE_NAME, key))
                 continue
-
             name = key_list[1]
-            data_dict = self.db.get_all(self.db.STATE_DB, key)
-            if output_json:
-                json_output.append({
-                    "Sensor": name,
-                    "Temperature": data_dict[TEMPER_FIELD_NAME],
-                    "High_TH": data_dict[HIGH_THRESH_FIELD_NAME],
-                    "Low_TH": data_dict[LOW_THRESH_FIELD_NAME],
-                    "Crit_High_TH": data_dict[CRIT_HIGH_THRESH_FIELD_NAME],
-                    "Crit_Low_TH": data_dict[CRIT_LOW_THRESH_FIELD_NAME],
-                    "Warning": data_dict[WARNING_STATUS_FIELD_NAME],
-                    "Timestamp": data_dict[TIMESTAMP_FIELD_NAME]
-                })
+            data_dict = self.db.get_all(self.db.STATE_DB, key) or {}
+            rows.append({
+                'name': name,
+                'temperature': data_dict.get(TEMPER_FIELD_NAME, NA),
+                'high_th': data_dict.get(HIGH_THRESH_FIELD_NAME, NA),
+                'low_th': data_dict.get(LOW_THRESH_FIELD_NAME, NA),
+                'crit_high_th': data_dict.get(CRIT_HIGH_THRESH_FIELD_NAME, NA),
+                'crit_low_th': data_dict.get(CRIT_LOW_THRESH_FIELD_NAME, NA),
+                'warning': data_dict.get(WARNING_STATUS_FIELD_NAME, NA),
+                'timestamp': data_dict.get(TIMESTAMP_FIELD_NAME, NA),
+            })
+        return rows
+
+    def _collect_sfp_sensors(self):
+        """Collect SFP/transceiver temperatures from xcvrd-managed tables.
+
+        Map xcvrd threshold fields onto tempershow's columns:
+          high_th       <- temphighwarning
+          low_th        <- templowwarning
+          crit_high_th  <- temphighalarm
+          crit_low_th   <- templowalarm
+
+        Warning column is True if any of the temperature high/low
+        warning/alarm flags in TRANSCEIVER_DOM_FLAG are asserted.
+        """
+        rows = []
+        keys = self.db.keys(self.db.STATE_DB, SFP_TEMPER_TABLE_NAME + '|*')
+        if not keys:
+            return rows
+        timestamp = datetime.now().strftime(SFP_DISPLAY_TIME_FORMAT)
+        for key in natsorted(keys):
+            key_list = key.split('|')
+            if len(key_list) != 2:
+                print('Warn: Invalid key in table {}: {}'.format(SFP_TEMPER_TABLE_NAME, key))
+                continue
+            port = key_list[1]
+            temp_dict = self.db.get_all(self.db.STATE_DB, key) or {}
+            thr_dict = self.db.get_all(
+                self.db.STATE_DB,
+                '{}|{}'.format(SFP_THRESHOLD_TABLE_NAME, port)) or {}
+            flag_dict = self.db.get_all(
+                self.db.STATE_DB,
+                '{}|{}'.format(SFP_FLAG_TABLE_NAME, port)) or {}
+            rows.append({
+                'name': self._sfp_display_name(port),
+                'temperature': temp_dict.get(SFP_TEMPER_FIELD_NAME, NA),
+                'high_th': thr_dict.get(SFP_TEMP_HIGH_WARN_FIELD, NA),
+                'low_th': thr_dict.get(SFP_TEMP_LOW_WARN_FIELD, NA),
+                'crit_high_th': thr_dict.get(SFP_TEMP_HIGH_ALARM_FIELD, NA),
+                'crit_low_th': thr_dict.get(SFP_TEMP_LOW_ALARM_FIELD, NA),
+                'warning': self._derive_sfp_warning(flag_dict),
+                'timestamp': timestamp,
+            })
+        return rows
+
+    @staticmethod
+    def _derive_sfp_warning(flag_dict):
+        """Return True/False/N/A based on temp flags in TRANSCEIVER_DOM_FLAG.
+
+        True  - any of temphigh/lowwarning/alarm is asserted
+        False - all four flags are present and de-asserted
+        N/A   - none of the four flags are present
+        """
+        if not flag_dict:
+            return NA
+        seen = False
+        for field in SFP_TEMP_FLAG_FIELDS:
+            value = flag_dict.get(field)
+            if value is None:
+                continue
+            seen = True
+            if str(value).strip().lower() == 'true':
+                return True
+        return False if seen else NA
+
+    def show(self, output_json):
+        rows = self._collect_platform_sensors() + self._collect_sfp_sensors()
+        if not rows:
+            print('Thermal Not detected\n')
+            return
 
-            else:
-                table.append((name, 
-                              data_dict[TEMPER_FIELD_NAME], 
-                              data_dict[HIGH_THRESH_FIELD_NAME],
-                              data_dict[LOW_THRESH_FIELD_NAME],
-                              data_dict[CRIT_HIGH_THRESH_FIELD_NAME],
-                              data_dict[CRIT_LOW_THRESH_FIELD_NAME],
-                              data_dict[WARNING_STATUS_FIELD_NAME],
-                              data_dict[TIMESTAMP_FIELD_NAME]
-                              ))
-        
         if output_json:
+            json_output = [{
+                "Sensor": r['name'],
+                "Temperature": r['temperature'],
+                "High_TH": r['high_th'],
+                "Low_TH": r['low_th'],
+                "Crit_High_TH": r['crit_high_th'],
+                "Crit_Low_TH": r['crit_low_th'],
+                "Warning": r['warning'],
+                "Timestamp": r['timestamp'],
+            } for r in rows]
             print(json.dumps(json_output, indent=2))
-        elif table:
-            print(tabulate(table, header, tablefmt='simple', stralign='right'))
-        else:
-            print('No temperature data available\n')
+            return
+
+        table = [(r['name'], r['temperature'], r['high_th'], r['low_th'],
+                  r['crit_high_th'], r['crit_low_th'], r['warning'],
+                  r['timestamp']) for r in rows]
+        print(tabulate(table, header, tablefmt='simple', stralign='right'))
+
 
-            
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description='Display the temperature Sensor information',
                                      formatter_class=argparse.RawTextHelpFormatter,