openubmc-bingo 0.5.242__py3-none-any.whl → 0.5.253__py3-none-any.whl

bmcgo/codegen/lua/script/template.py

@@ -46,6 +46,9 @@ def parse_input_args() -> Options:
     parser.add_argument("-n", "--project_name", dest="project_name",
                         help="project name",
                         default="")
+    parser.add_argument("-p", "--major_version", dest="major_version",
+                        help="major version",
+                        default="")
     parser.add_argument("-v", "--version", dest="version",
                         help="version",
                         default=-1)
@@ -122,7 +125,7 @@ def generate(options: Options):
 
     header = utils.Utils(data, options).make_header(
         options.template_name, options.output_file_path)
-    lookup = TemplateLookup(directories=[os.getcwd() + "/"], input_encoding='utf-8')
+    lookup = TemplateLookup(directories=[os.getcwd() + "/", os.getcwd() + "/../../"], input_encoding='utf-8')
     template = lookup.get_template(options.template_name)
     if os.path.exists(options.output_file_path):
         os.remove(options.output_file_path)
@@ -144,6 +147,7 @@ def generate(options: Options):
         load_import=make_load_import(data, options),
         project_name=options.project_name,
         version=options.version,
+        major_version=options.major_version,
         use_frame_log=use_frame_log,
     ))
     output_file.write(render_data)

bmcgo/codegen/lua/script/utils.py

@@ -16,8 +16,8 @@ import re
 from datetime import datetime, timezone
 from pathlib import Path
 
-from dto.options import Options
-from validate import all_validates
+from bmcgo.codegen.lua.script.dto.options import Options
+from bmcgo.codegen.lua.script.validate import all_validates
 from bmcgo.codegen import __version__ as codegen_version
 
 
@@ -206,6 +206,13 @@ class Utils:
             return codegen_version
         return int(env_version)
 
+    @staticmethod
+    def get_major_version():
+        env_version = os.getenv('MAJOR_VERSION')
+        if env_version is None or env_version == "-1" or not env_version.isdigit():
+            return 1
+        return int(env_version)
+
     @staticmethod
     def formatter(header, date, filename, lang, draft_info):
         if draft_info:

bmcgo/codegen/lua/templates/Makefile

@@ -13,10 +13,12 @@ apps:
 		GENERATE_OUT_DIR=${GENERATE_OUT_DIR} \
 		PLUGIN_TEMPLATE_DIR=${TEMP_DIR}/plugin \
 		SCRIPT_DIR=${SCRIPT_DIR} \
+		MAJOR_VERIONS_DIR=${MAJOR_VERIONS_DIR} \
 		PROTO_OUT_DIR=${PROTO_OUT_DIR} \
 		PROTO_DIR=${PROTO_DIR} \
 		PROJECT_NAME=${PROJECT_NAME} \
 		VERSION=${VERSION} \
+		MAJOR_VERSION=${MAJOR_VERSION} \
 		RESTAPI_DIRS="${RESTAPI_DIRS}" \
 		MDS_DIR=${MDS_DIR} \
 		TEMP_DIR=${TEMP_DIR} \
@@ -35,10 +37,12 @@ dft_make:
 		GENERATE_OUT_DIR=${GENERATE_OUT_DIR}/dft \
 		PLUGIN_TEMPLATE_DIR=${TEMP_DIR}/dft/plugin \
 		SCRIPT_DIR=${SCRIPT_DIR} \
+		MAJOR_VERIONS_DIR=${MAJOR_VERIONS_DIR} \
 		PROTO_OUT_DIR=${PROTO_OUT_DIR}/dft \
 		PROTO_DIR=${PROTO_DIR} \
 		PROJECT_NAME=${DFT_NAME} \
 		VERSION=${VERSION} \
+		MAJOR_VERSION=${MAJOR_VERSION} \
 		RESTAPI_DIRS="${RESTAPI_DIRS}" \
 		MDS_DIR=${MDS_DIR}/dft \
 		TEMP_DIR=${TEMP_DIR} \
@@ -60,10 +64,12 @@ debug_make:
 		GENERATE_OUT_DIR=${GENERATE_OUT_DIR}/debug \
 		PLUGIN_TEMPLATE_DIR=${TEMP_DIR}/debug/plugin \
 		SCRIPT_DIR=${SCRIPT_DIR} \
+		MAJOR_VERIONS_DIR=${MAJOR_VERIONS_DIR} \
 		PROTO_OUT_DIR=${PROTO_OUT_DIR}/debug \
 		PROTO_DIR=${PROTO_DIR} \
 		PROJECT_NAME=${DEBUG_NAME} \
 		VERSION=${VERSION} \
+		MAJOR_VERSION=${MAJOR_VERSION} \
 		RESTAPI_DIRS="${RESTAPI_DIRS}" \
 		MDS_DIR=${MDS_DIR}/debug \
 		TEMP_DIR=${TEMP_DIR} \
@@ -105,10 +111,12 @@ mdb:
 	@cd apps && make \
 		GENERATE_OUT_DIR=${GENERATE_OUT_DIR} \
 		SCRIPT_DIR=${SCRIPT_DIR} \
+		MAJOR_VERIONS_DIR=${MAJOR_VERIONS_DIR} \
 		PROTO_OUT_DIR=${PROTO_OUT_DIR} \
 		PROTO_DIR=${PROTO_DIR} \
 		PROJECT_NAME=${PROJECT_NAME} \
 		VERSION=${VERSION} \
+		MAJOR_VERSION=${MAJOR_VERSION} \
 		-f Makefile.mdb.mk
 
 all: apps errors dft_make debug_make

bmcgo/codegen/lua/templates/apps/Makefile

@@ -5,6 +5,7 @@ LUA_FORMATER = ${SCRIPT_DIR}/lua_format.py
 MDB_INTF_DIR = ${TEMP_DIR}/opt/bmc/apps/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)
 
 define get_proto_files
 $(wildcard $(1)*.proto) $(foreach e, $(wildcard $(1)*), $(call get_proto_files, $(e)/))
@@ -130,18 +131,38 @@ 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)
+$(MDS_DIR)/modelx.json: ${PROTO_OUT_DIR}/_model.json
+	mkdir -p $(@D)
+	cp $< $@
+modelx:${MDS_DIR}/modelx.json
+else
+modelx:
+endif
+
 ${PROTO_OUT_DIR}/service.json: ${PROTO_OUT_DIR}/_model.json ${SCRIPT_DIR}/gen_intf_rpc_json.py
 	python3 ${SCRIPT_DIR}/gen_intf_rpc_json.py -i ${PROTO_OUT_DIR}/_model.json -o $@ -s ${SERVICE_JSON_PATH} -p ${MDS_DIR}/ipmi.json
 
+ifeq ($(MAJOR_VERSION_EQ_1), true)
+${GEN_OUT_DIR}/service.lua: ${PROTO_OUT_DIR}/service.json ${TEMPLATE_BIN} \
+	${MAJOR_VERIONS_DIR}/v1/templates/apps/service.lua.mako utils/validate.mako utils/imports.mako service_message message
+	python3 ${TEMPLATE_BIN} -d ${PROTO_DIR} -v ${VERSION} -j ${PROTO_OUT_DIR}/json_types/ -n ${PROJECT_NAME} -i ${PROTO_OUT_DIR}/service.json -f ${LUA_FORMATER} -t v1/templates/apps/service.lua.mako -o $@
+else
 ${GEN_OUT_DIR}/service.lua: ${PROTO_OUT_DIR}/service.json ${TEMPLATE_BIN} \
   	service.lua.mako utils/validate.mako utils/imports.mako service_message message
 	python3 ${TEMPLATE_BIN} -d ${PROTO_DIR} -v ${VERSION} -j ${PROTO_OUT_DIR}/json_types/ -n ${PROJECT_NAME} -i ${PROTO_OUT_DIR}/service.json -f ${LUA_FORMATER} -t service.lua.mako -o $@
+endif
 
 service:${GEN_OUT_DIR}/service.lua
 
 ifneq ($(wildcard ${MDS_DIR}/model.json),)
+ifeq ($(MAJOR_VERSION_EQ_1), true)
+${MDS_DIR}/schema.json: ${PROTO_OUT_DIR}/_model.json ${MAJOR_VERIONS_DIR}/v1/script/gen_schema.py
+	python3 ${MAJOR_VERIONS_DIR}/v1/script/gen_schema.py -i ${PROTO_OUT_DIR}/_model.json -t ${MDS_DIR}/types.json -n ${PROJECT_NAME} -o $@
+else
 ${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
 
 ${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
@@ -191,8 +212,13 @@ service_message: service_message_json
 schema:  ${MDS_DIR}/schema.json
 database: ${PROTO_OUT_DIR}/db_json.json
 
+ifeq ($(MAJOR_VERSION_EQ_1), true)
+${GENERATE_OUT_DIR}/class/model.lua: ${PROTO_OUT_DIR}/_model.json ${TEMPLATE_BIN} ${MAJOR_VERIONS_DIR}/v1/templates/apps/model.lua.mako
+	python3 ${TEMPLATE_BIN} -d ${PROTO_DIR} -v ${VERSION} -j ${PROTO_OUT_DIR} -i ${PROTO_OUT_DIR}/_model.json -f ${LUA_FORMATER} -t v1/templates/apps/model.lua.mako -n ${PROJECT_NAME} -o $@
+else
 ${GENERATE_OUT_DIR}/class/model.lua: ${PROTO_OUT_DIR}/_model.json ${TEMPLATE_BIN} model.lua.mako
 	python3 ${TEMPLATE_BIN} -d ${PROTO_DIR} -v ${VERSION} -j ${PROTO_OUT_DIR} -i ${PROTO_OUT_DIR}/_model.json -f ${LUA_FORMATER} -t model.lua.mako -n ${PROJECT_NAME} -o $@
+endif
 
 model: ${GENERATE_OUT_DIR}/class/model.lua
 
@@ -258,4 +284,4 @@ client: ${GEN_OUT_DIR}/client.lua
 
 endif
 
-all: client service 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

bmcgo/codegen/lua/templates/apps/controller.lua.mako

@@ -186,16 +186,28 @@ function C${controller['name']}:on_${method}(req, rsp)
     local err
   % if method == 'post':
     local task_info
-    err, rsp.body, _, task_info = self.worker_ctrl:process(req.path, '${method}', {body = req.body, query = req.query, user = req.user})
+    % if render_utils.get_lua_codegen_version() <= 3:
+      err, rsp.body, _, task_info = self.route_mapper:match(req.path, '${method}', {body = req.body, query = req.query, user = req.user})
+    % else:
+      err, rsp.body, _, task_info = self.worker_ctrl:process(req.path, '${method}', {body = req.body, query = req.query, user = req.user})
+    % endif
   % else:
-    err, rsp.body = self.worker_ctrl:process(req.path, '${method}', {body = req.body, query = req.query, user = req.user})
+    % if render_utils.get_lua_codegen_version() <= 3:
+      err, rsp.body = self.route_mapper:match(req.path, '${method}', {body = req.body, query = req.query, user = req.user})
+    % else:
+      err, rsp.body = self.worker_ctrl:process(req.path, '${method}', {body = req.body, query = req.query, user = req.user})
+    % endif
   % endif
     if err and #err ~= 0 then
         local webrest_utils = require 'webrest_utils'
         return webrest_utils.parse_route_mapper_error(err)
     end
   % if method == 'patch':
-    _, rsp.body = self.worker_ctrl:process(req.path, 'get', {body = req.body, query = req.query, user = req.user})
+    % if render_utils.get_lua_codegen_version() <= 3:
+      _, rsp.body = self.route_mapper:match(req.path, 'get', {body = req.body, query = req.query, user = req.user})
+    % else:
+      _, rsp.body = self.worker_ctrl:process(req.path, 'get', {body = req.body, query = req.query, user = req.user})
+    % endif
   % endif
   % if method == 'post':
     if task_info then
@@ -213,7 +225,11 @@ function C${controller['name']}:on_${method}(req, rsp)
     err, rsp.body = redfish_utils.get_rsp_body(self, req)
   % else:
     local err, extra_info
-    err, rsp.body, extra_info = self.worker_ctrl:process(req.path, '${method}', {body = req.body, query = req.query, user = req.user})
+    % if render_utils.get_lua_codegen_version() <= 3:
+      err, rsp.body, extra_info = self.route_mapper:match(req.path, '${method}', {body = req.body, query = req.query, user = req.user})
+    % else:
+      err, rsp.body, extra_info = self.worker_ctrl:process(req.path, '${method}', {body = req.body, query = req.query, user = req.user})
+    % endif
   % endif
   % if method == 'post' or method == 'delete' or method == 'get':
     if err and #err ~= 0 then

bmcgo/codegen/lua/v1/script/gen_schema.py

@@ -0,0 +1,328 @@
+#!/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
+import re
+from collections import OrderedDict
+from bmcgo.codegen.lua.script.utils import Utils
+from bmcgo.utils.tools import Tools
+
+tool = Tools()
+log = tool.log
+MDS_REF = "$ref"
+MDS_DEFS = "defs"
+MDS_REF_INTERFACE = "refInterface"
+MDS_PATH = "path"
+MDS_PARENT = "parent"
+MDS_DEFINITIONS = "definitions"
+BASIC_TYPES = ["U8", "U16", "U32", "U64", "S16", "S32", "S64", "String", "Double", "Boolean"]
+RETAIN_ITEMS = ["description", "enum", "minimum", "maximum", "minLength", "maxLength", "pattern", "x-originalName",
+                "x-interface"]
+
+
+def no_need_filter(k):
+    filter_list = ["usage", "notAllowNull", "readOnly", "default", "primaryKey", "critical"]
+    return k not in filter_list
+
+
+def is_excluded_intf(intf):
+    return intf == "bmc.kepler.Object.Properties"
+
+
+def is_usage_csr(property_data):
+    return "usage" in property_data and "CSR" in property_data["usage"]
+
+
+def update_dictionary_type(key_data, value_data):
+    new_property_data = {}
+    if key_data["baseType"] == 'String':
+        new_property_data["^.*$"] = update_type(value_data)
+        return {"type": "object", "patternProperties": new_property_data}
+    else:
+        return {"type": "array", "items": {"$ref": "base.json#/definitions/S32"}}
+
+
+def update_array_type(property_data, base_type):
+    new_property_data = property_data.copy()
+    new_property_data["type"] = "array"
+    if base_type == "Array":
+        try:
+            new_property_data["items"][MDS_REF] = new_property_data["items"][MDS_REF] \
+                .replace(MDS_DEFS, MDS_DEFINITIONS).replace("types.json", "")
+        except Exception as e:
+            log.error(f"任务状态错误: {e}")
+            raise Exception(f"未找到{MDS_REF}") from e
+        return new_property_data
+
+    if "refInterface" in new_property_data:
+        ref_interface = new_property_data.pop("refInterface")
+        new_property_data["x-refInterface"] = ref_interface
+    new_property_data["items"] = {MDS_REF: "base.json#/definitions/" + base_type[:-2]}
+    return new_property_data
+
+
+def update_type(property_data):
+    new_property_data = {}
+    if not isinstance(property_data, dict):
+        return new_property_data
+
+    if "baseType" in property_data or "$ref" in property_data:
+        base_type = property_data.pop("baseType", "")
+        match = re.fullmatch(r'^(.+)(\[\])$', base_type)
+        if base_type == "Array" or (match and match.group(1) in BASIC_TYPES):
+            return update_array_type(property_data, base_type)
+
+        if MDS_REF_INTERFACE in property_data:
+            new_property_data[MDS_REF_INTERFACE] = property_data.pop(MDS_REF_INTERFACE, "")
+        
+        if base_type in BASIC_TYPES:
+            new_property_data[MDS_REF] = "base.json#/definitions/" + base_type
+        elif MDS_REF in property_data:
+            new_property_data[MDS_REF] = property_data[MDS_REF].replace(MDS_DEFS, MDS_DEFINITIONS) \
+                .replace("types.json", "")
+
+        for item in RETAIN_ITEMS:
+            if item in property_data:
+                new_property_data[item] = property_data[item]
+
+    return new_property_data
+
+
+def read_properties(intf_name, properties, out_properties, is_intf_props, usage_csr):
+    # properties only mark usage as C should deploy to csr schema
+    props = list(p for p, v in properties.items() if is_intf_props or is_usage_csr(v))
+    for index, prop in enumerate(props):
+        # filter properties which no need for csr
+        if is_usage_csr(properties[prop]) != usage_csr:
+            continue
+        prop_alias = prop
+        # if prop have alias, use alias name replace prop name
+        if "alias" in properties[prop]:
+            prop_alias = properties[prop].pop("alias", "")
+            properties[prop]["x-originalName"] = prop
+        if intf_name:
+            properties[prop]["x-interface"] = intf_name
+        out_properties[prop_alias] = {
+            k: v
+            for k, v in properties[prop].items()
+            if no_need_filter(k)
+        }
+
+        if prop_alias != prop:
+            out_properties[prop_alias] = update_type(out_properties[prop_alias])
+            props[index] = prop_alias
+        else:
+            out_properties[prop] = update_type(out_properties[prop])
+
+    return props
+
+
+def read_defs(structs, data):
+    for struct_name, struct_data in data[MDS_DEFS].items():
+        if struct_name in structs:
+            continue
+        properties = {k: v for k, v in struct_data.items()}
+        first_value = next(iter(struct_data.values()), None)
+        if isinstance(first_value, str) or isinstance(first_value, int):
+            structs[struct_name] = {"type": "string" if isinstance(first_value, str) else "integer",
+                                    "enum": list(struct_data.values())}
+            continue
+        if "key" in properties:
+            structs[struct_name] = update_dictionary_type(properties["key"], properties["value"])
+            continue
+        items = []
+        for _, prop_data in properties.items():
+            items.append(update_type(prop_data))
+        structs[struct_name] = {"type": "array", "items": items}
+
+
+def read_interfaces(interfaces, out_properties, structs, usage_csr):
+    intfs = {}
+    for intf_name, intf in interfaces.items():
+        # no properties also need interface name , because may be reference Object by other property for Devkit check
+        intfs[intf_name] = {}
+        if "properties" in intf:
+            props = read_properties(intf_name, intf["properties"], out_properties, not is_excluded_intf(intf_name),
+                                    usage_csr)
+            intfs[intf_name] = props
+        if MDS_DEFS in intf:
+            read_defs(structs, intf)
+    return intfs
+
+
+def save_csr_schema(of_name, csr_schema):
+    if os.path.exists(of_name):
+        with os.fdopen(os.open(of_name, os.O_RDONLY, stat.S_IRUSR), "r") as load_f:
+            if json.load(load_f) == csr_schema:
+                logging.info("schema 文件内容没有变更")
+                return
+
+    with os.fdopen(
+        os.open(
+            of_name, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, stat.S_IWUSR | stat.S_IRUSR
+        ),
+        "w", encoding="utf-8"
+    ) as load_f:
+        json.dump(csr_schema, load_f, ensure_ascii=False, indent=4)
+        logging.info("schema 已经发生改变")
+
+
+csr_schema_template = {
+    "$id": "CSR",
+    "$schema": "https://json-schema.org/draft/2019-09/schema#",
+    "x-version": "1.0",
+    "title": "CSR",
+    "description": "支持对CSR对象配置进行检查和校验",
+    "type": "object",
+    "patternProperties": {}
+}
+
+
+def replace_colon(path):
+    path = os.path.realpath(path) if (path[0:1] == "/") else path
+    paths = path.split("/")
+    maps = {}
+    for var in paths:
+        if var.startswith(":"):
+            maps[var] = var.replace(":", "${") + "}"
+    for old, new in maps.items():
+        path = path.replace(old, new)
+    return path
+
+
+def create_schema_class(interfaces, properties, non_csr_properties, class_data):
+    class_def = {"type": "object", "properties": properties, "x-publicProperties": non_csr_properties}
+    if MDS_PATH in class_data:
+        class_def["x-" + MDS_PATH] = replace_colon(class_data[MDS_PATH])
+    if MDS_PARENT in class_data:
+        class_def["x-" + MDS_PARENT] = class_data[MDS_PARENT]
+    class_def["additionalProperties"] = True
+    return class_def
+
+
+def count_dir_level(path):
+    level = 0
+    while True:
+        path = os.path.dirname(path)
+        if path == '/':
+            break
+        level += 1
+    return level
+
+
+def filling_material(load_dict, csr_schema):
+    for class_name, class_data in load_dict.items():
+        properties = {}
+        non_csr_properties = {}
+        interfaces = {}
+        if "interfaces" in class_data:
+            interfaces = read_interfaces(
+                class_data["interfaces"], properties, csr_schema[MDS_DEFINITIONS], True
+            )
+            _ = read_interfaces(
+                class_data["interfaces"], non_csr_properties, csr_schema[MDS_DEFINITIONS], False
+            )
+        if "properties" in class_data:
+            _ = read_properties(None, class_data["properties"], properties, False, True)
+            _ = read_properties(None, class_data["properties"], non_csr_properties, False, False)
+        if MDS_DEFS in class_data:
+            read_defs(csr_schema[MDS_DEFINITIONS], class_data)
+        # no properties means no properties mark usage C ,no need generic csr schema class
+        if properties:
+            csr_schema["patternProperties"]["^" + class_name + "_.+$"] = create_schema_class(
+                interfaces, properties, non_csr_properties, class_data
+            )
+    if MDS_DEFS in load_dict:
+        read_defs(csr_schema[MDS_DEFINITIONS], load_dict)
+
+
+def generate_schema(types_path, root, file, csr_schema):
+    file_path = os.path.join(root, file)
+    load_f = os.fdopen(os.open(file_path, os.O_RDONLY, stat.S_IRUSR), "r")
+    load_dict = json.load(load_f)
+    if os.path.exists(types_path):
+        load_f2 = os.fdopen(os.open(types_path, os.O_RDONLY, stat.S_IRUSR), "r")
+        load_dict2 = json.load(load_f2)
+        types_defs = {}
+        read_defs(types_defs, load_dict2)
+        csr_schema[MDS_DEFINITIONS].update(types_defs)
+
+    filling_material(load_dict, csr_schema)
+    load_f.close()
+
+
+def generate(types_path, if_name, of_name, project_name):   
+    if not os.path.exists(if_name):
+        return
+
+    # APP的目录层级是3，组件层级是4
+    pattern = re.compile(f'.*(/[^/]+/temp/{project_name}/.*)')
+    match = re.search(pattern, if_name)
+    path_level = 0
+    if match:
+        temp_model_path = match.group(1)
+        path_level = count_dir_level(temp_model_path)
+    dir_path = os.path.dirname(if_name)
+
+    if not (dir_path.endswith('test_gen_schema') or path_level == 3):
+        return
+
+    csr_schema = OrderedDict(csr_schema_template.copy())
+    csr_schema[MDS_DEFINITIONS] = {}
+    for root, _, files in os.walk(dir_path):
+        for file in files:
+            if file.endswith('_model.json'):
+                generate_schema(types_path, root, file, csr_schema)
+
+    save_csr_schema(of_name, csr_schema)
+
+
+
+def usage():
+    logging.info("gen_schema.py -i <inputfile> -o <outfile> -n <project_name>")
+
+
+def main(argv):
+    m_input = ""
+    output = ""
+    try:
+        opts, _ = getopt.getopt(argv, "ht:i:o:n:", ["help", "types_path=", "input=", "out=", "project_name="])
+    except getopt.GetoptError:
+        help()
+        return
+    for opt, arg in opts:
+        if opt in ("-h", "--help"):
+            usage()
+            return
+        elif opt in ("-t", "--types_path"):
+            m_types_path = arg
+        elif opt in ("-i", "--input"):
+            m_input = arg
+        elif opt in ("-o", "--out"):
+            output = arg
+        elif opt in ("-n", "--project_name"):
+            project_name = arg
+        else:
+            raise RuntimeError("不支持的选项: {}".format(opt))
+    if not m_input or not output:
+        usage()
+        return
+    generate(m_types_path, m_input, output, project_name)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])