Feature #55: Implement the OsApplication parser

README.md

@@ -243,4 +243,8 @@ PrefSystemImporter --base-path c:/EB/ACG-8_8_8_WIN32X86/workspace/simple_demo_rt
 
 **Version 1.2.2**
 
-1. Fix the TARGET of EcucPartitionSoftwareComponentInstanceRef is empty and skipped to added.
+1. Fix the TARGET of EcucPartitionSoftwareComponentInstanceRef is empty and skipped to added.
+
+**Version 1.2.3**
+
+1. Implement the OsApplication parser.

setup.py

@@ -7,7 +7,7 @@
 
 setup(
     name='py_eb_model',
-    version='1.2.2',
+    version='1.2.3',
     license='proprietary',
     description="The parser for EB XDM file",
     long_description=long_description,

src/eb_model/models/os_xdm.py

@@ -234,9 +234,9 @@ def __init__(self, parent, name) -> None:
         self.OsTrustedApplicationWithProtection: bool = False
         self.OsAppAlarmRefs: List[EcucRefType] = []
         self.OsAppCounterRefs: List[EcucRefType] = []
-        self.OsAppEcucPartitionRefs: List[EcucRefType] = []
+        self.OsAppEcucPartitionRef: EcucRefType = None
         self.OsAppIsrRefs: List[EcucRefType] = []
-        self.OsApplicationCoreRefs: List[EcucRefType] = []
+        self.OsApplicationCoreAssignment: int = None
         self.OsAppScheduleTableRefs: List[EcucRefType] = []
         self.OsAppTaskRefs: List[EcucRefType] = []
         self.OsMemoryMappingCodeLocationRef: EcucRefType = None
@@ -282,12 +282,12 @@ def addOsAppCounterRefs(self, value):
         self.OsAppCounterRefs.append(value)
         return self
 
-    def getOsAppEcucPartitionRefs(self):
-        return self.OsAppEcucPartitionRefs
+    def getOsAppEcucPartitionRef(self):
+        return self.OsAppEcucPartitionRef
 
-    def addOsAppEcucPartitionRef(self, value):
+    def setOsAppEcucPartitionRef(self, value):
         if value is not None:
-            self.OsAppEcucPartitionRefs.append(value)
+            self.OsAppEcucPartitionRef = value
         return self
 
     def getOsAppIsrRefs(self):
@@ -298,11 +298,12 @@ def addOsAppIsrRef(self, value):
             self.OsAppIsrRefs.append(value)
         return self
 
-    def getOsApplicationCoreRefs(self):
-        return self.OsApplicationCoreRefs
+    def getOsApplicationCoreAssignment(self) -> int:
+        return self.OsApplicationCoreAssignment
 
-    def addOsApplicationCoreRefs(self, value):
-        self.OsApplicationCoreRefs.append(value)
+    def setOsApplicationCoreAssignment(self, value: int):
+        if value is not None:
+            self.OsApplicationCoreAssignment = value
         return self
 
     def getOsAppScheduleTableRefs(self):
@@ -342,6 +343,15 @@ def addOsAppResourceRef(self, value):
         if value is not None:
             self.OsAppResourceRefs.append(value)
         return self
+
+    def __str__(self):
+        lines = []
+        lines.append("Name: {}".format(self.getName()))
+        lines.append("Trusted: {}".format(self.getOsTrusted()))
+        lines.append("EcucPartition References: {}".format(self.getOsAppEcucPartitionRef().getShortName()))
+        lines.append("Core Assignment: {}".format(self.getOsApplicationCoreAssignment()))
+
+        return "\n".join(lines)
 
 
 class OsDriver(EcucParamConfContainerDef):

src/eb_model/parser/eb_parser.py

@@ -113,6 +113,9 @@ def read_optional_ref_value(self, parent: ET.Element, name: str) -> EcucRefType:
     def read_ref_value_list(self, parent: ET.Element, name: str) -> List[EcucRefType]:
         ref_value_list = []
         for tag in parent.findall(".//d:lst[@name='%s']/d:ref" % name, self.nsmap):
+            if 'value' not in tag.attrib:
+                self.logger.warning("Reference tag <%s> does not have value attribute." % name)
+                continue
             ref_value_list.append(EcucRefType(self.read_ref_raw_value(tag.attrib['value'])))
         return ref_value_list
 

src/eb_model/parser/ecuc_xdm_parser.py

@@ -37,7 +37,7 @@ def read_ecuc_partition_software_component_instances(self, element: ET.Element,
             instance = EcucPartitionSoftwareComponentInstanceRef(ecuc_partition, ctr_tag.attrib['type'])
             instance.setTargetRef(self.read_ref_value(ctr_tag, "TARGET"))
             if instance.getTargetRef() is not None:
-                self.logger.info("Instance: %s" % instance.getTargetRef().getShortName())
+                self.logger.debug("Instance: %s" % instance.getTargetRef().getShortName())
                 ecuc_partition.addEcucPartitionSoftwareComponentInstanceRef(instance)
 
     def read_ecuc_partition(self, element: ET.Element, collection: EcucPartitionCollection):

src/eb_model/parser/os_xdm_parser.py

@@ -183,9 +183,11 @@ def read_os_counters(self, element: ET.Element, os: Os):
 
     def read_os_applications(self, element: ET.Element, os: Os):
         for ctr_tag in self.find_ctr_tag_list(element, "OsApplication"):
-            os_app = OsApplication(os, ctr_tag.attrib["name"]) \
-                .setOsTrusted(self.read_value(ctr_tag, "OsTrusted"))
-
+            os_app = OsApplication(os, ctr_tag.attrib["name"])
+            os_app.setOsTrusted(self.read_value(ctr_tag, "OsTrusted"))
+            os_app.setOsApplicationCoreAssignment(self.read_value(ctr_tag, "OsApplicationCoreAssignment"))
+            os_app.setOsAppEcucPartitionRef(self.read_ref_value(ctr_tag, "OsAppEcucPartitionRef"))
+
             for ref in self.read_ref_value_list(ctr_tag, "OsAppAlarmRef"):
                 os_app.addOsAppAlarmRef(ref)
 

src/eb_model/reporter/excel_reporter/os_xdm.py

@@ -11,9 +11,8 @@ def __init__(self) -> None:
     def write_os_tasks(self, doc: EBModel):
         sheet = self.wb.create_sheet("OsTask", 0)
 
-        title_row = [
-            "Name", "OsApplication", "OsTaskActivation", "OsTaskPriority", "OsTaskAutostart",
-            "OsTaskSchedule", "OsStacksize", "OsTaskType", "OsResourceRef"]
+        title_row = ["Name", "OsApplication", "OsTaskActivation", "OsTaskPriority", "OsTaskAutostart",
+                     "OsTaskSchedule", "OsStacksize", "OsTaskType", "OsResourceRef"]
         self.write_title_row(sheet, title_row)
 
         row = 2
@@ -46,29 +45,42 @@ def write_os_tasks(self, doc: EBModel):
 
         self.auto_width(sheet)
 
+    def write_os_applications(self, doc: EBModel):
+        sheet = self.wb.create_sheet("OsApplications", 0)
+
+        title_row = ["Name", "OsTrusted", "OsApplicationCoreAssignment", "OsAppEcucPartitionRef"]
+        self.write_title_row(sheet, title_row)
+
+        row = 2
+        for os_app in doc.getOs().getOsApplicationList():
+            self.write_cell(sheet, row, 1, os_app.getName())
+            self.write_cell(sheet, row, 2, os_app.getOsTrusted())
+            self.write_cell(sheet, row, 3, os_app.getOsApplicationCoreAssignment())
+            if os_app.getOsAppEcucPartitionRef() is not None:
+                self.write_cell(sheet, row, 4, os_app.getOsAppEcucPartitionRef().getShortName())
+            # self.write_cell(sheet, row, 5, os_app.getOsAppMkPermitShutdownAllCores())
+            # self.write_cell(sheet, row, 6, os_app.getOsAppMkCreateMemoryRegion())
+
+            self.logger.debug("Write OsApplication <%s>" % os_app.getName())
+
+        self.auto_width(sheet)
+
     def write_os_isrs(self, doc: EBModel):
         sheet = self.wb.create_sheet("OsIsr", 1)
 
-        title_row = [
-            "Name", "OsApplication", "OsIsrCategory", "OsStacksize", "OsIsrPriority",
-            "OsIsrVector", "MkMemoryRegion"]
+        title_row = ["Name", "OsApplication", "OsIsrCategory", "OsStacksize", "OsIsrPriority", "OsIsrVector", "MkMemoryRegion"]
         self.write_title_row(sheet, title_row)
 
         row = 2
         for os_isr in doc.getOs().getOsIsrList():
             self.write_cell(sheet, row, 1, os_isr.getName(), {'alignment': Alignment(vertical="top")})
             os_app = doc.getOs().getOsIsrOsApplication(os_isr.getName())
             if os_app is not None:
-                self.write_cell(sheet, row, 2, os_app.getName(),
-                                format={'alignment': Alignment(horizontal="center", vertical="top")})
-            self.write_cell(sheet, row, 3, os_isr.getOsIsrCategory(),
-                            format={'alignment': Alignment(horizontal="center", vertical="top")})
-            self.write_cell(sheet, row, 4, os_isr.getOsStacksize(),
-                            format={'alignment': Alignment(horizontal="center", vertical="top")})
-            self.write_cell(sheet, row, 5, os_isr.getOsIsrPriority(),
-                            format={'alignment': Alignment(horizontal="center", vertical="top")})
-            self.write_cell(sheet, row, 6, os_isr.getOsIsrVector(),
-                            format={'alignment': Alignment(horizontal="center", vertical="top")})
+                self.write_cell(sheet, row, 2, os_app.getName(), format={'alignment': Alignment(horizontal="center", vertical="top")})
+            self.write_cell(sheet, row, 3, os_isr.getOsIsrCategory(), format={'alignment': Alignment(horizontal="center", vertical="top")})
+            self.write_cell(sheet, row, 4, os_isr.getOsStacksize(), format={'alignment': Alignment(horizontal="center", vertical="top")})
+            self.write_cell(sheet, row, 5, os_isr.getOsIsrPriority(), format={'alignment': Alignment(horizontal="center", vertical="top")})
+            self.write_cell(sheet, row, 6, os_isr.getOsIsrVector(), format={'alignment': Alignment(horizontal="center", vertical="top")})
             if len(os_isr.getOsIsrMkMemoryRegionRefs()) > 1:
                 self.write_cell(sheet, row, 7, "\n".join(map(lambda a: a.getShortName(), os_isr.getOsIsrMkMemoryRegionRefs())),
                                 {'alignment': Alignment(wrapText=True, vertical="top")})
@@ -90,12 +102,9 @@ def write_os_schedule_tables(self, doc: EBModel):
         row = 2
         for os_schedule_table in doc.getOs().getOsScheduleTableList():
             self.write_cell(sheet, row, 1, os_schedule_table.getName())
-            self.write_cell(sheet, row, 2, os_schedule_table.getOsScheduleTableDuration(),
-                            format={'alignment': Alignment(horizontal="center")})
-            self.write_cell(sheet, row, 3, os_schedule_table.getOsScheduleTableRepeating(),
-                            format={'alignment': Alignment(horizontal="center")})
-            self.write_cell(sheet, row, 4, os_schedule_table.getOsScheduleTableCounterRef().getShortName(),
-                            format={'alignment': Alignment(horizontal="center")})
+            self.write_cell_center(sheet, row, 2, os_schedule_table.getOsScheduleTableDuration())
+            self.write_cell_center(sheet, row, 3, os_schedule_table.getOsScheduleTableRepeating())
+            self.write_cell_center(sheet, row, 4, os_schedule_table.getOsScheduleTableCounterRef().getShortName())
             row += 1
 
             self.logger.debug("Write OsScheduleTable <%s>" % os_schedule_table.getName())
@@ -111,16 +120,11 @@ def write_os_counters(self, doc: EBModel):
         row = 2
         for os_counter in doc.getOs().getOsCounterList():
             self.write_cell(sheet, row, 1, os_counter.getName())
-            self.write_cell(sheet, row, 2, os_counter.getOsCounterMaxAllowedValue(),
-                            format={'alignment': Alignment(horizontal="center")})
-            self.write_cell(sheet, row, 3, os_counter.getOsCounterMinCycle(),
-                            format={'alignment': Alignment(horizontal="center")})
-            self.write_cell(sheet, row, 4, os_counter.getOsCounterTicksPerBase(),
-                            format={'alignment': Alignment(horizontal="center")})
-            self.write_cell(sheet, row, 5, os_counter.getOsCounterType(),
-                            format={'alignment': Alignment(horizontal="center")})
-            self.write_cell(sheet, row, 6, os_counter.getOsSecondsPerTick(),
-                            format={'alignment': Alignment(horizontal="center")})
+            self.write_cell_center(sheet, row, 2, os_counter.getOsCounterMaxAllowedValue())
+            self.write_cell_center(sheet, row, 3, os_counter.getOsCounterMinCycle())
+            self.write_cell_center(sheet, row, 4, os_counter.getOsCounterTicksPerBase())
+            self.write_cell_center(sheet, row, 5, os_counter.getOsCounterType())
+            self.write_cell_center(sheet, row, 6, os_counter.getOsSecondsPerTick())
             row += 1
 
             self.logger.debug("Write OsScheduleTable <%s>" % os_counter.getName())
@@ -140,12 +144,9 @@ def write_expiry_points(self, doc: EBModel):
             for expiry_point in expiry_point_list:
                 self.write_cell(sheet, row, 1, expiry_point.getName())
                 self.write_cell(sheet, row, 2, table.getName())
-                self.write_cell(sheet, row, 3, table.getOsScheduleTableCounterRef().getShortName(),
-                                format={'alignment': Alignment(horizontal="center")})
-                self.write_cell(sheet, row, 4, expiry_point.getOsScheduleTblExpPointOffset(),
-                                format={'alignment': Alignment(horizontal="center")})
-                self.write_cell(sheet, row, 5, len(expiry_point.getOsScheduleTableTaskActivationList()),
-                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell_center(sheet, row, 3, table.getOsScheduleTableCounterRef().getShortName())
+                self.write_cell_center(sheet, row, 4, expiry_point.getOsScheduleTblExpPointOffset())
+                self.write_cell_center(sheet, row, 5, len(expiry_point.getOsScheduleTableTaskActivationList()))
                 row += 1
 
             self.logger.debug("Write OsScheduleTable <%s>" % table.getName())
@@ -171,39 +172,26 @@ def write_mk_memory_regions(self, doc: EBModel):
             sheet = self.wb.create_sheet("MkMemoryRegion", 5)
 
             title_row = [
-                "Name", "Flags", "Initialize", "Global", "InitThread",
-                "IdleThread", "OsThread", "ErrorHook", "ProtHook", "ShutdownHook",
+                "Name", "Flags", "Initialize", "Global", "InitThread", "IdleThread", "OsThread", "ErrorHook", "ProtHook", "ShutdownHook",
                 "Shutdown", "Kernel", "InitializePerCore"
             ]
             self.write_title_row(sheet, title_row)
 
             row = 2
             for region in doc.getOs().getOsMicrokernel().getMkMemoryProtection().getMkMemoryRegionList():
                 self.write_cell(sheet, row, 1, region.getName())
-                self.write_cell(sheet, row, 2, region.getMkMemoryRegionFlags(),
-                                format={'alignment': Alignment(horizontal="center")})
-                self.write_cell(sheet, row, 3, self.format_boolean(region.getMkMemoryRegionInitialize()),
-                                format={'alignment': Alignment(horizontal="center")})
-                self.write_cell(sheet, row, 4, self.format_boolean(region.getMkMemoryRegionGlobal()),
-                                format={'alignment': Alignment(horizontal="center")})
-                self.write_cell(sheet, row, 5, self.format_boolean(region.getMkMemoryRegionInitThreadAccess()),
-                                format={'alignment': Alignment(horizontal="center")})
-                self.write_cell(sheet, row, 6, self.format_boolean(region.getMkMemoryRegionIdleThreadAccess()),
-                                format={'alignment': Alignment(horizontal="center")})
-                self.write_cell(sheet, row, 7, self.format_boolean(region.getMkMemoryRegionOsThreadAccess()),
-                                format={'alignment': Alignment(horizontal="center")})
-                self.write_cell(sheet, row, 8, self.format_boolean(region.getMkMemoryRegionErrorHookAccess()),
-                                format={'alignment': Alignment(horizontal="center")})
-                self.write_cell(sheet, row, 9, self.format_boolean(region.getMkMemoryRegionProtHookAccess()),
-                                format={'alignment': Alignment(horizontal="center")})
-                self.write_cell(sheet, row, 10, self.format_boolean(region.getMkMemoryRegionShutdownHookAccess()),
-                                format={'alignment': Alignment(horizontal="center")})
-                self.write_cell(sheet, row, 11, self.format_boolean(region.getMkMemoryRegionShutdownAccess()),
-                                format={'alignment': Alignment(horizontal="center")})
-                self.write_cell(sheet, row, 12, self.format_boolean(region.getMkMemoryRegionKernelAccess()),
-                                format={'alignment': Alignment(horizontal="center")})
-                self.write_cell(sheet, row, 13, self.format_boolean(region.getMkMemoryRegionInitializePerCore()),
-                                format={'alignment': Alignment(horizontal="center")})
+                self.write_cell_center(sheet, row, 2, region.getMkMemoryRegionFlags())
+                self.write_cell_center(sheet, row, 3, self.format_boolean(region.getMkMemoryRegionInitialize()))
+                self.write_cell_center(sheet, row, 4, self.format_boolean(region.getMkMemoryRegionGlobal()))
+                self.write_cell_center(sheet, row, 5, self.format_boolean(region.getMkMemoryRegionInitThreadAccess()))
+                self.write_cell_center(sheet, row, 6, self.format_boolean(region.getMkMemoryRegionIdleThreadAccess()))
+                self.write_cell_center(sheet, row, 7, self.format_boolean(region.getMkMemoryRegionOsThreadAccess()))
+                self.write_cell_center(sheet, row, 8, self.format_boolean(region.getMkMemoryRegionErrorHookAccess()))
+                self.write_cell_center(sheet, row, 9, self.format_boolean(region.getMkMemoryRegionProtHookAccess()))
+                self.write_cell_center(sheet, row, 10, self.format_boolean(region.getMkMemoryRegionShutdownHookAccess()))
+                self.write_cell_center(sheet, row, 11, self.format_boolean(region.getMkMemoryRegionShutdownAccess()))
+                self.write_cell_center(sheet, row, 12, self.format_boolean(region.getMkMemoryRegionKernelAccess()))
+                self.write_cell_center(sheet, row, 13, self.format_boolean(region.getMkMemoryRegionInitializePerCore()))
 
                 row += 1
 
@@ -216,6 +204,7 @@ def write(self, filename, doc: EBModel, options={"skip_os_task": False}):
 
         if not options['skip_os_task']:
             self.write_os_tasks(doc)
+        self.write_os_applications(doc)
         self.write_os_isrs(doc)
         self.write_os_schedule_tables(doc)
         self.write_os_counters(doc)