Add JSON dictionary generation to CMake system

Autocoders/Python/src/fprime_ac/utils/version.py

@@ -1,4 +1,5 @@
 """ fprime version handling and reporting """
+
 import os
 import subprocess
 
@@ -54,3 +55,20 @@ def get_project_version(fallback=FALLBACK_VERSION):
     """
     fprime_directory = os.environ.get("FPRIME_PROJECT_ROOT", os.path.dirname(__file__))
     return get_version_str(working_dir=fprime_directory, fallback=fallback)
+
+
+def get_library_versions(fallback=FALLBACK_VERSION) -> dict:
+    """Calculate the versions of each libraries.
+    Return a dictionary with the library name as key and the version as value
+    """
+    fprime_libraries = os.environ.get("FPRIME_LIBRARY_LOCATIONS", "")
+    if fprime_libraries == "":
+        return {}
+
+    lib_versions = {}
+    for library in fprime_libraries.split(":"):
+        library_name = os.path.basename(library)
+        lib_versions[library_name] = get_version_str(
+            working_dir=library, fallback=fallback
+        )
+    return lib_versions

Svc/SystemResources/SystemResources.cpp

@@ -12,7 +12,7 @@
 
 #include <cmath>  //isnan()
 #include <Svc/SystemResources/SystemResources.hpp>
-#include <version.hpp>
+#include <versions/version.hpp>
 #include <FpConfig.hpp>
 
 namespace Svc {
@@ -89,10 +89,10 @@
 }
 
 void SystemResources ::VERSION_cmdHandler(const FwOpcodeType opCode, const U32 cmdSeq) {
-    Fw::LogStringArg version_string(FRAMEWORK_VERSION);
+    Fw::LogStringArg version_string(Project::Version::FRAMEWORK_VERSION);
     this->log_ACTIVITY_LO_FRAMEWORK_VERSION(version_string);
 
-    version_string = PROJECT_VERSION;
+    version_string = Project::Version::PROJECT_VERSION;
     this->log_ACTIVITY_LO_PROJECT_VERSION(version_string);
     this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
 }
@@ -152,10 +152,10 @@
 }
 
 void SystemResources::Version() {
-    Fw::TlmString version_string(FRAMEWORK_VERSION);
+    Fw::TlmString version_string(Project::Version::FRAMEWORK_VERSION);
     this->tlmWrite_FRAMEWORK_VERSION(version_string);
 
-    version_string= PROJECT_VERSION;
+    version_string= Project::Version::PROJECT_VERSION;
     this->tlmWrite_PROJECT_VERSION(version_string);
 }
 }  // end namespace Svc

Svc/SystemResources/test/ut/SystemResourcesTester.cpp

@@ -11,7 +11,7 @@
 // ======================================================================
 
 #include "SystemResourcesTester.hpp"
-#include "version.hpp"
+#include "versions/version.hpp"
 #define INSTANCE 0
 #define MAX_HISTORY_SIZE 100
 
@@ -114,8 +114,8 @@ void SystemResourcesTester ::test_tlm(bool enabled) {
                 ASSERT_TLM_FRAMEWORK_VERSION_SIZE((enabled) ? 1 : 0);
                 ASSERT_TLM_PROJECT_VERSION_SIZE((enabled) ? 1 : 0);
                 if (enabled) {
-                    ASSERT_TLM_FRAMEWORK_VERSION(0, FRAMEWORK_VERSION);
-                    ASSERT_TLM_PROJECT_VERSION(0, PROJECT_VERSION);
+                    ASSERT_TLM_FRAMEWORK_VERSION(0, Project::Version::FRAMEWORK_VERSION);
+                    ASSERT_TLM_PROJECT_VERSION(0, Project::Version::PROJECT_VERSION);
                 }
                 ASSERT_TLM_SIZE((enabled) ? (count + 3) : 0); // CPU count channels + avg + 2 ver
                 break;
@@ -133,9 +133,9 @@ void SystemResourcesTester ::test_disable_enable() {
 void SystemResourcesTester ::test_version_evr() {
     this->sendCmd_VERSION(0, 0);
     ASSERT_EVENTS_FRAMEWORK_VERSION_SIZE(1);
-    ASSERT_EVENTS_FRAMEWORK_VERSION(0, FRAMEWORK_VERSION);
+    ASSERT_EVENTS_FRAMEWORK_VERSION(0, Project::Version::FRAMEWORK_VERSION);
     ASSERT_EVENTS_PROJECT_VERSION_SIZE(1);
-    ASSERT_EVENTS_PROJECT_VERSION(0, FRAMEWORK_VERSION);
+    ASSERT_EVENTS_PROJECT_VERSION(0, Project::Version::FRAMEWORK_VERSION);
 }
 
 // ----------------------------------------------------------------------

cmake/autocoder/fpp.cmake

@@ -7,6 +7,7 @@
 include_guard()
 include(utilities)
 include(autocoder/helpers)
+set(FPRIME_FPP_TO_DICT_WRAPPER "${CMAKE_CURRENT_LIST_DIR}/scripts/fpp_to_dict_wrapper.py")
 
 autocoder_setup_for_multiple_sources()
 ####
@@ -17,7 +18,7 @@ autocoder_setup_for_multiple_sources()
 ####
 function(locate_fpp_tools)
     # Loop through each tool, looking if it was found and check the version
-    foreach(TOOL FPP_DEPEND FPP_TO_XML FPP_TO_CPP FPP_LOCATE_DEFS)
+    foreach(TOOL FPP_DEPEND FPP_TO_XML FPP_TO_CPP FPP_LOCATE_DEFS FPP_TO_DICT)
         # Skipped already defined tools
         if (${TOOL})
             continue()
@@ -207,8 +208,11 @@ function(fpp_setup_autocode AC_INPUT_FILES)
     # Separate the source files into the CPP and XML steps
     set(GENERATED_AI)
     set(GENERATED_CPP)
+    set(GENERATED_DICT)
     foreach(GENERATED IN LISTS GENERATED_FILES)
-        if (GENERATED MATCHES ".*\\.xml")
+        if (GENERATED MATCHES ".*TopologyDictionary\.json")
+            list(APPEND GENERATED_DICT "${GENERATED}")
+        elseif (GENERATED MATCHES ".*\\.xml")
             list(APPEND GENERATED_AI "${GENERATED}")
         else()
             list(APPEND GENERATED_CPP "${GENERATED}")
@@ -234,7 +238,23 @@ function(fpp_setup_autocode AC_INPUT_FILES)
                 DEPENDS ${FILE_DEPENDENCIES} ${MODULE_DEPENDENCIES}
         )
     endif()
-    set(AUTOCODER_GENERATED ${GENERATED_AI} ${GENERATED_CPP})
+    # Add in dictionary generation
+    if (GENERATED_DICT)
+        set(FPRIME_CURRENT_DICTIONARY_FILE_JSON "${GENERATED_DICT}" CACHE INTERNAL "" FORCE)
+        set(FPRIME_JSON_VERSION_FILE "${CMAKE_BINARY_DIR}/versions/version.json")
+        add_custom_command(
+            OUTPUT ${GENERATED_DICT}
+            COMMAND ${FPRIME_FPP_TO_DICT_WRAPPER}
+                "--executable" "${FPP_TO_DICT}"
+                "--cmake-bin-dir" "${CMAKE_CURRENT_BINARY_DIR}" 
+                "--jsonVersionFile" "${FPRIME_JSON_VERSION_FILE}"
+                ${IMPORTS} ${AC_INPUT_FILES}
+            DEPENDS ${FILE_DEPENDENCIES} ${MODULE_DEPENDENCIES} 
+                    ${FPRIME_JSON_VERSION_FILE}
+                    version
+        )
+endif()
+    set(AUTOCODER_GENERATED ${GENERATED_AI} ${GENERATED_CPP} ${GENERATED_DICT})
     set(AUTOCODER_GENERATED "${AUTOCODER_GENERATED}" PARENT_SCOPE)
     set(AUTOCODER_DEPENDENCIES "${MODULE_DEPENDENCIES}" PARENT_SCOPE)
     set(AUTOCODER_INCLUDES "${FILE_DEPENDENCIES}" PARENT_SCOPE)

cmake/autocoder/scripts/fpp_to_dict_wrapper.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""
+fpp_to_dict_wrapper.py:
+
+Wrapper script to run fpp-to-dict within the build process. 
+This is required to be able to read the version files and pass them to the fpp-to-dict executable.
+
+@author thomas-bc
+"""
+
+import subprocess
+import argparse
+import json
+
+
+def main():
+    """
+    Main program entry point
+    """
+    parser = argparse.ArgumentParser(description="Create version header")
+    parser.add_argument(
+        "--executable",
+        required=True,
+        help="Path to the fpp-to-dict executable",
+    )
+    parser.add_argument(
+        "sources",
+        nargs="+",
+        help="Source files",
+    )
+    parser.add_argument(
+        "--jsonVersionFile",
+        default=False,
+        help="Path to file containing versions in JSON format",
+    )
+    parser.add_argument(
+        "--cmake-bin-dir",
+        default=False,
+        help="Library version string",
+    )
+    parser.add_argument(
+        "-i",
+        default=False,
+        help="Imports",
+    )
+    args = parser.parse_args()
+
+    with open(args.jsonVersionFile, "r") as file:
+        versions = json.load(file)
+
+    # Parses library versions into a string to input to fpp-to-dict
+    libs_str = ",".join(
+        f"{lib}@{version}"
+        for lib, version in versions.get("library_versions", {}).items()
+    )
+    framework_version = versions.get("framework_version")
+    project_version = versions.get("project_version")
+    if framework_version is None or project_version is None:
+        raise ValueError(
+            f"{args.jsonVersionFile} is missing 'framework_version' or 'project_version'"
+        )
+
+    cmd_args = [
+        args.executable,
+        "--directory",
+        args.cmake_bin_dir,
+        "--projectVersion",
+        project_version,
+        "--frameworkVersion",
+        framework_version,
+        *(["--libraryVersions", libs_str] if libs_str else []),  # "" unpacks nothing
+        "--imports",
+        args.i,
+        *args.sources,
+    ]
+
+    return subprocess.call(args=cmd_args)
+
+
+if __name__ == "__main__":
+    main()

cmake/required.cmake

@@ -35,4 +35,5 @@ message(STATUS "[python3] python3 found at: ${PYTHON}")
 message(STATUS "[fpp-tools] fpp-depend found at: ${FPP_DEPEND}")
 message(STATUS "[fpp-tools] fpp-to-xml found at: ${FPP_TO_XML}")
 message(STATUS "[fpp-tools] fpp-to-cpp found at: ${FPP_TO_CPP}")
+message(STATUS "[fpp-tools] fpp-to-dict found at: ${FPP_TO_DICT}")
 message(STATUS "[fpp-tools] fpp-locate-defs found at: ${FPP_LOCATE_DEFS}")

cmake/target/install.cmake

@@ -50,7 +50,7 @@ function(install_add_deployment_target MODULE TARGET SOURCES DEPENDENCIES FULL_D
             ARCHIVE DESTINATION ${TOOLCHAIN_NAME}/${MODULE}/lib/static
             COMPONENT ${MODULE}
     )
-    install(FILES ${FPRIME_CURRENT_DICTIONARY_FILE} DESTINATION ${TOOLCHAIN_NAME}/${MODULE}/dict COMPONENT ${MODULE})
+    install(FILES ${FPRIME_CURRENT_DICTIONARY_FILE} ${FPRIME_CURRENT_DICTIONARY_FILE_JSON} DESTINATION ${TOOLCHAIN_NAME}/${MODULE}/dict COMPONENT ${MODULE})
     add_custom_command(TARGET "${MODULE}" POST_BUILD COMMAND "${CMAKE_COMMAND}"
             -DCMAKE_INSTALL_COMPONENT=${MODULE} -P ${CMAKE_BINARY_DIR}/cmake_install.cmake)
 endfunction()

cmake/target/version.cmake

@@ -1,21 +1,30 @@
 ####
 # cmake/target/version.cmake:
 #
-# A basic versioning target which will produce the version.hpp file.
+# A basic versioning target which will produce the version files.
 ####
-set(FPRIME_VERSION_SCRIPT "${CMAKE_CURRENT_LIST_DIR}/version/generate_version_header.py" CACHE PATH "Script used to generate version.hpp")
+set(FPRIME_VERSION_INFO_SCRIPT "${CMAKE_CURRENT_LIST_DIR}/version/generate_version_info.py")
 
 function(version_add_global_target TARGET)
-    set(OUTPUT_FILE "${CMAKE_BINARY_DIR}/version.hpp")
+    set(OUTPUT_DIR "${CMAKE_BINARY_DIR}/versions")
+    set(OUTPUT_HPP "${OUTPUT_DIR}/version.hpp")
+    set(OUTPUT_JSON "${OUTPUT_DIR}/version.json")
+    file(MAKE_DIRECTORY ${OUTPUT_DIR})
     # Add check argument when requested
     set(OPTIONAL_CHECK_ARG)
+    string(REGEX REPLACE ";" ":"  FPRIME_LIBRARY_LOCATIONS_CSV "${FPRIME_LIBRARY_LOCATIONS}")
     if (FPRIME_CHECK_FRAMEWORK_VERSION)
         set(OPTIONAL_CHECK_ARG "--check")
     endif()
-    add_custom_target("${TARGET}" ALL BYPRODUCTS "${OUTPUT_FILE}"
-        COMMAND "${CMAKE_COMMAND}" -E env "PYTHONPATH=${PYTHONPATH}:${FPRIME_FRAMEWORK_PATH}/Autocoders/Python/src"
-            "${FPRIME_VERSION_SCRIPT}" "${OUTPUT_FILE}.tmp" "${OPTIONAL_CHECK_ARG}"
-        COMMAND "${CMAKE_COMMAND}" -E copy_if_different "${OUTPUT_FILE}.tmp" "${OUTPUT_FILE}"
+    add_custom_target("${TARGET}" ALL BYPRODUCTS "${OUTPUT_HPP}" "${OUTPUT_JSON}"
+        COMMAND "${CMAKE_COMMAND}" 
+            -E env "PYTHONPATH=${PYTHONPATH}:${FPRIME_FRAMEWORK_PATH}/Autocoders/Python/src" 
+                    "FPRIME_PROJECT_ROOT=${FPRIME_PROJECT_ROOT}"
+                    "FPRIME_FRAMEWORK_PATH=${FPRIME_FRAMEWORK_PATH}"
+                    "FPRIME_LIBRARY_LOCATIONS=${FPRIME_LIBRARY_LOCATIONS_CSV}"
+            "${FPRIME_VERSION_INFO_SCRIPT}" "${OUTPUT_DIR}" "${OPTIONAL_CHECK_ARG}"
+        COMMAND "${CMAKE_COMMAND}" -E copy_if_different "${OUTPUT_HPP}.tmp" "${OUTPUT_HPP}"
+        COMMAND "${CMAKE_COMMAND}" -E copy_if_different "${OUTPUT_JSON}.tmp" "${OUTPUT_JSON}"
         WORKING_DIRECTORY "${FPRIME_PROJECT_ROOT}"
     )
 endfunction()