openubmc-bingo 0.5.257__py3-none-any.whl → 0.5.261__py3-none-any.whl

bmcgo/__init__.py

@@ -9,4 +9,4 @@
 # MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 # See the Mulan PSL v2 for more details.
 
-__version__ = '0.5.257'
+__version__ = '0.5.261'

bmcgo/codegen/lua/codegen.py

@@ -15,6 +15,7 @@ import os
 import re
 import subprocess
 import shutil
+from pathlib import Path
 from bmcgo.codegen.c.helper import Helper
 from bmcgo import misc
 from bmcgo.utils.tools import Tools
@@ -98,6 +99,27 @@ class CodeGen(object):
         shutil.copytree(os.path.join(temp_dir, "mdb_interface/opt/bmc/apps/mdb_interface"), target_dir)
         shutil.rmtree(temp_dir, ignore_errors=True)
 
+    def setup_latest_mdb_interface(self):
+        target_dir = os.path.join(self.project_dir, 'temp/opt/bmc/apps/latest_mdb_interface')
+        shutil.rmtree(target_dir, ignore_errors=True)
+        temp_dir = os.path.join(self.project_dir, 'temp/.latest_mdb_interface_temp')
+        shutil.rmtree(temp_dir, ignore_errors=True)
+        os.makedirs(temp_dir, exist_ok=True)
+
+        conan_home = Path(os.environ.get("CONAN_HOME", Path.home() / ".conan/data"))
+        mdb_interface_tmp_dir = os.path.join(conan_home, "latest_mdb_interface")
+        env = dict(os.environ, CONAN_STORAGE_PATH=mdb_interface_tmp_dir)
+
+        package = self.get_mdb_interface_package()
+        cmd = ["conan", "install", package, f"-if={temp_dir}", "--update", "--build=missing", "-g", "deploy"]
+        cmd += ["-pr=profile.dt.ini", "-s", "build_type=Dt"]
+        if self.remote:
+            cmd += ["-r", self.remote]
+
+        subprocess.run(cmd, env=env)
+        shutil.copytree(os.path.join(temp_dir, "mdb_interface/opt/bmc/apps/mdb_interface"), target_dir)
+        shutil.rmtree(temp_dir, ignore_errors=True)
+
     def is_valid_date(self, date_str):
         pattern = r'^-- Create: \d{4}-\d{1,2}-\d{1,2}$'
         return bool(re.match(pattern, date_str))
@@ -141,6 +163,7 @@ class CodeGen(object):
         shutil.rmtree(self.gen_tool_dir, ignore_errors=True)
         shutil.copytree(cwd, self.gen_tool_dir)
         self.setup_mdb_interface()
+        self.setup_latest_mdb_interface()
         lua_format = self.get_lua_format()
         cmd = [
             "/usr/bin/make", "-j12", f"PROJECT_NAME={self.project_name}", f"TPL_DIR={self.gen_tool_dir}",

bmcgo/codegen/lua/script/model_consistency_check.py

@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+# coding=utf-8
+# Copyright (c) 2025 Huawei Technologies Co., Ltd.
+# openUBMC is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#         http://license.coscl.org.cn/MulanPSL2
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+
+import json
+import logging
+import getopt
+import sys
+import os
+import stat
+from collections import OrderedDict
+import mds_util as utils
+
+
+MDB_INTF_ITEM = ["properties", "methods", "signals"]
+MDB_METHOD_KEY = ["baseType", "items", "minimum", "maximum", "minLength", "maxLength", "pattern", "enum"]
+MDB_PROPERTY_KEY = MDB_METHOD_KEY + ["readOnly", "deprecated", "constrait"]
+OBJECT_PROPERTIES_INTERFACE = "bmc.kepler.Object.Properties"
+BASETYPE = "baseType"
+REQ = "req"
+RSP = "rsp"
+
+
+class MethodCheckArgs:
+    def __init__(self, mdb_data, complete_data, class_name, intf_name, method, param_type):
+        self.mdb_data = mdb_data
+        self.complete_data = complete_data
+        self.class_name = class_name
+        self.intf_name = intf_name
+        self.method = method
+        self.param_type = param_type
+
+
+def get_parent_path(origin_model, class_data):
+    if "parent" in class_data and class_data["parent"] in origin_model and \
+                "path" in origin_model[class_data["parent"]]:
+        return get_parent_path(origin_model, origin_model[class_data["parent"]]) \
+            + "/" + utils.cut_ids(class_data["path"])
+    else:
+        return utils.cut_ids(class_data["path"])
+
+
+def check_prop_consistency(mdb_item, complete_item, class_name, intf_name, prop_keys):
+    for prop in prop_keys:
+        if BASETYPE in mdb_item[prop] and BASETYPE in complete_item[prop]:
+            if mdb_item[prop][BASETYPE] != complete_item[prop][BASETYPE]:
+                raise RuntimeError(f"组件模型中类{class_name}接口{intf_name}的属性{prop}的类型{complete_item[prop][BASETYPE]}"
+                    f"与mdb_interface对应类型{mdb_item[prop][BASETYPE]}不一致"
+                )
+
+
+def check_method_params(args):
+    mdb_keys = set(args.mdb_data.keys())
+    complete_keys = set(args.complete_data.keys())
+    label = "请求" if args.param_type == REQ else "响应"
+    if mdb_keys != complete_keys:
+        only_in_mdb = mdb_keys - complete_keys
+        if only_in_mdb:
+            raise RuntimeError(f"组件模型中类{args.class_name}接口{args.intf_name}的方法{args.method}中的{label}参数{only_in_mdb}"
+                f"未实现，请检查model.json与mdb_interface定义"
+            )
+        only_in_complete = complete_keys - mdb_keys
+        if only_in_complete:
+            raise RuntimeError(f"组件模型中类{args.class_name}接口{args.intf_name}的方法{args.method}中的{label}参数{only_in_complete}"
+                f"未在mdb_interface中定义，请检查model.json与mdb_interface定义"
+            )
+    
+    for param in mdb_keys:
+        if BASETYPE in args.mdb_data[param] and BASETYPE in args.complete_data[param]:
+            if args.mdb_data[param][BASETYPE] != args.complete_data[param][BASETYPE]:
+                raise RuntimeError(f"组件模型中类{args.class_name}接口{args.intf_name}的方法{args.method}中的{label}参数{param}的类型"
+                    f"{args.complete_data[param][BASETYPE]}与mdb_interface对应类型{args.mdb_data[param][BASETYPE]}不一致"
+                )
+
+
+def check_method_consistency(mdb_item, complete_item, class_name, intf_name, method_keys):
+    for method in method_keys:
+        has_req_mdb = REQ in mdb_item[method]
+        has_req_complete = REQ in complete_item[method]
+        if has_req_mdb != has_req_complete:
+            if has_req_mdb:
+                raise RuntimeError(f"组件模型中类{class_name}的接口{intf_name}的方法{method}中未实现req，请检查model.json与mdb_interface定义")
+            else:
+                raise RuntimeError(f"组件模型中类{class_name}的接口{intf_name}的方法{method}中req未在mdb_interface中定义"
+                    f"，请检查model.json与mdb_interface定义"
+                )
+        else:
+            if has_req_mdb:
+                method_req_params = MethodCheckArgs(mdb_item[method][REQ], complete_item[method][REQ], \
+                                                    class_name, intf_name, method, REQ)
+                check_method_params(method_req_params)
+
+        has_rsp_mdb = RSP in mdb_item[method]
+        has_rsp_complete = RSP in complete_item[method]
+        if has_rsp_mdb != has_rsp_complete:
+            if has_rsp_mdb:
+                raise RuntimeError(f"组件模型中类{class_name}的接口{intf_name}的方法{method}中未实现rsp参数"
+                    f"，请检查model.json与mdb_interface定义"
+                )
+            else:
+                raise RuntimeError(f"组件模型中类{class_name}的接口{intf_name}的方法{method}中rsp未在mdb_interface中定义"
+                    f"，请检查model.json与mdb_interface定义"
+                )
+        else:
+            if has_rsp_mdb:
+                method_rsp_params = MethodCheckArgs(mdb_item[method][RSP], complete_item[method][RSP], \
+                                                    class_name, intf_name, method, RSP)
+                check_method_params(method_rsp_params) 
+
+
+def check_intf_item_consistency(mdb_item, complete_item, class_name, intf_name, item_type):
+    mdb_keys = set(mdb_item.keys())
+    complete_keys = set(complete_item.keys())
+    diff_keys = mdb_keys.symmetric_difference(complete_keys)
+    if diff_keys:
+        only_in_mdb = diff_keys - complete_keys
+        only_in_complete = diff_keys - mdb_keys
+        if only_in_mdb:
+            raise RuntimeError(f"组件模型中类{class_name}的接口{intf_name}的{item_type}未实现{only_in_mdb}"
+                f"，请检查model.json与mdb_interface定义"
+            )
+        if only_in_complete:
+            raise RuntimeError(f"组件模型中类{class_name}的接口{intf_name}的{item_type}中的{only_in_complete}"
+                f"未在mdb_interface中定义，请检查model.json与mdb_interface定义"
+            )
+
+    if item_type == "properties":
+        check_prop_consistency(mdb_item, complete_item, class_name, intf_name, mdb_keys)
+    elif item_type == "methods":
+        check_method_consistency(mdb_item, complete_item, class_name, intf_name, mdb_keys)
+
+
+def check_intf_consistency(mdb_intf, complete_intf, class_name, intf_name):
+    for item in MDB_INTF_ITEM:
+        if item in mdb_intf and item not in complete_intf:
+            if mdb_intf[item]:
+                raise RuntimeError(f"组件模型中类{class_name}的接口{intf_name}未实现{item}，请检查model.json与mdb_interface定义")
+        elif item not in mdb_intf and item in complete_intf:
+            if complete_intf[item]:
+                raise RuntimeError(f"组件模型中类{class_name}的接口{intf_name}的{item}未在mdb_interface中定义"
+                    f"，请检查model.json与mdb_interface定义"            
+                )
+        elif item in mdb_intf and item in complete_intf:
+            check_intf_item_consistency(mdb_intf[item], complete_intf[item], class_name, intf_name, item)
+
+
+def check_model_consistency(class_name, complete_model, mdb_obj, mdb_path):
+    intf_complete = set(complete_model["interfaces"].keys())
+    intf_mdb = set(mdb_obj[class_name]["interfaces"])
+    if intf_complete != intf_mdb:
+        intf_only_in_mds = intf_complete - intf_mdb
+        intf_only_in_mds.discard(OBJECT_PROPERTIES_INTERFACE)
+        if intf_only_in_mds:
+            raise RuntimeError(f"组件模型中类{class_name}的接口{intf_only_in_mds}未在mdb_interface中定义"
+                f"，请检查model.json与mdb_interface定义"
+            )
+        intf_only_in_mdb = intf_mdb - intf_complete
+        if intf_only_in_mdb:
+            raise RuntimeError(f"组件模型中类{class_name}未实现{intf_only_in_mdb}接口，请检查model.json与mdb_interface定义")
+
+    for intf_name in intf_complete:
+        mdb_intf_json = utils.get_intf(intf_name, mdb_path)
+        check_intf_consistency(mdb_intf_json[intf_name], complete_model["interfaces"][intf_name], class_name, intf_name)
+
+
+def check(if_name, mdb_path):
+    load_dict = {}
+    if os.path.exists(if_name):
+        load_f = os.fdopen(os.open(if_name, os.O_RDONLY, stat.S_IRUSR), "r")
+        load_dict = OrderedDict(json.load(load_f))
+        load_f.close()
+
+    for class_name, class_data in load_dict.items():
+        if "path" in class_data and class_name != "defs":
+            class_path = get_parent_path(load_dict, class_data)
+            mdb_obj = utils.get_path(class_name, mdb_path, class_path)
+            check_model_consistency(class_name, class_data, mdb_obj, mdb_path)
+
+
+def get_all_modelx_json(mds_dir):
+    load_dict = {}
+    for root, _, files in os.walk(mds_dir):
+        for file in files:
+            if file == 'modelx.json':
+                file_path = os.path.join(root, file)
+                load_f = os.fdopen(os.open(file_path, os.O_RDONLY, stat.S_IRUSR), "r")
+                load_modelx_dict = OrderedDict(json.load(load_f))
+                load_dict.update(load_modelx_dict)
+
+    return load_dict
+
+
+def access_check(mds_dir, mdb_path):
+    load_dict = get_all_modelx_json(mds_dir)
+
+    for class_name, class_data in load_dict.items():
+        if "path" in class_data and class_name != "defs":
+            class_path = get_parent_path(load_dict, class_data)
+            mdb_obj = utils.get_path(class_name, mdb_path, class_path)
+            check_model_consistency(class_name, class_data, mdb_obj, mdb_path)
+
+    return True   
+    
+
+def usage():
+    logging.info("model_consistency_check.py -i <inputfile> -d <MdbInterfaceDir>")
+
+
+def main(argv):
+    m_input = ""
+    mdb_path = ""
+    try:
+        opts, _ = getopt.getopt(argv, "hi:d:", ["help", "input=", "mdb_interface_path="])
+    except getopt.GetoptError:
+        help()
+        return
+    for opt, arg in opts:
+        if opt in ("-h", "--help"):
+            usage()
+            return
+        elif opt in ("-i", "--input"):
+            m_input = arg
+        elif opt in ("-d", "--dir"):
+            mdb_path = arg
+        else:
+            raise RuntimeError("不支持的选项: {}".format(opt))
+    if not m_input:
+        usage()
+        return
+    check(m_input, mdb_path)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

bmcgo/codegen/lua/script/render_utils/__init__.py

@@ -12,9 +12,10 @@
 
 __all__ = [
     'Base', 'Factory', 'RequestLuaUtils', 'ControllerLuaUtils', 'IpmiMessageUtils', 'MessageUtils',
-    'UtilsMessageLua', 'ErrorLuaUtils', 'ClientLuaUtils', "ConsistencyModelLuaUtils",
+    'UtilsMessageLua', 'ErrorLuaUtils', 'ClientLuaUtils', "ConsistencyModelLuaUtils", "ConsistencyDbLuaUtils",
     'DbLuaUtils', 'IpmiLuaUtils', 'RedfishProtoUtils', 'ServicesUtils', 
-    'MdbLuaUtils', 'OldModelLuaUtils', 'ModelLuaUtils', "MdbRegister", 'MessagesLuaUtils', 'PluginLuaUtils'
+    'MdbLuaUtils', 'OldModelLuaUtils', 'ModelLuaUtils', "MdbRegister", 'MessagesLuaUtils', 'PluginLuaUtils',
+    'ConsistencyClientLuaUtils'
 ]
 
 from render_utils.client_lua import ClientLuaUtils
@@ -31,9 +32,11 @@ from render_utils.service_lua import ServicesUtils
 from render_utils.utils_message_lua import UtilsMessageLua
 from render_utils.old_model_lua import OldModelLuaUtils
 from render_utils.model_lua import ModelLuaUtils
-from render_utils.mdb_register import MdbRegister
 from render_utils.messages_lua import MessagesLuaUtils
 from render_utils.plugin_lua import PluginLuaUtils
+from bmcgo.codegen.lua.script.mdb_register import MdbRegister
 from bmcgo.codegen.lua.script.base import Base
 from bmcgo.codegen.lua.script.factory import Factory
-from bmcgo.codegen.lua.v1.script.render_utils.model_lua import ConsistencyModelLuaUtils
+from bmcgo.codegen.lua.v1.script.render_utils.model_lua import ConsistencyModelLuaUtils
+from bmcgo.codegen.lua.v1.script.render_utils.db_lua import ConsistencyDbLuaUtils
+from bmcgo.codegen.lua.v1.script.render_utils.client_lua import ConsistencyClientLuaUtils

bmcgo/codegen/lua/script/render_utils/client_lua.py

@@ -12,7 +12,7 @@
 
 from utils import Utils
 from dto.options import Options
-from render_utils.mdb_register import MdbRegister
+from bmcgo.codegen.lua.script.mdb_register import MdbRegister
 from bmcgo.codegen.lua.script.base import Base
 from bmcgo.codegen.lua.script.factory import Factory
 
@@ -96,4 +96,3 @@ class ClientLuaUtils(Base, Utils, MdbRegister):
         return f"path_params and ({path_with_params}) or '{path}'"
 
 Factory().register("client.lua.mako", ClientLuaUtils)
-Factory().register("v1/templates/apps/client.lua.mako", ClientLuaUtils)

bmcgo/codegen/lua/script/render_utils/message_lua.py

@@ -13,7 +13,7 @@
 from dto.options import Options
 from render_utils.utils_message_lua import UtilsMessageLua
 from render_utils.validate_lua import ValidateLua
-from render_utils.mdb_register import MdbRegister
+from bmcgo.codegen.lua.script.mdb_register import MdbRegister
 from bmcgo.codegen.lua.script.base import Base
 from bmcgo.codegen.lua.script.factory import Factory
 
@@ -24,3 +24,4 @@ class MessageUtils(Base, ValidateLua, UtilsMessageLua, MdbRegister):
 
 
 Factory().register("message.lua.mako", MessageUtils)
+Factory().register("v1/templates/apps/message.lua.mako", MessageUtils)

bmcgo/codegen/lua/script/render_utils/service_lua.py

@@ -15,7 +15,7 @@ import re
 from utils import Utils
 from dto.options import Options
 from render_utils.validate_lua import ValidateLua
-from render_utils.mdb_register import MdbRegister
+from bmcgo.codegen.lua.script.mdb_register import MdbRegister
 from bmcgo.codegen.lua.script.base import Base
 from bmcgo.codegen.lua.script.factory import Factory
 

bmcgo/codegen/lua/script/utils.py

@@ -267,7 +267,9 @@ class Utils:
 
     @staticmethod
     def force_to_colon(path):
-        return path.replace("${", ":").replace("}", "")
+        if isinstance(path, str):
+            return path.replace("${", ":").replace("}", "")
+        return [p.replace("${", ":").replace("}", "") for p in path]
 
     @staticmethod
     def check_db_open(name):
@@ -664,8 +666,15 @@ class Utils:
 
     def get_path_params(self, path):
         path = self.force_to_colon(path)
-        params = re.compile(
-            r':([a-zA-Z_][0-9a-zA-Z_]+)').findall(path)
+
+        pattern = r':([a-zA-Z_][0-9a-zA-Z_]+)'
+        if isinstance(path, str):
+            params = re.compile(pattern).findall(path)
+        else:
+            params = []
+            for p in path:
+                params.extend(re.compile(pattern).findall(p))
+                
         return self.remove_duplicate(params)
 
     def deduplicate_path(self, path):

bmcgo/codegen/lua/templates/apps/Makefile

@@ -3,6 +3,7 @@ TEMPLATE_BIN = ${SCRIPT_DIR}/template.py
 SEP_IPMI_MESSAGE_CMDS_BIN = ${SCRIPT_DIR}/sep_ipmi_message_cmds.py
 LUA_FORMATER = ${SCRIPT_DIR}/lua_format.py
 MDB_INTF_DIR = ${TEMP_DIR}/opt/bmc/apps/mdb_interface/
+LATEST_MDB_INTF_DIR = ${TEMP_DIR}/opt/bmc/apps/latest_mdb_interface/
 YAML_TO_JSON_BIN = ${SCRIPT_DIR}/yaml_to_json.py
 BAK_LOCAL_DB_DIR = ${GEN_BAK_DIR}/${PROJECT_NAME}
 MAJOR_VERSION_EQ_1 := $(shell [ $(MAJOR_VERSION) -eq 1 ] && echo true)
@@ -63,9 +64,15 @@ $(strip $(subst .proto.json,,$(1)))
 endef
 
 define MAKE_MESSAGE
+ifeq ($(MAJOR_VERSION_EQ_1), true)
+  $$(GEN_OUT_DIR)/$(1).lua: ${PROTO_OUT_DIR}/$(1).proto.json $${TEMPLATE_BIN} ${MAJOR_VERIONS_DIR}/v1/templates/apps/message.lua.mako utils/message.mako utils/enum.mako
+	@mkdir -p $$(dir $$@)
+	python3 $${TEMPLATE_BIN} -d ${PROTO_DIR} -j ${PROTO_OUT_DIR} -n ${PROJECT_NAME} -i ${PROTO_OUT_DIR}/$(1).proto.json -f ${LUA_FORMATER} -t v1/templates/apps/message.lua.mako -o $$@
+else
   $$(GEN_OUT_DIR)/$(1).lua: ${PROTO_OUT_DIR}/$(1).proto.json $${TEMPLATE_BIN} message.lua.mako utils/message.mako utils/enum.mako
 	@mkdir -p $$(dir $$@)
 	python3 $${TEMPLATE_BIN} -d ${PROTO_DIR} -j ${PROTO_OUT_DIR} -n ${PROJECT_NAME} -i ${PROTO_OUT_DIR}/$(1).proto.json -f ${LUA_FORMATER} -t message.lua.mako -o $$@
+endif
 endef
 $(foreach v, $(MESSAGE_FILES), $(eval $(call MAKE_MESSAGE,$(v))))
 message: $(foreach v, $(MESSAGE_FILES), $(GEN_OUT_DIR)/$(v).lua)
@@ -131,6 +138,13 @@ endif
 ${PROTO_OUT_DIR}/_model.json: ${SCRIPT_DIR}/merge_model.py
 	python3 ${SCRIPT_DIR}/merge_model.py -i ${MDS_DIR}/model.json -o $@ -d ${MDB_INTF_DIR} -c ${SCRIPT_DIR}/../temp/check_cmd.json
 
+ifeq ($(MAJOR_VERSION_EQ_1), true)
+model_consistency_check: ${PROTO_OUT_DIR}/_model.json ${SCRIPT_DIR}/model_consistency_check.py
+	python3 ${SCRIPT_DIR}/model_consistency_check.py -i ${PROTO_OUT_DIR}/_model.json -d ${LATEST_MDB_INTF_DIR}
+else
+model_consistency_check:
+endif
+
 ifeq ($(MAJOR_VERSION_EQ_1), true)
 $(MDS_DIR)/modelx.json: ${PROTO_OUT_DIR}/_model.json
 	mkdir -p $(@D)
@@ -164,11 +178,19 @@ ${MDS_DIR}/schema.json: ${PROTO_OUT_DIR}/_model.json ${SCRIPT_DIR}/gen_schema.py
 	python3 ${SCRIPT_DIR}/gen_schema.py -i ${PROTO_OUT_DIR}/_model.json -n ${PROJECT_NAME} -o $@
 endif
 
+ifeq ($(MAJOR_VERSION_EQ_1), true)
+${PROTO_OUT_DIR}/db_json.json: ${PROTO_OUT_DIR}/_model.json ${SCRIPT_DIR}/gen_db_json.py
+	python3 ${SCRIPT_DIR}/gen_historical_local_db_json.py -i ${BAK_LOCAL_DB_DIR}/local_db.lua -o ${PROTO_OUT_DIR}/historical_local_db.json
+	python3 ${SCRIPT_DIR}/gen_db_json.py -i ${PROTO_OUT_DIR}/_model.json -m ${PROTO_OUT_DIR}/historical_local_db.json -o $@
+	python3 ${TEMPLATE_BIN} -d ${PROTO_DIR} -j ${PROTO_OUT_DIR}/ -n ${PROJECT_NAME} -i ${PROTO_OUT_DIR}/db_json.json -f ${LUA_FORMATER} -t v1/templates/apps/db.lua.mako -o ${GEN_OUT_DIR}/db.lua
+	python3 ${TEMPLATE_BIN} -d ${PROTO_DIR} -j ${PROTO_OUT_DIR}/ -n ${PROJECT_NAME} -i ${PROTO_OUT_DIR}/local_db_json.json -f ${LUA_FORMATER} -t v1/templates/apps/local_db.lua.mako -o ${GEN_OUT_DIR}/local_db.lua
+else
 ${PROTO_OUT_DIR}/db_json.json: ${PROTO_OUT_DIR}/_model.json ${SCRIPT_DIR}/gen_db_json.py
 	python3 ${SCRIPT_DIR}/gen_historical_local_db_json.py -i ${BAK_LOCAL_DB_DIR}/local_db.lua -o ${PROTO_OUT_DIR}/historical_local_db.json
 	python3 ${SCRIPT_DIR}/gen_db_json.py -i ${PROTO_OUT_DIR}/_model.json -m ${PROTO_OUT_DIR}/historical_local_db.json -o $@
 	python3 ${TEMPLATE_BIN} -d ${PROTO_DIR} -j ${PROTO_OUT_DIR}/ -n ${PROJECT_NAME} -i ${PROTO_OUT_DIR}/db_json.json -f ${LUA_FORMATER} -t db.lua.mako -o ${GEN_OUT_DIR}/db.lua
 	python3 ${TEMPLATE_BIN} -d ${PROTO_DIR} -j ${PROTO_OUT_DIR}/ -n ${PROJECT_NAME} -i ${PROTO_OUT_DIR}/local_db_json.json -f ${LUA_FORMATER} -t local_db.lua.mako -o ${GEN_OUT_DIR}/local_db.lua
+endif
 
 ifneq ($(wildcard ${MDS_DIR}/types.json),)
 # types代码生成
@@ -176,10 +198,17 @@ types_message_json: ${TYPES_JSON_PATH} ${SCRIPT_DIR}/gen_rpc_msg_json.py
 	mkdir -p ${PROTO_OUT_DIR}/model_types/
 	python3 ${SCRIPT_DIR}/gen_rpc_msg_json.py -i ${TYPES_JSON_PATH} -o ${PROTO_OUT_DIR}/model_types/ -d ${MDB_INTF_DIR} -t
 
+ifeq ($(MAJOR_VERSION_EQ_1), true)
+types_message: types_message_json
+	python3 ${TEMPLATE_BIN} -d ${PROTO_DIR} -j ${PROTO_OUT_DIR}/model_types/ -n ${PROJECT_NAME} \
+	-i ${PROTO_OUT_DIR}/model_types/def_types.proto.json -f ${LUA_FORMATER} -t v1/templates/apps/message.lua.mako \
+	-o $(call proto_json_to_lua, ${GENERATE_OUT_DIR}/class/types/types.lua);
+else
 types_message: types_message_json
 	python3 ${TEMPLATE_BIN} -d ${PROTO_DIR} -j ${PROTO_OUT_DIR}/model_types/ -n ${PROJECT_NAME} \
 	-i ${PROTO_OUT_DIR}/model_types/def_types.proto.json -f ${LUA_FORMATER} -t message.lua.mako \
 	-o $(call proto_json_to_lua, ${GENERATE_OUT_DIR}/class/types/types.lua);
+endif
 
 endif
 
@@ -188,17 +217,36 @@ model_message_json: ${PROTO_OUT_DIR}/_model.json ${SCRIPT_DIR}/gen_rpc_msg_json.
 	mkdir -p ${PROTO_OUT_DIR}/model_types/
 	python3 ${SCRIPT_DIR}/gen_rpc_msg_json.py -i ${PROTO_OUT_DIR}/_model.json -o ${PROTO_OUT_DIR}/model_types/ -d ${MDB_INTF_DIR} -p
 
+ifeq ($(MAJOR_VERSION_EQ_1), true)
+model_message: model_message_json
+	@$(foreach x,$(shell ls $(PROTO_OUT_DIR)/model_types/ -I def_types.proto.json), \
+        python3 ${TEMPLATE_BIN} -d ${PROTO_DIR} -j ${PROTO_OUT_DIR}/model_types/ -n ${PROJECT_NAME} \
+		-i ${PROTO_OUT_DIR}/model_types/$x -f ${LUA_FORMATER} -t v1/templates/apps/message.lua.mako \
+		-o $(call proto_json_to_lua, ${GENERATE_OUT_DIR}/class/types/$x);)
+else
 model_message: model_message_json
 	@$(foreach x,$(shell ls $(PROTO_OUT_DIR)/model_types/ -I def_types.proto.json), \
         python3 ${TEMPLATE_BIN} -d ${PROTO_DIR} -j ${PROTO_OUT_DIR}/model_types/ -n ${PROJECT_NAME} \
 		-i ${PROTO_OUT_DIR}/model_types/$x -f ${LUA_FORMATER} -t message.lua.mako \
 		-o $(call proto_json_to_lua, ${GENERATE_OUT_DIR}/class/types/$x);)
+endif
 
 # 服务端代码生成
 service_message_json: ${PROTO_OUT_DIR}/_model.json ${SCRIPT_DIR}/gen_rpc_msg_json.py
 	@mkdir -p ${PROTO_OUT_DIR}/json_types/
 	python3 ${SCRIPT_DIR}/gen_rpc_msg_json.py -i ${PROTO_OUT_DIR}/_model.json -o ${PROTO_OUT_DIR}/json_types/ -d ${MDB_INTF_DIR} -n ${PROJECT_NAME} -m
 
+ifeq ($(MAJOR_VERSION_EQ_1), true)
+service_message: service_message_json
+	@$(foreach x,$(shell ls $(PROTO_OUT_DIR)/json_types/),\
+        python3 ${TEMPLATE_BIN} -v ${VERSION} -d ${PROTO_DIR} -j ${PROTO_OUT_DIR}/json_types/ -n ${PROJECT_NAME} \
+		-i ${PROTO_OUT_DIR}/json_types/$x -f ${LUA_FORMATER} -t v1/templates/apps/message.lua.mako \
+		-o $(call proto_json_to_lua, ${GEN_OUT_DIR}/json_types/$x);)
+	@$(foreach x,$(shell ls $(PROTO_OUT_DIR)/device_types/),\
+        python3 ${TEMPLATE_BIN} -d ${PROTO_DIR} -j ${PROTO_OUT_DIR}/device_types/ -n ${PROJECT_NAME} \
+		-i ${PROTO_OUT_DIR}/device_types/$x -f ${LUA_FORMATER} -t v1/templates/apps/message.lua.mako \
+		-o $(call proto_json_to_lua, ${GEN_OUT_DIR}/device_types/$x);)
+else
 service_message: service_message_json
 	@$(foreach x,$(shell ls $(PROTO_OUT_DIR)/json_types/),\
         python3 ${TEMPLATE_BIN} -v ${VERSION} -d ${PROTO_DIR} -j ${PROTO_OUT_DIR}/json_types/ -n ${PROJECT_NAME} \
@@ -208,6 +256,7 @@ service_message: service_message_json
         python3 ${TEMPLATE_BIN} -d ${PROTO_DIR} -j ${PROTO_OUT_DIR}/device_types/ -n ${PROJECT_NAME} \
 		-i ${PROTO_OUT_DIR}/device_types/$x -f ${LUA_FORMATER} -t message.lua.mako \
 		-o $(call proto_json_to_lua, ${GEN_OUT_DIR}/device_types/$x);)
+endif
 
 schema:  ${MDS_DIR}/schema.json
 database: ${PROTO_OUT_DIR}/db_json.json
@@ -275,11 +324,19 @@ client_messages_json: ${MDS_DIR}/service.json ${SCRIPT_DIR}/gen_rpc_msg_json.py
 	@mkdir -p ${PROTO_OUT_DIR}/json_types/
 	python3 ${SCRIPT_DIR}/gen_rpc_msg_json.py -i ${MDS_DIR}/service.json -o ${PROTO_OUT_DIR}/json_types/ -d ${MDB_INTF_DIR} -n ${PROJECT_NAME} -x
 
+ifeq ($(MAJOR_VERSION_EQ_1), true)
+client_messages: client_messages_json
+	@$(foreach x,$(shell ls $(PROTO_OUT_DIR)/json_types/),\
+        python3 ${TEMPLATE_BIN} -v ${VERSION} -d ${PROTO_DIR} -j ${PROTO_OUT_DIR}/json_types/ -n ${PROJECT_NAME} \
+		-i ${PROTO_OUT_DIR}/json_types/$x -f ${LUA_FORMATER} -t v1/templates/apps/message.lua.mako \
+		-o $(call proto_json_to_lua, ${GEN_OUT_DIR}/json_types/$x);)
+else
 client_messages: client_messages_json
 	@$(foreach x,$(shell ls $(PROTO_OUT_DIR)/json_types/),\
         python3 ${TEMPLATE_BIN} -v ${VERSION} -d ${PROTO_DIR} -j ${PROTO_OUT_DIR}/json_types/ -n ${PROJECT_NAME} \
 		-i ${PROTO_OUT_DIR}/json_types/$x -f ${LUA_FORMATER} -t message.lua.mako \
-		-o $(call proto_json_to_lua, ${GEN_OUT_DIR}/json_types/$x);) \
+		-o $(call proto_json_to_lua, ${GEN_OUT_DIR}/json_types/$x);)
+endif
 
 ifeq ($(MAJOR_VERSION_EQ_1), true)
 ${GEN_OUT_DIR}/client.lua : ${PROTO_OUT_DIR}/client.json ${TEMPLATE_BIN} \
@@ -295,4 +352,4 @@ client: ${GEN_OUT_DIR}/client.lua
 
 endif
 
-all: client service modelx message datas datas_conf restapi restapi_resource schema  model types_message model_message database ipmi orm_classes feature impl_feature
+all: client service modelx message datas datas_conf restapi restapi_resource schema  model types_message model_message database ipmi orm_classes feature impl_feature model_consistency_check

bmcgo/codegen/lua/v1/script/render_utils/client_lua.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+# coding=utf-8
+# Copyright (c) 2024 Huawei Technologies Co., Ltd.
+# openUBMC is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#         http://license.coscl.org.cn/MulanPSL2
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+
+from utils import Utils
+from bmcgo.codegen.lua.script.dto.options import Options
+from bmcgo.codegen.lua.script.mdb_register import MdbRegister
+from bmcgo.codegen.lua.script.base import Base
+from bmcgo.codegen.lua.script.factory import Factory
+
+
+class ConsistencyClientLuaUtils(Base, Utils, MdbRegister):
+    def __init__(self, data: dict, options: Options):
+        super().__init__(data, options=options)
+
+    @staticmethod
+    def message_type(t):
+        if t == ".google.protobuf.Empty":
+            return 'nil'
+        return t[1:] if t.startswith('.') else t
+
+    def sig(self, msg_type):
+        msg = Utils(self.data, self.options).make_get_message(msg_type)
+        return "".join(
+            [Utils(self.data, self.options).do_type_to_dbus(p['type'], p['repeated']) for p in msg.get('properties')])
+
+    def props(self, msg_type):
+        msg = Utils(self.data, self.options).make_get_message(msg_type)
+        return msg.get('properties')
+
+    def params(self, msg_type):
+        return ", ".join([p['name'] for p in self.props(msg_type)])
+
+    def cb_name(self, rpc):
+        return Utils(self.data, self.options).camel_to_snake('__On' + rpc['name'])
+
+    def rsp_message(self, rpc):
+        return self.message_type(rpc['rsp'])
+
+    def req_message(self, rpc):
+        return self.message_type(rpc['req'])
+
+    def make_path_with_params(self, path):
+        path = self.force_to_colon(path)
+        params = self.get_path_params(path)
+        if not params:
+            return f"'{path}'"
+        result = []
+        for name in params:
+            parts = path.partition(f':{name}')
+            result.append(f"'{parts[0]}'")
+            result.append(f"path_params['{name}']")
+            path = parts[2]
+        ret = ' .. '.join(result)
+        if path:
+            ret += f" .. '{path}'"
+        return ret
+
+    def get_path_arg(self, path, with_comma=True):
+        if not self.get_path_params(path):
+            return ""
+        if with_comma:
+            return ", path_params"
+        return "path_params"
+
+    def get_path_namespace_name(self, index):
+        return f"path_namespace{index + 1}"
+
+    def get_path_namespace_list(self, paths):
+        indexed_path_namespace = [
+            f"path_namespace{index + 1}"
+            for index, _ in enumerate(paths)
+        ]
+        return "{" + ", ".join(indexed_path_namespace) + "}"
+
+    def get_dep_properties(self, properties):
+        if properties == ["*"]:
+            return ""
+
+        return ', {"' + '", "'.join(properties) + '"}'
+
+    def get_path_namespace(self, path):
+        if not self.get_path_params(path):
+            return f"'{path}'"
+        path_with_params = self.make_path_with_params(path)
+        if Utils.get_lua_codegen_version() >= 17:
+            return f"path_params and ({path_with_params}) or '{path}'"
+        prefix = path_with_params.split("/' ..")[0]
+        return f"path_params and ({path_with_params}) or {prefix}'"
+
+    def get_path_patterns(self, paths):
+        return MdbRegister.convert_to_lua(self, paths)
+
+    def get_object_path(self, path):
+        if not self.get_path_params(path):
+            return f"'{path}'"
+        path_with_params = self.make_path_with_params(path)
+        return f"path_params and ({path_with_params}) or '{path}'"
+
+Factory().register("v1/templates/apps/client.lua.mako", ConsistencyClientLuaUtils)