cmake: Use components to install groups

- kamailio-core for anything related to core
- group_name as defined in groups.cmake
- Preferably use K-variants instead of DEFAULT,STANDARD
- Refactor kamctl and dbschema CMakLists for component based installation

cmake/db_files.cmake

@@ -0,0 +1,41 @@
+function(add_db_files group_name file kamctl)
+  # message(WARNING "file name is ${file}")
+  # message(WARNING "group name is ${group_name}")
+  # Process the file with sed and install it
+  add_custom_command(
+    OUTPUT "${CMAKE_BINARY_DIR}/utils/kamctl/${file}"
+    COMMAND sed -e "s#/usr/local/sbin#${BIN_DIR}#g" < ${CMAKE_SOURCE_DIR}/utils/kamctl/${file} >
+            ${CMAKE_BINARY_DIR}/utils/kamctl/${file}
+    COMMENT "Processed ${file} with sed "
+  )
+
+  # Append to the depependencies list for the target kamctl/kamdbctl respectively
+  if(kamctl)
+    add_custom_target(
+      kamctl_${file}
+      DEPENDS ${CMAKE_BINARY_DIR}/utils/kamctl/${file}
+      COMMENT "Generating kamctl_${file}"
+    )
+    set_property(GLOBAL APPEND PROPERTY KAMCTL_DEPENDENCIES "kamctl_${file}")
+  else()
+    add_custom_target(
+      kamdbctl_${file}
+      DEPENDS ${CMAKE_BINARY_DIR}/utils/kamctl/${file}
+      COMMENT "Generating kamctl_${file}"
+    )
+    set_property(GLOBAL APPEND PROPERTY KAMDBCTL_DEPENDENCIES "kamdbctl_${file}")
+  endif()
+  install(
+    PROGRAMS ${CMAKE_BINARY_DIR}/utils/kamctl/${file}
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/${MAIN_NAME}/kamctl
+    COMPONENT ${group_name}
+  )
+endfunction()
+
+function(add_kamctl_db_files group_name file)
+  add_db_files(${group_name} ${file} 1)
+endfunction()
+
+function(add_kamdbctl_db_files group_name file)
+  add_db_files(${group_name} ${file} 0)
+endfunction()

cmake/dbschema.cmake

@@ -0,0 +1,115 @@
+# ----------
+# dbschema target: Old Makefiles: make dbschema declared in src/ Makefile This
+# was using the makefile found in src/lib/srdb1/schema folder.
+#
+# TODO: Revise where we want the target declared. New CMakelists.txt Declare the
+# target in srdb1 CMakeLists.txt file.
+
+find_program(XSLTPROC_EXECUTABLE xsltproc QUIET)
+
+if(NOT XSLTPROC_EXECUTABLE)
+  message(STATUS "xsltproc is not found. Skip dbschema target.")
+else()
+  #  Add targets for each database type
+  if(NOT TARGET dbschema)
+    add_custom_target(dbschema COMMENT "Generating schemas for all dbs...")
+  endif()
+  if(NOT TARGET dbschema_clean)
+    add_custom_target(dbschema_clean COMMENT "Cleaning schemas for all dbs...")
+  endif()
+
+  option(XSLT_VALIDATE, "Enable schema validation during XSL transformations" ON)
+  option(XSLT_VERBOSE, "Enable verbose output for XSL transformations" OFF)
+
+  set(XSLTPROC_FLAGS --xinclude)
+  if(NOT ${XSLT_VALIDATE})
+    set(XSLTPROC_FLAGS ${XSLTPROC_FLAGS} --novalid)
+  endif()
+  if(${XSLT_VERBOSE})
+    set(XSLTPROC_FLAGS ${XSLTPROC_FLAGS} --verbose)
+  endif()
+
+  # Set the root directories
+  set(ROOTDIR ${CMAKE_SOURCE_DIR})
+  set(STYLESHEETS ${ROOTDIR}/doc/stylesheets/dbschema_k/xsl)
+  set(CATALOG ${ROOTDIR}/doc/stylesheets/dbschema_k/catalog.xml)
+
+  # List of XML files
+  file(GLOB TABLES "${CMAKE_SOURCE_DIR}/src/lib/srdb1/schema/kamailio-*.xml")
+  # message(WARNING "TABLES : ${TABLES}")
+  set(EXTRACTED_TABLES "")
+  foreach(table ${TABLES})
+    get_filename_component(TABLE_NAME "${table}" NAME)
+    string(REPLACE "kamailio-" "" TABLE_NAME "${TABLE_NAME}")
+    string(REPLACE ".xml" "" TABLE_NAME "${TABLE_NAME}")
+    list(APPEND EXTRACTED_TABLES "${TABLE_NAME}")
+  endforeach()
+  # Output the extracted table names
+  if(VERBOSE)
+    message(STATUS "Extracted Tables for DB schema generation: ${EXTRACTED_TABLES}")
+  endif()
+
+  # Function to add a target for each database type prefix with dbschema ie
+  # db_name = redis -> target = dbschema_redis
+  function(add_db_target group_name db_name xsl_file)
+    # Change name for the folder
+    if(db_name STREQUAL "pi_framework_table" OR db_name STREQUAL "pi_framework_mod")
+      set(db_name_folder xhttp_pi)
+    else()
+      set(db_name_folder ${db_name})
+    endif()
+
+    add_custom_target(
+      dbschema_${db_name}
+      COMMAND ${CMAKE_COMMAND} -E make_directory "${db_name_folder}"
+      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+      COMMENT "Creating schemas for ${db_name}"
+    )
+
+    # Loop through each table and add a command for xsltproc
+    foreach(table ${EXTRACTED_TABLES})
+      # Determine the prefix based on db_name
+      if(db_name STREQUAL "db_berkeley"
+         OR db_name STREQUAL "db_redis"
+         OR db_name STREQUAL "dbtext"
+         OR db_name STREQUAL "mongodb"
+      )
+        set(prefix '')
+        set(folder_suffix "${MAIN_NAME}")
+      else()
+        set(prefix "${table}-")
+        set(folder_suffix '')
+      endif()
+
+      add_custom_command(
+        TARGET dbschema_${db_name}
+        PRE_BUILD
+        COMMAND
+          XML_CATALOG_FILES=${CATALOG} ${XSLTPROC_EXECUTABLE} ${XSLTPROC_FLAGS} --stringparam dir
+          ${CMAKE_CURRENT_BINARY_DIR}/${db_name_folder}/${folder_suffix} --stringparam prefix
+          ${prefix} --stringparam db ${db_name} ${xsl_file} "kamailio-${table}.xml"
+        WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}/src/lib/srdb1/schema"
+        COMMENT "Processing ${table} for ${db_name}"
+      )
+    endforeach()
+
+    add_custom_target(
+      dbschema_${db_name}_clean
+      COMMAND ${CMAKE_COMMAND} -E remove_directory "${CMAKE_CURRENT_BINARY_DIR}/${db_name_folder}"
+      COMMENT "Cleaning ${db_name} schema files"
+    )
+
+    add_dependencies(dbschema dbschema_${db_name})
+    add_dependencies(dbschema_clean dbschema_${db_name}_clean)
+
+    # message(WARNING "group name is ${group_name}")
+    # Before installing, ensure the target is built `dbschema_${db_name}`
+    install(
+      DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${db_name_folder}
+      DESTINATION ${CMAKE_INSTALL_DATADIR}/${MAIN_NAME}
+      OPTIONAL
+      COMPONENT ${group_name}
+    )
+
+  endfunction()
+endif()

cmake/modules-docs.cmake

@@ -85,7 +85,7 @@ set(DOCS_LYNX_FLAGS
 )
 
 # Function to add a module docs entry
-function(docs_add_module module_name)
+function(docs_add_module group_name module_name)
   # message(STATUS "Adding documentation for module ${MODULE_NAME}")
   set(module_path "${MODULES_DIR}/${module_name}")
   set(module_doc_path "${module_path}/doc")
@@ -178,13 +178,13 @@ function(docs_add_module module_name)
       FILES ${CMAKE_CURRENT_SOURCE_DIR}/${module_name}/README
       RENAME README.${module_name}
       DESTINATION ${CMAKE_INSTALL_DOCDIR}/modules
-      COMPONENT kamailio_docs
+      COMPONENT ${group_name}
     )
 
     install(
       FILES ${CMAKE_CURRENT_SOURCE_DIR}/${module_name}/${module_name}.7
       DESTINATION ${CMAKE_INSTALL_DATADIR}/man/man7
-      COMPONENT kamailio_docs
+      COMPONENT ${group_name}
       OPTIONAL
     )
   endif()

src/CMakeLists.txt

@@ -133,7 +133,7 @@ install(
 install(
   FILES ${CMAKE_SOURCE_DIR}/README ${CMAKE_SOURCE_DIR}/INSTALL
   DESTINATION ${CMAKE_INSTALL_DOCDIR}
-  COMPONENT kamailio-docs
+  COMPONENT kamailio-core
 )
 
 # ----------
@@ -177,16 +177,17 @@ add_dependencies(man kamailio_docs_man)
 install(
   FILES ${CMAKE_CURRENT_BINARY_DIR}/${MAIN_NAME}.8
   DESTINATION ${CMAKE_INSTALL_MANDIR}/man8
-  COMPONENT kamailio_man
+  COMPONENT kamailio-core
   OPTIONAL
 )
 
 install(
   FILES ${CMAKE_CURRENT_BINARY_DIR}/${MAIN_NAME}.cfg.5
   DESTINATION ${CMAKE_INSTALL_MANDIR}/man5
-  COMPONENT kamailio_man
+  COMPONENT kamailio-core
   OPTIONAL
 )
+
 # ----------
 
 # Install the configuration file (kamailio.cfg) ${CFG_NAME} using a CODE block
@@ -213,5 +214,5 @@ install(
     endif()
 
 "
-  COMPONENT kamailio-utils-cfg
+  COMPONENT kamailio-core
 )

src/modules/CMakeLists.txt

@@ -52,7 +52,10 @@ set(EXCLUDE_MODULES
 include(${CMAKE_SOURCE_DIR}/cmake/modules-docs.cmake)
 
 # Function to add modules from a list
-function(add_module_group group_modules)
+function(add_module_group group_name group_modules)
+  # message(STATUS "Adding modules for group: ${group_name}")
+  # message(STATUS "Modules: ${group_modules}")
+
   foreach(module_name IN LISTS group_modules)
     # Check if the module has already been added
     get_property(ALREADY_ADDED GLOBAL PROPERTY ADDED_MODULES_LIST)
@@ -100,11 +103,11 @@ function(add_module_group group_modules)
         install(
           TARGETS ${module_name}
           DESTINATION ${CMAKE_INSTALL_LIBDIR}/${MAIN_NAME}/modules
-          COMPONENT kamailio_modules
+          COMPONENT ${group_name}
         )
         # Add the module to the list of added modules
         set_property(GLOBAL APPEND PROPERTY ADDED_MODULES_LIST ${module_name})
-        docs_add_module(${module_name})
+        docs_add_module(${group_name} ${module_name})
         set_property(GLOBAL APPEND PROPERTY ALL_MODULE_DOC_TARGETS ${module_name}_doc)
       else()
         message(FATAL_ERROR "Module directory ${module_path} does not exist.")
@@ -140,9 +143,14 @@ foreach(group IN LISTS FULL_MODULE_GROUP_NAMES)
   if(VERBOSE)
     message(STATUS "Modules in ${group}: ${MODULES_IN_GROUP}")
   endif()
-  add_module_group("${MODULES_IN_GROUP}")
+  # remove module_group_prefix.
+  # TODO: This feels like a hack since user already provided
+  # the group name. Move the check above in these for maybe?
+  string(REPLACE "MODULE_GROUP_" "" group_name "${group}")
+  # message(WARNING "Adding module group: ${group_name}")
+  add_module_group("${group_name}" "${MODULES_IN_GROUP}")
 endforeach()
-add_module_group("${USER_MODULES_LIST}")
+add_module_group(" " "${USER_MODULES_LIST}")
 
 get_property(ADDED_MODULES_LIST GLOBAL PROPERTY ADDED_MODULES_LIST)
 message(STATUS "Modules to be built: ${ADDED_MODULES_LIST}")
@@ -150,10 +158,7 @@ message(STATUS "Modules to be built: ${ADDED_MODULES_LIST}")
 # https://gitlab.kitware.com/cmake/cmake/-/issues/26571
 add_custom_target(modules COMMENT "Building modules")
 if(NOT ADDED_MODULES_LIST)
-  message(
-    WARNING
-      "No modules to build. Did you forget to add a module group or include module?"
-  )
+  message(WARNING "No modules to build. Did you forget to add a module group or include module?")
 else()
   add_dependencies(modules ${ADDED_MODULES_LIST})
 endif()

src/modules/app_perl/CMakeLists.txt

@@ -115,6 +115,8 @@ add_custom_command(
 add_custom_target(${module_name}_pod.sgml DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/doc/app_perl_pod.sgml)
 
 # Install nessecary files
-install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/lib/perl
-        DESTINATION ${CMAKE_INSTALL_LIBDIR}/${MAIN_NAME}
+install(
+  DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/lib/perl
+  DESTINATION ${CMAKE_INSTALL_LIBDIR}/${MAIN_NAME}
+  COMPONENT ${group_name}
 )

src/modules/auth_radius/CMakeLists.txt

@@ -27,9 +27,10 @@ install(
             PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ)
     endif()
 "
-  COMPONENT ${module_name}-cfg
+  COMPONENT ${group_name}
 )
 
+# Custom target to install only the specific config file
 add_custom_target(
   ${module_name}-install-cfg
   COMMENT "Installing auth_radius dictionary.${CFG_NAME} configuration file"

src/modules/db_berkeley/CMakeLists.txt

@@ -11,3 +11,10 @@ target_link_libraries(${module_name} PRIVATE BerkeleyDB::BerkeleyDB)
 # This is needed to build the kamdb_recover utility
 add_subdirectory(${CMAKE_SOURCE_DIR}/utils/db_berkeley ${CMAKE_BINARY_DIR}/utils/db_berkeley)
 add_dependencies(${module_name} kamdb_recover)
+
+include(${CMAKE_SOURCE_DIR}/cmake/db_files.cmake)
+add_kamctl_db_files(${group_name} kamctl.db_berkeley)
+add_kamdbctl_db_files(${group_name} kamdbctl.db_berkeley)
+
+include(${CMAKE_SOURCE_DIR}/cmake/dbschema.cmake)
+add_db_target("${group_name}" db_berkeley "${STYLESHEETS}/db_berkeley.xsl")

src/modules/db_mongodb/CMakeLists.txt

@@ -9,3 +9,28 @@ pkg_check_modules(mongoc REQUIRED IMPORTED_TARGET libmongoc-1.0>=1.7)
 add_library(mongoc::mongoc ALIAS PkgConfig::mongoc)
 
 target_link_libraries(${module_name} PRIVATE mongoc::mongoc)
+
+include(${CMAKE_SOURCE_DIR}/cmake/dbschema.cmake)
+add_db_target("${group_name}" mongodb "${STYLESHEETS}/mongodb.xsl")
+
+# Create the version-create.mongo script
+# After processing the JSON files, create the version-create.mongo script
+# Usage of generate_version_create_mongo.sh:
+# 1. The first argument is the path to create the version-create.mongo script
+# 2. The second argument is the path to the directory containing the JSON files
+add_custom_command(
+  TARGET dbschema_mongodb
+  POST_BUILD
+  COMMAND
+    bash generate_version_create_mongo.sh
+    "${CMAKE_BINARY_DIR}/utils/kamctl/mongodb/kamailio/version-create.mongo"
+    "${CMAKE_BINARY_DIR}/utils/kamctl/mongodb/kamailio"
+  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/utils/kamctl
+  COMMENT "Creating version-create.mongo from JSON files"
+)
+
+install(
+  FILES ${CMAKE_BINARY_DIR}/utils/kamctl/mongodb/kamailio/version-create.mongo
+  DESTINATION ${CMAKE_INSTALL_DATADIR}/${MAIN_NAME}/mongodb/${MAIN_NAME}
+  COMPONENT ${group_name}
+)

src/modules/db_mysql/CMakeLists.txt

@@ -12,4 +12,9 @@ endif()
 target_include_directories(${module_name} PRIVATE ${MariaDBClient_INCLUDE_DIRS})
 target_link_libraries(${module_name} PRIVATE ${MariaDBClient_LIBRARIES})
 
-# TODO Install script files for kamctl
+include(${CMAKE_SOURCE_DIR}/cmake/db_files.cmake)
+add_kamctl_db_files(${group_name} kamctl.mysql)
+add_kamdbctl_db_files(${group_name} kamdbctl.mysql)
+
+include(${CMAKE_SOURCE_DIR}/cmake/dbschema.cmake)
+add_db_target("${group_name}" mysql "${STYLESHEETS}/mysql.xsl")

src/modules/db_oracle/CMakeLists.txt

@@ -8,3 +8,10 @@ find_package(Oracle REQUIRED)
 # /usr/include/oracle/18.3/client64)
 target_include_directories(${module_name} PRIVATE ${ORACLE_INCLUDE_DIR})
 target_link_libraries(${module_name} PRIVATE ${ORACLE_LIBRARIES})
+
+include(${CMAKE_SOURCE_DIR}/cmake/db_files.cmake)
+add_kamctl_db_files(${group_name} kamctl.oracle)
+add_kamdbctl_db_files(${group_name} kamdbctl.oracle kamdbfunc.oracle)
+
+include(${CMAKE_SOURCE_DIR}/cmake/dbschema.cmake)
+add_db_target("${group_name}" db_oracle "${STYLESHEETS}/oracle.xsl")

src/modules/db_postgres/CMakeLists.txt

@@ -7,3 +7,10 @@ find_package(PostgreSQL REQUIRED)
 target_compile_definitions(${module_name} PRIVATE ${PostgreSQL_DEFINITIONS})
 target_include_directories(${module_name} PRIVATE ${PostgreSQL_INCLUDE_DIRS})
 target_link_libraries(${module_name} PRIVATE ${PostgreSQL_LIBRARIES})
+
+include(${CMAKE_SOURCE_DIR}/cmake/db_files.cmake)
+add_kamctl_db_files(${group_name} kamctl.pgsql)
+add_kamdbctl_db_files(${group_name} kamdbctl.pgsql)
+
+include(${CMAKE_SOURCE_DIR}/cmake/dbschema.cmake)
+add_db_target("${group_name}" postgres "${STYLESHEETS}/postgres.xsl")

src/modules/db_redis/CMakeLists.txt

@@ -9,3 +9,6 @@ add_library(redis::redis ALIAS PkgConfig::redis)
 # TODO: Check with Makefile for cluster stuff
 
 target_link_libraries(${module_name} PRIVATE redis::redis)
+
+include(${CMAKE_SOURCE_DIR}/cmake/dbschema.cmake)
+add_db_target("${group_name}" db_redis "${STYLESHEETS}/db_redis.xsl")

src/modules/db_sqlite/CMakeLists.txt

@@ -5,3 +5,10 @@ add_library(${module_name} SHARED ${MODULE_SOURCES})
 find_package(SQLite3 REQUIRED)
 
 target_link_libraries(${module_name} PRIVATE SQLite::SQLite3)
+
+include(${CMAKE_SOURCE_DIR}/cmake/db_files.cmake)
+add_kamctl_db_files(${group_name} kamctl.sqlite)
+add_kamdbctl_db_files(${group_name} kamdbctl.sqlite)
+
+include(${CMAKE_SOURCE_DIR}/cmake/dbschema.cmake)
+add_db_target("${group_name}" db_sqlite "${STYLESHEETS}/db_sqlite.xsl")

src/modules/db_text/CMakeLists.txt

@@ -2,3 +2,16 @@ file(GLOB MODULE_SOURCES "*.c")
 
 add_library(${module_name} SHARED ${MODULE_SOURCES})
 target_compile_definitions(${module_name} PRIVATE DBT_EXTRA_DEBUG)
+
+include(${CMAKE_SOURCE_DIR}/cmake/db_files.cmake)
+
+add_kamctl_db_files(${group_name} kamctl.dbtext)
+add_kamdbctl_db_files(${group_name} kamdbctl.dbtext)
+install(
+  PROGRAMS ${CMAKE_SOURCE_DIR}/utils/kamctl/dbtextdb/dbtextdb.py
+  DESTINATION ${CMAKE_INSTALL_LIBDIR}/${MAIN_NAME}/kamctl/dbtextdb
+  COMPONENT kamailio-core
+)
+
+include(${CMAKE_SOURCE_DIR}/cmake/dbschema.cmake)
+add_db_target("${group_name}" dbtext "${STYLESHEETS}/dbtext.xsl")

src/modules/snmpstats/CMakeLists.txt

@@ -8,8 +8,10 @@ find_package(NETSNMP REQUIRED)
 # TODO: Compiles fine but need to do some more verifcation
 target_link_libraries(${module_name} PRIVATE NETSNMP::NETSNMP)
 
+message(WARNING "group_name is: ${group_name}")
 install(
   DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/mibs
   DESTINATION ${CMAKE_INSTALL_DATADIR}/snmp
   OPTIONAL
+  COMPONENT ${group_name}
 )

src/modules/tls/CMakeLists.txt

@@ -57,7 +57,7 @@ install(
             PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ)
     endif()
 "
-  COMPONENT tls-cfg
+  COMPONENT ${group_name}
 )
 
 add_custom_command(

src/modules/xhttp_pi/CMakeLists.txt

@@ -26,7 +26,7 @@ install(
             PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ)
     endif()
 "
-  COMPONENT xhttp_pi-cfg
+  COMPONENT ${group_name}
 )
 
 add_custom_target(
@@ -34,3 +34,19 @@ add_custom_target(
   COMMENT "Installing pi_framework.xml"
   COMMAND ${CMAKE_COMMAND} --install ${CMAKE_BINARY_DIR} --component xhttp_pi-cfg
 )
+
+include(${CMAKE_SOURCE_DIR}/cmake/dbschema.cmake)
+add_db_target("${group_name}" pi_framework_table "${STYLESHEETS}/pi_framework_table.xsl")
+add_db_target("${group_name}" pi_framework_mod "${STYLESHEETS}/pi_framework_mod.xsl")
+
+# Add targets that match the dbschema
+add_custom_target(dbschema_xhttp_pi)
+add_dependencies(dbschema_xhttp_pi dbschema_pi_framework_table dbschema_pi_framework_mod)
+
+add_custom_target(dbschema_xhttp_pi_clean)
+add_dependencies(
+  dbschema_xhttp_pi dbschema_pi_framework_table_clean dbschema_pi_framework_mod_clean
+)
+
+add_dependencies(dbschema dbschema_pi_framework_table dbschema_pi_framework_mod)
+add_dependencies(dbschema_clean dbschema_pi_framework_table_clean dbschema_pi_framework_mod_clean)

utils/db_berkeley/CMakeLists.txt

@@ -10,4 +10,5 @@ install(
   TARGETS kamdb_recover
   DESTINATION ${CMAKE_INSTALL_SBINDIR}
   OPTIONAL
+  COMPONENT ${group_name}
 )

utils/kamcmd/CMakeLists.txt

@@ -37,7 +37,11 @@ target_compile_definitions(
                   RUN_DIR="/${CMAKE_INSTALL_LOCALSTATEDIR}/run/${MAIN_NAME}" __OS_${OS_LOWER}
 )
 
-install(TARGETS ${NAME} DESTINATION ${CMAKE_INSTALL_SBINDIR})
+install(
+  TARGETS ${NAME}
+  DESTINATION ${CMAKE_INSTALL_SBINDIR}
+  COMPONENT kamailio-core
+)
 
 # Man page generation
 add_custom_command(
@@ -58,6 +62,6 @@ add_custom_target(kamcmd_man DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/kamcmd.8)
 install(
   FILES ${CMAKE_CURRENT_BINARY_DIR}/kamcmd.8
   DESTINATION ${CMAKE_INSTALL_MANDIR}/man8
-  COMPONENT kamailio_man
+  COMPONENT kamailio-core
   OPTIONAL
 )

utils/kamctl/CMakeLists.txt

@@ -7,126 +7,58 @@ set(LIB_DIR "${CMAKE_INSTALL_FULL_LIBDIR}/${MAIN_NAME}")
 set(CFG_DIR "${CMAKE_INSTALL_FULL_SYSCONFDIR}/${MAIN_NAME}")
 set(SHARE_DIR "${CMAKE_INSTALL_FULL_DATADIR}/${MAIN_NAME}")
 
-set(KAMCTL_BASE_FILES kamctl.base kamctl.ctlbase kamctl.rpcfifo kamctl.ser kamctl.sqlbase)
-
-if("db_berkeley" IN_LIST FINAL_MODULES_LIST)
-  set(KAMCTL_DB_FILES ${KAMCTL_DB_FILES} kamctl.db_berkeley)
-endif()
-if("db_text" IN_LIST FINAL_MODULES_LIST)
-  set(KAMCTL_DB_FILES ${KAMCTL_DB_FILES} kamctl.dbtext)
-endif()
-if("db_mysql" IN_LIST FINAL_MODULES_LIST)
-  set(KAMCTL_DB_FILES ${KAMCTL_DB_FILES} kamctl.mysql)
-endif()
-if("db_oracle" IN_LIST FINAL_MODULES_LIST)
-  set(KAMCTL_DB_FILES ${KAMCTL_DB_FILES} kamctl.oracle)
-endif()
-if("db_postgres" IN_LIST FINAL_MODULES_LIST)
-  set(KAMCTL_DB_FILES ${KAMCTL_DB_FILES} kamctl.pgsql)
-endif()
-if("db_sqlite" IN_LIST FINAL_MODULES_LIST)
-  set(KAMCTL_DB_FILES ${KAMCTL_DB_FILES} kamctl.sqlite)
-endif()
+include(${CMAKE_SOURCE_DIR}/cmake/db_files.cmake)
 
-# Create the depependencies list for the target kamctl
-set(KAMCTL_DEPENDENCIES "")
+set(KAMCTL_BASE_FILES kamctl.base kamctl.ctlbase kamctl.rpcfifo kamctl.ser kamctl.sqlbase)
 
 # Install kamctl.base and the rest
-foreach(file IN LISTS KAMCTL_BASE_FILES KAMCTL_DB_FILES)
-  # Append to the depependencies list for the target kamctl
-  list(APPEND KAMCTL_DEPENDENCIES "${CMAKE_CURRENT_BINARY_DIR}/${file}")
-  # Process the file with sed and install it
-  add_custom_command(
-    OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${file}"
-    COMMAND sed -e "s#/usr/local/sbin#${BIN_DIR}#g" < ${CMAKE_CURRENT_SOURCE_DIR}/${file} >
-            ${CMAKE_CURRENT_BINARY_DIR}/${file}
-    COMMENT "Processed ${file} with sed"
-  )
-  install(
-    PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${file}
-    DESTINATION ${CMAKE_INSTALL_LIBDIR}/${MAIN_NAME}/kamctl
-    COMPONENT kamailio-utils-bin
-  )
+foreach(file IN LISTS KAMCTL_BASE_FILES)
+  add_kamctl_db_files("kamailio-core" ${file})
 endforeach()
 
 # Kamctl target to depend on all kamctl files
 # Install kamctl and it's database files
+get_property(KAMCTL_DEPENDENCIES GLOBAL PROPERTY KAMCTL_DEPENDENCIES)
 add_custom_target(
   kamctl ALL
   COMMAND
     sed -e "s#/usr/local/sbin#${BIN_DIR}#g" -e "s#/usr/local/lib/kamailio#${LIB_DIR}#g" -e
     "s#/usr/local/etc/kamailio#${CFG_DIR}#g" < ${CMAKE_CURRENT_SOURCE_DIR}/kamctl >
     ${CMAKE_CURRENT_BINARY_DIR}/kamctl
-  DEPENDS ${KAMCTL_DEPENDENCIES}
   COMMENT "Build kamctl and its dependencies"
 )
+add_dependencies(kamctl ${KAMCTL_DEPENDENCIES})
 
 install(
   PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/kamctl
   DESTINATION ${CMAKE_INSTALL_SBINDIR}
-  COMPONENT kamailio-utils-bin
+  COMPONENT kamailio-core
 )
 
 # Set up and install kamdbctl stuff
 set(KAMDBCTL_BASE_FILES kamdbctl.base)
 
-if("db_berkeley" IN_LIST FINAL_MODULES_LIST)
-  set(KAMDBCTL_DB_FILES ${KAMDBCTL_DB_FILES} kamdbctl.db_berkeley)
-endif()
-if("db_text" IN_LIST FINAL_MODULES_LIST)
-  set(KAMDBCTL_DB_FILES ${KAMDBCTL_DB_FILES} kamdbctl.dbtext)
-  install(PROGRAMS dbtextdb/dbtextdb.py
-          DESTINATION ${CMAKE_INSTALL_LIBDIR}/${MAIN_NAME}/kamctl/dbtextdb
-  )
-endif()
-if("db_mysql" IN_LIST FINAL_MODULES_LIST)
-  set(KAMDBCTL_DB_FILES ${KAMDBCTL_DB_FILES} kamdbctl.mysql)
-endif()
-if("db_oracle" IN_LIST FINAL_MODULES_LIST)
-  set(KAMDBCTL_DB_FILES ${KAMDBCTL_DB_FILES} kamdbctl.oracle kamdbfunc.oracle)
-endif()
-if("db_postgres" IN_LIST FINAL_MODULES_LIST)
-  set(KAMDBCTL_DB_FILES ${KAMDBCTL_DB_FILES} kamdbctl.pgsql)
-endif()
-if("db_sqlite" IN_LIST FINAL_MODULES_LIST)
-  set(KAMDBCTL_DB_FILES ${KAMDBCTL_DB_FILES} kamdbctl.sqlite)
-endif()
-
 # Install kamdbctl
-set(KAMDB_DEPENDENCIES "")
 
-foreach(file IN LISTS KAMDBCTL_BASE_FILES KAMDBCTL_DB_FILES)
-  list(APPEND KAMDB_DEPENDENCIES "${CMAKE_CURRENT_BINARY_DIR}/${file}")
-  # Install db setup base script
-  add_custom_command(
-    OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${file}"
-    COMMAND
-      sed -e "s#/usr/local/sbin#${BIN_DIR}#g" -e "s#/usr/local/etc/kamailio#${CFG_DIR}#g" -e
-      "s#/usr/local/share/kamailio#${SHARE_DIR}#g" < ${CMAKE_CURRENT_SOURCE_DIR}/${file} >
-      ${CMAKE_CURRENT_BINARY_DIR}/${file}
-    COMMENT "Processed ${file}"
-  )
-  install(
-    PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/${file}
-    DESTINATION ${CMAKE_INSTALL_LIBDIR}/${MAIN_NAME}/kamctl
-    COMPONENT kamailio-utils-bin
-  )
+foreach(file IN LISTS KAMDBCTL_BASE_FILES)
+  add_kamdbctl_db_files("kamailio-core" ${file})
 endforeach()
 
+get_property(KAMDBCTL_DEPENDENCIES GLOBAL PROPERTY KAMDBCTL_DEPENDENCIES)
 add_custom_target(
   kamdbctl ALL
   COMMAND
     sed -e "s#/usr/local/sbin#${BIN_DIR}#g" -e "s#/usr/local/lib/kamailio#${LIB_DIR}#g" -e
     "s#/usr/local/etc/kamailio#${CFG_DIR}#g" < ${CMAKE_CURRENT_SOURCE_DIR}/kamdbctl >
     ${CMAKE_CURRENT_BINARY_DIR}/kamdbctl
-  DEPENDS ${KAMDB_DEPENDENCIES}
   COMMENT "Build kamdbctl and its dependencies"
 )
+add_dependencies(kamdbctl ${KAMDBCTL_DEPENDENCIES})
 
 install(
   PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/kamdbctl
   DESTINATION ${CMAKE_INSTALL_SBINDIR}
-  COMPONENT kamailio-utils-bin
+  COMPONENT kamailio-core
 )
 
 # Install the configuration file (kamctlrc) using a CODE block to check
@@ -149,7 +81,7 @@ install(
             PERMISSIONS OWNER_READ OWNER_WRITE GROUP_READ WORLD_READ)
     endif()
 "
-  COMPONENT kamailio-utils-cfg
+  COMPONENT kamailio-core
 )
 
 # Man pages generation and installation
@@ -184,7 +116,7 @@ add_custom_target(
 install(
   FILES ${CMAKE_CURRENT_BINARY_DIR}/kamctl.8 ${CMAKE_CURRENT_BINARY_DIR}/kamdbctl.8
   DESTINATION ${CMAKE_INSTALL_MANDIR}/man8
-  COMPONENT kamailio_man
+  COMPONENT kamailio-core
   OPTIONAL
 )
 
@@ -207,189 +139,3 @@ add_custom_target(
 # Custom target for installing the kamailio-utils component
 add_custom_target(install-kamailio-utils COMMENT "Installing utils components")
 add_dependencies(install-kamailio-utils install-kamailio-utils-cfg install-kamailio-utils-bin)
-
-# ----------
-
-# ----------
-# dbschema target: Old Makefiles: make dbschema declared in src/ Makefile This
-# was using the makefile found in src/lib/srdb1/schema folder.
-#
-# TODO: Revise where we want the target declared. New CMakelists.txt Declare the
-# target in srdb1 CMakeLists.txt file.
-
-find_program(XSLTPROC_EXECUTABLE xsltproc QUIET)
-
-if(NOT XSLTPROC_EXECUTABLE)
-  message(STATUS "xsltproc is not found. Skip dbschema target.")
-else()
-  option(XSLT_VALIDATE, "Enable schema validation during XSL transformations" ON)
-  option(XSLT_VERBOSE, "Enable verbose output for XSL transformations" OFF)
-
-  set(XSLTPROC_FLAGS --xinclude)
-  if(NOT ${XSLT_VALIDATE})
-    set(XSLTPROC_FLAGS ${XSLTPROC_FLAGS} --novalid)
-  endif()
-  if(${XSLT_VERBOSE})
-    set(XSLTPROC_FLAGS ${XSLTPROC_FLAGS} --verbose)
-  endif()
-
-  # Set the root directories
-  set(ROOTDIR ${CMAKE_SOURCE_DIR})
-  set(STYLESHEETS ${ROOTDIR}/doc/stylesheets/dbschema_k/xsl)
-  set(CATALOG ${ROOTDIR}/doc/stylesheets/dbschema_k/catalog.xml)
-
-  # List of XML files
-  file(GLOB TABLES "${CMAKE_SOURCE_DIR}/src/lib/srdb1/schema/kamailio-*.xml")
-  # message(WARNING "TABLES : ${TABLES}")
-  set(EXTRACTED_TABLES "")
-  foreach(table ${TABLES})
-    get_filename_component(TABLE_NAME "${table}" NAME)
-    string(REPLACE "kamailio-" "" TABLE_NAME "${TABLE_NAME}")
-    string(REPLACE ".xml" "" TABLE_NAME "${TABLE_NAME}")
-    list(APPEND EXTRACTED_TABLES "${TABLE_NAME}")
-  endforeach()
-  # Output the extracted table names
-  if(VERBOSE)
-    message(STATUS "Extracted Tables for DB schema generation: ${EXTRACTED_TABLES}")
-  endif()
-
-  # Function to add a target for each database type prefix with dbschema ie
-  # db_name = redis -> target = dbschema_redis
-  function(add_db_target db_name xsl_file)
-    # Change name for the folder
-    if(db_name STREQUAL "pi_framework_table" OR db_name STREQUAL "pi_framework_mod")
-      set(db_name_folder xhttp_pi)
-    else()
-      set(db_name_folder ${db_name})
-    endif()
-
-    add_custom_target(
-      dbschema_${db_name}
-      COMMAND ${CMAKE_COMMAND} -E make_directory "${db_name_folder}"
-      WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-      COMMENT "Creating schemas for ${db_name}"
-    )
-
-    # Loop through each table and add a command for xsltproc
-    foreach(table ${EXTRACTED_TABLES})
-      # Determine the prefix based on db_name
-      if(db_name STREQUAL "db_berkeley"
-         OR db_name STREQUAL "db_redis"
-         OR db_name STREQUAL "dbtext"
-         OR db_name STREQUAL "mongodb"
-      )
-        set(prefix '')
-        set(folder_suffix "${MAIN_NAME}")
-      else()
-        set(prefix "${table}-")
-        set(folder_suffix '')
-      endif()
-
-      add_custom_command(
-        TARGET dbschema_${db_name}
-        PRE_BUILD
-        COMMAND
-          XML_CATALOG_FILES=${CATALOG} ${XSLTPROC_EXECUTABLE} ${XSLTPROC_FLAGS} --stringparam dir
-          ${CMAKE_CURRENT_BINARY_DIR}/${db_name_folder}/${folder_suffix} --stringparam prefix
-          ${prefix} --stringparam db ${db_name} ${xsl_file} "kamailio-${table}.xml"
-        WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}/src/lib/srdb1/schema"
-        COMMENT "Processing ${table} for ${db_name}"
-      )
-    endforeach()
-
-    # Before installing, ensure the target is built `dbschema_${db_name}`
-    install(
-      DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${db_name_folder}
-      DESTINATION ${CMAKE_INSTALL_DATADIR}/${MAIN_NAME}
-      OPTIONAL
-    )
-
-    add_custom_target(
-      dbschema_${db_name}_clean
-      COMMAND ${CMAKE_COMMAND} -E remove_directory "${CMAKE_CURRENT_BINARY_DIR}/${db_name_folder}"
-      COMMENT "Cleaning ${db_name} schema files"
-    )
-  endfunction()
-
-  # Add targets for each database type
-  add_custom_target(dbschema COMMENT "Generating schemas for all dbs...")
-  add_custom_target(dbschema_clean COMMENT "Cleaning schemas for all dbs...")
-
-  # Pi framework targets should combined into one
-  if("xhttp_pi" IN_LIST FINAL_MODULES_LIST)
-    add_db_target(pi_framework_table "${STYLESHEETS}/pi_framework_table.xsl")
-    add_db_target(pi_framework_mod "${STYLESHEETS}/pi_framework_mod.xsl")
-    add_custom_target(dbschema_xhttp_pi)
-    add_dependencies(dbschema_xhttp_pi dbschema_pi_framework_table dbschema_pi_framework_mod)
-
-    add_custom_target(dbschema_xhttp_pi_clean)
-    add_dependencies(
-      dbschema_xhttp_pi dbschema_pi_framework_table_clean dbschema_pi_framework_mod_clean
-    )
-
-    add_dependencies(dbschema dbschema_pi_framework_table dbschema_pi_framework_mod)
-    add_dependencies(
-      dbschema_clean dbschema_pi_framework_table_clean dbschema_pi_framework_mod_clean
-    )
-  endif()
-  if("db_mysql" IN_LIST FINAL_MODULES_LIST)
-    add_db_target(mysql "${STYLESHEETS}/mysql.xsl")
-    add_dependencies(dbschema dbschema_mysql)
-    add_dependencies(dbschema_clean dbschema_mysql_clean)
-  endif()
-  if("db_postgres" IN_LIST FINAL_MODULES_LIST)
-    add_db_target(postgres "${STYLESHEETS}/postgres.xsl")
-    add_dependencies(dbschema dbschema_postgres)
-    add_dependencies(dbschema_clean dbschema_postgres_clean)
-  endif()
-  if("db_oracle" IN_LIST FINAL_MODULES_LIST)
-    add_db_target(oracle "${STYLESHEETS}/oracle.xsl")
-    add_dependencies(dbschema dbschema_oracle)
-    add_dependencies(dbschema_clean dbschema_oracle_clean)
-  endif()
-  if("db_text" IN_LIST FINAL_MODULES_LIST)
-    add_db_target(dbtext "${STYLESHEETS}/dbtext.xsl")
-    add_dependencies(dbschema dbschema_dbtext)
-    add_dependencies(dbschema_clean dbschema_dbtext_clean)
-  endif()
-  if("db_berkeley" IN_LIST FINAL_MODULES_LIST)
-    add_db_target(db_berkeley "${STYLESHEETS}/db_berkeley.xsl")
-    add_dependencies(dbschema dbschema_db_berkeley)
-    add_dependencies(dbschema_clean dbschema_db_berkeley_clean)
-  endif()
-  if("db_sqlite" IN_LIST FINAL_MODULES_LIST)
-    add_db_target(db_sqlite "${STYLESHEETS}/db_sqlite.xsl")
-    add_dependencies(dbschema dbschema_db_sqlite)
-    add_dependencies(dbschema_clean dbschema_db_sqlite_clean)
-  endif()
-  if("db_mongodb" IN_LIST FINAL_MODULES_LIST)
-    add_db_target(mongodb "${STYLESHEETS}/mongodb.xsl")
-    add_dependencies(dbschema dbschema_mongodb)
-    add_dependencies(dbschema_clean dbschema_mongodb_clean)
-    # Create the version-create.mongo script
-    # After processing the JSON files, create the version-create.mongo script
-    # Usage of generate_version_create_mongo.sh:
-    # 1. The first argument is the path to create the version-create.mongo script
-    # 2. The second argument is the path to the directory containing the JSON files
-    add_custom_command(
-      TARGET dbschema_mongodb
-      POST_BUILD
-      COMMAND
-        bash ${CMAKE_CURRENT_SOURCE_DIR}/generate_version_create_mongo.sh
-        "${CMAKE_CURRENT_BINARY_DIR}/mongodb/kamailio/version-create.mongo"
-        "${CMAKE_CURRENT_BINARY_DIR}/mongodb/kamailio"
-      COMMENT "Creating version-create.mongo from JSON files"
-    )
-
-    install(
-      FILES ${CMAKE_CURRENT_BINARY_DIR}/mongodb/kamailio/version-create.mongo
-      DESTINATION ${CMAKE_INSTALL_DATADIR}/${MAIN_NAME}/mongodb/${MAIN_NAME}
-      COMPONENT KMONGODB
-    )
-  endif()
-  if("db_redis" IN_LIST FINAL_MODULES_LIST)
-    add_db_target(db_redis "${STYLESHEETS}/db_redis.xsl")
-    add_dependencies(dbschema dbschema_db_redis)
-    add_dependencies(dbschema_clean dbschema_db_redis_clean)
-  endif()
-endif()