[BFN] Updated syseeprom platform plugin to use onie-eeprom (sonic-net#10556)

* Align system eeprom info with ONIE

* revert linked sonic_platform implementation

* refactor into one class

* refactor after review

Author: dmytroxIntel

platform/barefoot/sonic-platform-modules-bfn-montara/sonic_platform/chassis.py

@@ -13,8 +13,8 @@
     from sonic_platform.psu import psu_list_get
     from sonic_platform.fan_drawer import fan_drawer_list_get
     from sonic_platform.thermal import thermal_list_get
-    from eeprom import Eeprom
-    from platform_utils import file_create
+    from sonic_platform.platform_utils import file_create
+    from sonic_platform.eeprom import Eeprom
 
     from sonic_platform.platform_thrift_client import pltfm_mgr_ready
     from sonic_platform.platform_thrift_client import thrift_try
@@ -40,7 +40,10 @@ class Chassis(ChassisBase):
     def __init__(self):
         ChassisBase.__init__(self)
 
-        self.__eeprom = None
+        self._eeprom = Eeprom()
+        self.__tlv_bin_eeprom = self._eeprom.get_raw_data()
+        self.__tlv_dict_eeprom = self._eeprom.get_data()
+
         self.__fan_drawers = None
         self.__fan_list = None
         self.__thermals = None
@@ -57,16 +60,6 @@ def __init__(self):
             file_create(config_dict['handlers']['file']['filename'], '646')
             logging.config.dictConfig(config_dict)
 
-    @property
-    def _eeprom(self):
-        if self.__eeprom is None:
-            self.__eeprom = Eeprom()
-        return self.__eeprom
-
-    @_eeprom.setter
-    def _eeprom(self, value):
-        pass
-
     @property
     def _fan_drawer_list(self):
         if self.__fan_drawers is None:
@@ -152,7 +145,7 @@ def get_name(self):
         Returns:
             string: The name of the chassis
         """
-        return self._eeprom.modelstr()
+        return self._eeprom.modelstr(self.__tlv_bin_eeprom)
 
     def get_presence(self):
         """
@@ -168,23 +161,24 @@ def get_model(self):
         Returns:
             string: Model/part number of chassis
         """
-        return self._eeprom.part_number_str()
+        return self._eeprom.part_number_str(self.__tlv_bin_eeprom)
 
     def get_serial(self):
         """
         Retrieves the serial number of the chassis (Service tag)
         Returns:
             string: Serial number of chassis
         """
-        return self._eeprom.serial_number_str()
+        return self._eeprom.serial_number_str(self.__tlv_bin_eeprom)
 
     def get_revision(self):
         """
         Retrieves the revision number of the chassis (Service tag)
         Returns:
             string: Revision number of chassis
         """
-        return self._eeprom.revision_str()
+        return self.__tlv_dict_eeprom.get(
+            "0x{:X}".format(Eeprom._TLV_CODE_LABEL_REVISION), 'N/A')
 
     def get_sfp(self, index):
         """
@@ -225,7 +219,7 @@ def get_base_mac(self):
             A string containing the MAC address in the format
             'XX:XX:XX:XX:XX:XX'
         """
-        return self._eeprom.base_mac_addr()
+        return self._eeprom.base_mac_addr(self.__tlv_bin_eeprom)
 
     def get_system_eeprom_info(self):
         """
@@ -236,7 +230,7 @@ def get_system_eeprom_info(self):
             OCP ONIE TlvInfo EEPROM format and values are their corresponding
             values.
         """
-        return self._eeprom.system_eeprom_info()
+        return self.__tlv_dict_eeprom
 
     def __get_transceiver_change_event(self, timeout=0):
         forever = False

platform/barefoot/sonic-platform-modules-bfn-montara/sonic_platform/eeprom.py

@@ -2,7 +2,8 @@
     import os
     import sys
     import datetime
-    import re
+    import logging
+    import logging.config
 
     sys.path.append(os.path.dirname(__file__))
 
@@ -13,13 +14,15 @@
 
     from sonic_platform_base.sonic_eeprom import eeprom_base
     from sonic_platform_base.sonic_eeprom import eeprom_tlvinfo
-    from platform_utils import file_create
 
-    from platform_thrift_client import thrift_try
+    from sonic_py_common import device_info
+
+    from sonic_platform.platform_thrift_client import thrift_try
+    from sonic_platform.platform_utils import file_create
+
 except ImportError as e:
     raise ImportError (str(e) + "- required module not found")
 
-
 _platform_eeprom_map = {
     "prod_name"         : ("Product Name",                "0x21", 12),
     "odm_pcba_part_num" : ("Part Number",                 "0x22", 13),
@@ -44,25 +47,55 @@ class Eeprom(eeprom_tlvinfo.TlvInfoDecoder):
     def __init__(self):
         file_create(_EEPROM_SYMLINK, '646')
         file_create(_EEPROM_STATUS, '646')
-        with open(_EEPROM_STATUS, 'w') as f:
-            f.write("initializing..")
+        super(Eeprom, self).__init__(_EEPROM_SYMLINK, 0, _EEPROM_STATUS, True)
 
-        self.eeprom_path = _EEPROM_SYMLINK
-        super(Eeprom, self).__init__(self.eeprom_path, 0, _EEPROM_STATUS, True)
-
-        def sys_eeprom_get(client):
-            return client.pltfm_mgr.pltfm_mgr_sys_eeprom_get()
+        self._eeprom_bin = bytearray()
+        self.report_status("initializing..")
         try:
-            platform_eeprom = thrift_try(sys_eeprom_get)
-        except Exception:
-            raise RuntimeError("eeprom.py: Initialization failed")
+            try:
+                if device_info.get_platform() in ["x86_64-accton_as9516_32d-r0",
+                                                  "x86_64-accton_as9516bf_32d-r0"]:
+                    def tlv_eeprom_get(client):
+                        return client.pltfm_mgr.pltfm_mgr_tlv_eeprom_get()
+                    try:
+                        self._eeprom_bin = bytearray.fromhex(
+                            thrift_try(tlv_eeprom_get, 1).raw_content_hex)
+                    except TApplicationException as e:
+                        raise RuntimeError("api is not supported")
+                    except Exception as e:
+                        self._eeprom_bin = bytearray.fromhex(
+                            thrift_try(tlv_eeprom_get).raw_content_hex)
+                else:
+                    raise RuntimeError("platform is not supported")
+
+            except RuntimeError as e:
+                logging.warning("Tlv eeprom fetching failed: %s, using OpenBMC" % (str(e)))
+
+                def sys_eeprom_get(client):
+                    return client.pltfm_mgr.pltfm_mgr_sys_eeprom_get()
+
+                eeprom_params = self.platfrom_eeprom_to_params(thrift_try(sys_eeprom_get))
+                stdout_stream = sys.stdout
+                sys.stdout = open(os.devnull, 'w')
+                self._eeprom_bin = self.set_eeprom(self._eeprom_bin, [eeprom_params])
+                sys.stdout.close()
+                sys.stdout = stdout_stream
+            try:
+                self.write_eeprom(self._eeprom_bin)
+                self.report_status("ok")
+            except IOError as e:
+                logging.error("Failed to write eeprom: %s" % (str(e)))
 
-        self.__eeprom_init(platform_eeprom)
+        except Exception as e:
+            logging.error("eeprom.py: Initialization failed: %s" % (str(e)))
+            raise RuntimeError("eeprom.py: Initialization failed: %s" % (str(e)))
 
-    def __eeprom_init(self, platform_eeprom):
-        with open(_EEPROM_STATUS, 'w') as f:
-            f.write("ok")
+        self._system_eeprom_info = dict()
+        visitor = EepromContentVisitor(self._system_eeprom_info)
+        self.visit_eeprom(self._eeprom_bin, visitor)
 
+    @staticmethod
+    def platfrom_eeprom_to_params(platform_eeprom):
         eeprom_params = ""
         for attr, val in platform_eeprom.__dict__.items():
             if val is None:
@@ -86,57 +119,41 @@ def __eeprom_init(self, platform_eeprom):
             if len(eeprom_params) > 0:
                 eeprom_params += ","
             eeprom_params += "{0:s}={1:s}".format(elem[1], value)
+        return eeprom_params
 
-        orig_stdout = sys.stdout
-        sys.stdout = StringIO()
-        try:
-            eeprom_data = eeprom_tlvinfo.TlvInfoDecoder.set_eeprom(self, "", [eeprom_params])
-        finally:
-            decode_output = sys.stdout.getvalue()
-            sys.stdout = orig_stdout
-
-        eeprom_base.EepromDecoder.write_eeprom(self, eeprom_data)
-        self.__eeprom_tlv_dict = self.__parse_output(decode_output)
+    def get_data(self):
+        return self._system_eeprom_info
 
-    def __parse_output(self, decode_output):
-        EEPROM_DECODE_HEADLINES = 6
-        lines = decode_output.replace('\0', '').split('\n')
-        lines = lines[EEPROM_DECODE_HEADLINES:]
-        res = dict()
-
-        for line in lines:
-            try:
-                # match whitespace-separated tag hex, length and value (value is mathced with its whitespaces)
-                match = re.search('(0x[0-9a-fA-F]{2})([\s]+[\S]+[\s]+)([\S]+[\s]*[\S]*)', line)
-                if match is not None:
-                    code = match.group(1)
-                    value = match.group(3).rstrip('\0')
-                    res[code] = value
-            except Exception:
-                pass
-        return res
-
-    def __tlv_get(self, code):
-        return self.__eeprom_tlv_dict.get("0x{:X}".format(code), 'N/A')
-
-    def system_eeprom_info(self):
-        return self.__eeprom_tlv_dict
-
-    def serial_number_str(self):
-        return self.__tlv_get(self._TLV_CODE_SERIAL_NUMBER)
-
-    def serial_str(self):
-        return self.serial_number_str()
-
-    def base_mac_addr(self):
-        return self.__tlv_get(self._TLV_CODE_MAC_BASE)
-
-    def part_number_str(self):
-        return self.__tlv_get(self._TLV_CODE_PART_NUMBER)
-
-    def modelstr(self):
-        return self.__tlv_get(self._TLV_CODE_PRODUCT_NAME)
-
-    def revision_str(self):
-        return self.__tlv_get(self._TLV_CODE_LABEL_REVISION)
+    def get_raw_data(self):
+        return self._eeprom_bin
 
+    def report_status(self, status):
+        status_file = None
+        try:
+            status_file = open(_EEPROM_STATUS, "w")
+            status_file.write(status)
+        except IOError as e:
+            logging.error("Failed to report state: %s" % (str(e)))
+        finally:
+            if status_file is not None:
+                status_file.close()
+
+class EepromContentVisitor(eeprom_tlvinfo.EepromDefaultVisitor):
+    def __init__(self, content_dict):
+        self.content_dict = content_dict
+
+    def visit_tlv(self, name, code, length, value):
+        if code != Eeprom._TLV_CODE_VENDOR_EXT:
+            self.content_dict["0x{:X}".format(code)] = value.rstrip('\0')
+        else:
+            if value:
+                value = value.rstrip('\0')
+                if value:
+                    code = "0x{:X}".format(code)
+                    if code not in self.content_dict:
+                        self.content_dict[code] = [value]
+                    else:
+                        self.content_dict[code].append(value)
+
+    def set_error(self, error):
+        logging.error("EepromContentVisitor error: %s" % (str(error)))