lbkit 0.5.3__tar.gz → 0.5.5__tar.gz

{lbkit-0.5.3/lbkit.egg-info → lbkit-0.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lbkit
-Version: 0.5.3
+Version: 0.5.5
 Summary: Tools provided by litebmc.com
 Home-page: https://www.litebmc.com
 Author: xuhj@litebmc.com

lbkit-0.5.5/lbkit/__init__.py

@@ -0,0 +1,2 @@
+
+__version__ = '0.5.5'

{lbkit-0.5.3 → lbkit-0.5.5}/lbkit/codegen/codegen.py

@@ -16,6 +16,7 @@ from lbkit.misc import SmartFormatter
 lb_cwd = os.path.split(os.path.realpath(__file__))[0]
 log = Logger("codegen")
 
+__version__=1
 
 class CodeGen(object):
     def __init__(self, args):
@@ -66,7 +67,7 @@ class CodeGen(object):
                     sys.exit(-1)
                 outdir = cfg.get("outdir", os.getcwd())
                 self._gen(file, outdir)
-                return
+            return
 
         parser = argparse.ArgumentParser(description=self.run.__doc__,
                                          prog="lbkit gen",

{lbkit-0.5.3 → lbkit-0.5.5}/lbkit/codegen/idf_interface.py

@@ -66,7 +66,8 @@ STRU_NAME_REGEX = METHOD_NAME_REGEX
 ENUM_NAME_REGEX = METHOD_NAME_REGEX
 DICT_NAME_REGEX = METHOD_NAME_REGEX
 
-CTYPE_REGEX = "boolean|byte|int16|uint16|int32|uint32|int64|uint64|size|ssize|double|string|object_path|signature|unixfd|variant"
+CTYPE_BASE_REG = "boolean|byte|int16|uint16|int32|uint32|int64|uint64|size|ssize|double|string|object_path|signature|unixfd"
+CTYPE_REGEX = CTYPE_BASE_REG + "|variant"
 
 CTYPE_SIGNATURE_MAP = {
     "boolean": "b",
@@ -136,7 +137,7 @@ class IdfCtypeRender():
     def declare(self):
         """变量申明，用于结构体（接口类、方法请求和响应、信号消息等）申明"""
         log.debug(f"Get declare info, name: {self.name}, ctype: {self.ctype}")
-        match = re.match(f"^array\[({CTYPE_REGEX})\]$", self.ctype)
+        match = re.match(f"^array\[({CTYPE_BASE_REG})\]$", self.ctype)
         if match:
             ctype_obj = CTYPE_OBJS.get(self.ctype)
             return ctype_obj.declare
@@ -176,7 +177,7 @@ class IdfCtypeRender():
     def free_func(self):
         """生成释放数据的C函数，如果是结构体、字典需要生成对象的释放函数"""
         log.debug(f"Get free function info, name: {self.name}, ctype: {self.ctype}")
-        match = re.match(f"^array\[({CTYPE_REGEX})\]$", self.ctype)
+        match = re.match(f"^array\[({CTYPE_BASE_REG})\]$", self.ctype)
         if match:
             ctype_obj = CTYPE_OBJS.get(self.ctype)
             return ctype_obj.free_func
@@ -205,7 +206,7 @@ class IdfCtypeRender():
 
     def encode_func(self):
         log.debug(f"Get encode function info, name: {self.name}, ctype: {self.ctype}")
-        match = re.match(f"^array\[({CTYPE_REGEX})\]$", self.ctype)
+        match = re.match(f"^array\[({CTYPE_BASE_REG})\]$", self.ctype)
         if match:
             ctype_obj = CTYPE_OBJS.get(self.ctype)
             return ctype_obj.encode_func
@@ -238,7 +239,7 @@ class IdfCtypeRender():
 
     def decode_func(self):
         log.debug(f"Get decode info, name: {self.name}, ctype: {self.ctype}")
-        match = re.match(f"^array\[({CTYPE_REGEX})\]$", self.ctype)
+        match = re.match(f"^array\[({CTYPE_BASE_REG})\]$", self.ctype)
         if match:
             ctype_obj = CTYPE_OBJS.get(self.ctype)
             return ctype_obj.decode_func
@@ -268,6 +269,47 @@ class IdfCtypeRender():
             else:
                 return [f"<arg_in> = {stru_name}_decode(<arg_name>)"]
 
+    def odf_load_func(self):
+        log.debug(f"Get odf_load function, name: {self.name}, ctype: {self.ctype}")
+        # odf不支持gariant
+        match = re.match(f"^array\[(variant)\]$", self.ctype)
+        if match:
+            return None
+        match = re.match(f"^variant$", self.ctype)
+        if match:
+            return None
+        # 字符串数组由结束NULL表示，不需要长度
+        match = re.match(f"^array\[(string|object_path|signature)\]$", self.ctype)
+        if match:
+            return "<arg_name> = load_odf_as_" + match.group(1) + "_v(doc, <node>)"
+        match = re.match(f"^array\[({CTYPE_BASE_REG})\]$", self.ctype)
+        if match:
+            return "<arg_name> = load_odf_as_" + match.group(1) + "_v(doc, <node>, &n_<arg_name>)"
+        match = re.match(f"^({CTYPE_REGEX})$", self.ctype)
+        if match:
+            return "<arg_name> = load_odf_as_" + match.group(1) + "(doc, <node>)"
+        # 非基础类型
+        is_array = False
+        ctype = self.ctype
+        match = re.match(f"^array\[(.*)\]$", ctype)
+        if match:
+            is_array = True
+            ctype = match.group(1)
+        match = re.match(f"^(struct|enum|dict)\[(.*)\]$", ctype)
+        _, stru_name = get_intfname_and_ctype(match.group(2))
+        if match.group(1) == "enum":
+            if is_array:
+                # 入参为二级指针
+                return f"<arg_name> = _load_odf_as_{stru_name}_v(doc, <node>, &n_<arg_name>)"
+            else:
+                return f"<arg_name> = _load_odf_as_{stru_name}(doc, <node>)"
+        else:
+            if is_array:
+                # 入参为二级指针
+                return f"<arg_name> = _load_odf_as_{stru_name}_v(doc, <node>)"
+            else:
+                return f"<arg_name> = _load_odf_as_{stru_name}(doc, <node>)"
+
 class IdfProperty(IdfCtypeRender):
     def __init__(self, intf: IdfInterfaceBase, prop_data):
         self.intf = intf
@@ -278,8 +320,12 @@ class IdfProperty(IdfCtypeRender):
         self.annotations: list[IdfAnnotation] = []
         self.description = prop_data.get("description", "")
         flags = prop_data.get("flags", "").split(",")
+        self.flags = flags
         self.private = True if ("private" in flags) else False
         self.deprecated = True if ("deprecated" in flags) else False
+        # refobj的ctype只能是s或as
+        if "refobj" in flags and self.ctype != "string" and self.ctype != "array[string]":
+                raise IDFException(f"property {self.name} with refobj flag but type is neither s nor as")
         for k, v in ACCESS_MAP.items():
             if k in flags:
                 self.access = v

{lbkit-0.5.3 → lbkit-0.5.5}/lbkit/codegen/template/public.c.mako

@@ -140,6 +140,14 @@ static const gchar *_${name}StrMap[] = {
 % endfor
 };
 
+const gchar *${name}_as_string(${name} value)
+{
+    if (value >= _${name}Invalid) {
+        return "com.litebmc.Errors.Enum.Invalid";
+    }
+    return _${name}StrMap[value];
+}
+
 /* ${name}枚举类型序列化（enum转string）函数 */
 GVariant *${name}_encode(${name} value)
 {
@@ -165,6 +173,7 @@ ${name} ${name}_decode(GVariant *in)
     }
     return _${name}Invalid;
 }
+
 /* ${name}枚举类型序列化（enum转string）函数 */
 GVariant *${name}_encode_v(const ${name} *values, gsize n)
 {

{lbkit-0.5.3 → lbkit-0.5.5}/lbkit/codegen/template/public.h.mako

@@ -50,6 +50,8 @@ enum _${name} {
     _${name}Invalid,
 };
 
+const gchar *${name}_as_string(${name} value);
+
 % endfor
 % for name, dictionary in intf.dictionaries.items():
 
@@ -82,7 +84,7 @@ ${name} *${name}_new(void);
 
 ## 定义结构体编解码和释放函数
 % for name, stru in intf.structures.items():
-/* ${name} dictionary object */
+/* ${name} structure object */
 /* START: 结构体${name}及其数组类型的序列化、反序列化、释放函数 */
 GVariant *${name}_encode(const ${name} *value);
 ${name} *${name}_decode(GVariant *in);

lbkit-0.5.5/lbkit/codegen/template/server.c.mako

@@ -0,0 +1,357 @@
+#include "gcl_base.h"
+#include "${intf.name}.h"
+
+<%
+class_name = intf.alias
+properties = "_" + class_name + "_properties"
+signal_processer = "_" + class_name + "_signals"
+%>\
+## 定义结构体ODF加载函数
+% for name, stru in intf.structures.items():
+/* ${name} structure object */
+/* START: 结构体${name}及其数组类型的ODF加载函数 */
+${name} *_load_odf_as_${name}(yaml_document_t *doc, yaml_node_t *node);
+${name} **_load_odf_as_${name}_v(yaml_document_t *doc, yaml_node_t *node);
+
+% endfor
+## 定义枚举ODF加载函数
+% for name, enum in intf.enumerations.items():
+/* START: 枚举${name}及其数组类型的ODF加载函数 */
+${name} _load_odf_as_${name}(yaml_document_t *doc, yaml_node_t *node);
+${name} *_load_odf_as_${name}_v(yaml_document_t *doc, yaml_node_t *node, gsize *n);
+
+% endfor
+## 定义字典ODF加载函数
+% for name, dictionary in intf.dictionaries.items():
+/* START: 字典${name}及其数组类型的ODF加载函数 */
+${name} *_load_odf_as_${name}(yaml_document_t *doc, yaml_node_t *node);
+${name} **_load_odf_as_${name}_v(yaml_document_t *doc, yaml_node_t *node);
+
+% endfor
+## 定义结构体ODF加载函数
+% for name, stru in intf.structures.items():
+/* ${name} structure object */
+/* START: 结构体${name}及其数组类型的ODF加载函数 */
+
+${name} *_load_odf_as_${name}(yaml_document_t *doc, yaml_node_t *node)
+{
+<% cnt = 0 %>\
+    % for prop in stru.values.parameters:
+        % if prop.odf_load_func() is not None:
+<% cnt = cnt + 1 %>\
+        % endif
+    % endfor
+% if cnt == 0:
+    return g_new0(${name}, 1);
+% else:
+    yaml_node_t *val;
+    ${name} *output = g_new0(${name}, 1);
+    GHashTable *prop_table = load_yaml_mapping_to_hash_table(doc, node);
+    % for prop in stru.values.parameters:
+        % if prop.odf_load_func() is not None:
+    /* process ${prop.name} */
+    val = g_hash_table_lookup(prop_table, "${prop.name}");
+    if (val)
+        ${prop.odf_load_func().replace("n_<arg_name>", "output->n_" + prop.name).replace("<arg_name>", "output->" + prop.name).replace("<node>", "val")};
+        % endif
+    % endfor
+
+    g_hash_table_destroy(prop_table);
+    return output;
+% endif
+}
+
+${name} **_load_odf_as_${name}_v(yaml_document_t *doc, yaml_node_t *node)
+{
+    yaml_node_t *val;
+    gint i = 0;
+    if (node->type != YAML_SEQUENCE_NODE) {
+        log_warn("Load array ${name} failed because node type error, need type 1(sequence), get type %d", node->type);
+        return g_new0(${name} *, 1);
+    }
+    yaml_node_item_t *top = node->data.sequence.items.top;
+    yaml_node_item_t *start = node->data.sequence.items.start;
+    gsize cnt = ((gsize)top - (gsize)start) / sizeof(yaml_node_item_t);
+    ${name} **output = g_new0(${name} *, cnt + 1);
+
+    for (yaml_node_item_t *item = start; item < top; item++) {
+        val = yaml_document_get_node(doc, *item);
+        output[i++] = _load_odf_as_${name}(doc, val);
+    }
+    return output;
+}
+
+% endfor
+## 定义枚举ODF加载函数
+% for name, enum in intf.enumerations.items():
+
+${name} _load_odf_as_${name}(yaml_document_t *doc, yaml_node_t *node)
+{
+    g_assert(node->type == YAML_SCALAR_NODE);
+    if (node->type != YAML_SCALAR_NODE) {
+        return _${name}Invalid;
+    }
+
+    for (int i = 0; i <= ${len(enum.values.parameters)}; i++) {
+        if (g_strcmp0(node->data.scalar.value, ${name}_as_string(i)) == 0) {
+            return (${name})i;
+        }
+    }
+    return _${name}Invalid;
+}
+
+${name} *_load_odf_as_${name}_v(yaml_document_t *doc, yaml_node_t *node, gsize *n)
+{
+    g_assert(doc && node && n);
+    yaml_node_t *val;
+    gint i = 0;
+    if (node->type != YAML_SEQUENCE_NODE) {
+        log_warn("Load array ${name} failed because node type error, need type 1(sequence), get type %d", node->type);
+        return g_new0(${name}, 1);
+    }
+    yaml_node_item_t *top = node->data.sequence.items.top;
+    yaml_node_item_t *start = node->data.sequence.items.start;
+    *n = ((gsize)top - (gsize)start) / sizeof(yaml_node_item_t);
+    ${name} *output = g_new0(${name}, *n);
+
+    for (yaml_node_item_t *item = start; item < top; item++) {
+        val = yaml_document_get_node(doc, *item);
+        output[i++] = _load_odf_as_${name}(doc, val);
+    }
+    return output;
+}
+
+% endfor
+## 定义字典ODF加载函数
+% for name, dictionary in intf.dictionaries.items():
+
+${name} *_load_odf_as_${name}(yaml_document_t *doc, yaml_node_t *node)
+{
+    GHashTable *prop_table = NULL;
+    yaml_node_t *val = NULL;
+    ${name} *dict = ${name}_new();
+    yaml_node_item_t *top = node->data.sequence.items.top;
+    yaml_node_item_t *start = node->data.sequence.items.start;
+    for (yaml_node_item_t *item = start; item < top; item++) {
+        val = yaml_document_get_node(doc, *item);
+        ## 转换成hash表以获取key和properties
+        prop_table = load_yaml_mapping_to_hash_table(doc, val);
+        yaml_node_t *key = g_hash_table_lookup(prop_table, "key");
+        yaml_node_t *properties = g_hash_table_lookup(prop_table, "properties");
+        g_hash_table_destroy(prop_table);
+
+        ${", ".join(dictionary.key_obj.declare()).replace("<arg_name>", "key_val").replace("<const>", "")};
+        ${dictionary.key_obj.odf_load_func().replace("<arg_name>", "key_val").replace("<node>", "key")};
+
+        ## 创建一个新的字典成员
+        ${name}${dictionary.key} *item = g_new0(${name}${dictionary.key}, 1);
+        ## 转换成hash表
+        prop_table = load_yaml_mapping_to_hash_table(doc, properties);
+        ## 迭代所有成员并从odf中还原数据
+        % for prop in dictionary.values.parameters:
+            % if prop.odf_load_func() is not None:
+        val = g_hash_table_lookup(prop_table, "${prop.name}");
+        if (val)
+            ${prop.odf_load_func().replace("n_<arg_name>", "item->n_" + prop.name).replace("<arg_name>", "item->" + prop.name).replace("<node>", "val")};
+            % endif
+        % endfor
+        g_hash_table_destroy(prop_table);
+        dict->insert(dict, key_val, &item);
+        % for line in dictionary.key_obj.free_func():
+        ${line.replace("<arg_name>", "key_val")};
+        % endfor
+    }
+    return dict;
+}
+
+${name} **_load_odf_as_${name}_v(yaml_document_t *doc, yaml_node_t *node)
+{
+    yaml_node_t *val;
+    gint i = 0;
+    if (node->type != YAML_SEQUENCE_NODE) {
+        log_warn("Load array ${name} failed because node type error, need type 1(sequence), get type %d", node->type);
+        return g_new0(${name} *, 1);
+    }
+    yaml_node_item_t *top = node->data.sequence.items.top;
+    yaml_node_item_t *start = node->data.sequence.items.start;
+    gsize cnt = ((gsize)top - (gsize)start) / sizeof(yaml_node_item_t);
+    ${name} **output = g_new0(${name} *, cnt + 1);
+
+    for (yaml_node_item_t *item = start; item < top; item++) {
+        val = yaml_document_get_node(doc, *item);
+        output[i++] = _load_odf_as_${name}(doc, val);
+    }
+    return output;
+}
+
+% endfor
+static ${class_name}_Properties ${properties};
+static const ${class_name}_Signals *${signal_processer} = NULL;
+
+% for prop in intf.properties:
+/* ${prop.description} */
+    % if prop.deprecated:
+__attribute__((__deprecated__)) void ${class_name}_set_${prop.name}(const ${class_name} *object,
+    ${", ".join(prop.declare()).replace("<arg_name>", "value").replace("<const>", "const ")})
+    % else:
+void ${class_name}_set_${prop.name}(const ${class_name} *object,
+    ${", ".join(prop.declare()).replace("<arg_name>", "value").replace("<const>", "const ")})
+    % endif
+{
+    GVariant *tmp = NULL;
+    % for line in prop.encode_func():
+    ${line.replace("<arg_out>", "tmp").replace("n_<arg_name>", "n_value").replace("<arg_name>", "value")};
+    % endfor
+    gcl_set_value((GclObject *)object, &_${class_name}_properties.${prop.name}, tmp);
+    g_variant_unref(tmp);
+}
+
+% endfor
+% for signal in intf.signals:
+/*
+ * Signal: ${signal.name}
+ * ${signal.description}
+ */
+    % if signal.deprecated:
+__attribute__((__deprecated__)) gboolean ${class_name}_${signal.name}_Signal(const ${class_name} *object,
+    const gchar *destination, const ${class_name}_${signal.name}_Msg *msg, GError **error)
+    % else:
+gboolean ${class_name}_${signal.name}_Signal(const ${class_name} *object, const gchar *destination,
+    const ${class_name}_${signal.name}_Msg *msg, GError **error)
+    % endif
+{
+    if (error == NULL) {
+        log_error("Emit ${signal.name} with parameter error, error is NULL");
+        return FALSE;
+    }
+    if (object == NULL) {
+        *error = g_error_new(G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Emit ${signal.name} with parameter error, object is NULL");
+        return FALSE;
+    }
+    return gcl_impl.emit_signal((GclObject *)object, destination,
+        (const GclSignal *)&${signal_processer}->${signal.name}, msg, error);
+}
+
+% endfor
+static GclObject *_${class_name}_create(const gchar *obj_name, gpointer opaque);
+static void _load_from_odf(yaml_document_t *doc, yaml_node_t *node, GclObject *gcl_obj,
+    property_reference_loaded ref_loaded, gpointer user_data);
+/*
+ * interface: ${intf.name}
+% for c in intf.description.split("\n"):
+ * ${c}
+% endfor
+ */
+static GclInterface _${class_name}_interface = {
+    .create = _${intf.alias}_create,
+    .load_from_odf = (object_load_from_odf)_load_from_odf,
+    .is_remote = 0,
+    .name = "${intf.name}",
+    .properties = (GclProperty *)&${properties},
+    .interface = NULL,  /* load from usr/share/dbus-1/interfaces/${intf.name} by gcl_init */
+};
+
+% for prop in intf.properties:
+static void _load_odf_as_prop_${prop.name}(yaml_document_t *doc, GHashTable *prop_table,
+    ${class_name} *obj, property_reference_loaded ref_loaded, gpointer user_data)
+{
+    const gchar *flags = NULL;
+    yaml_node_t *val = g_hash_table_lookup(prop_table, "_${prop.name}_flags");
+    if (val && val->type == YAML_SCALAR_NODE) {
+        flags = val->data.scalar.value;
+    }
+    val = g_hash_table_lookup(prop_table, "${prop.name}");
+    if (!val) {
+        if (flags) {
+            ref_loaded(obj, &${properties}.${prop.name}, NULL, NULL, user_data, flags);
+        }
+        return;
+    }
+    % if "refobj" in prop.flags:
+    ref_loaded(obj, &${properties}.${prop.name}, doc, val, user_data, flags);
+    % else:
+    if (val->type == YAML_SCALAR_NODE && val->data.scalar.value[0] == '$' &&
+        g_regex_match(gcl_ref_prop_regex(), val->data.scalar.value, 0, NULL)) {
+        ref_loaded(obj, &${properties}.${prop.name}, doc, val, user_data, flags);
+    } else {
+        % if prop.odf_load_func() is not None:
+        ${prop.odf_load_func().replace("n_<arg_name>", "obj->n_" + prop.name).replace("<arg_name>", "obj->" + prop.name).replace("<node>", "val")};
+        % endif
+        if (flags) {
+            ref_loaded(obj, &${properties}.${prop.name}, NULL, NULL, user_data, flags);
+        }
+    }
+    % endif
+}
+
+% endfor
+static void _load_from_odf(yaml_document_t *doc, yaml_node_t *node, GclObject *gcl_obj,
+    property_reference_loaded ref_loaded, gpointer user_data)
+{
+    g_assert(doc && node && gcl_obj);
+    if (!gcl_obj) {
+        return;
+    }
+<% cnt = 0 %>\
+    % for prop in intf.properties:
+        % if prop.odf_load_func() is not None:
+<% cnt = cnt + 1 %>\
+        % endif
+    % endfor
+% if cnt == 0:
+    return;
+% else:
+    ${class_name} *obj = (${class_name} *)gcl_obj;
+    ${class_name}_clean(obj);
+    GHashTable *prop_table = load_yaml_mapping_to_hash_table(doc, node);
+    % for prop in intf.properties:
+    _load_odf_as_prop_${prop.name}(doc, prop_table, obj, ref_loaded, user_data);
+    % endfor
+
+    g_hash_table_destroy(prop_table);
+% endif
+}
+
+/**
+ * @brief 分配对象
+ *
+ * @param obj_name 对象名，需要由调用者分配内存
+ * @param opaque 上层应用需要写入对象的用户数据，由上层应用使用
+ */
+GclObject *_${class_name}_create(const gchar *obj_name, gpointer opaque)
+{
+    ${class_name} *obj = g_new0(${class_name}, 1);
+    memcpy(obj->_base.magic, GCL_MAGIC, strlen(GCL_MAGIC) + 1);
+    obj->_base.lock = g_new0(GRecMutex, 1);
+    g_rec_mutex_init(obj->_base.lock);
+    obj->_base.name = obj_name;
+    obj->_base.intf = &_${class_name}_interface;
+    obj->_base.opaque = opaque;
+    return (GclObject *)obj;
+}
+
+GclInterface *${class_name}_interface(void)
+{
+    return &_${class_name}_interface;
+}
+
+${class_name}_Properties *${class_name}_properties(void)
+{
+    return &${properties};
+}
+
+static void __attribute__((constructor(150))) ${class_name}_register(void)
+{
+
+    // 从公共库中复制信号处理函数
+    ${signal_processer} = ${class_name}_signals();
+    // 从公共库中复制方法处理函数
+    _${class_name}_interface.methods = (GclMethod *)${class_name}_methods();
+    _${class_name}_interface.signals = (GclSignal *)${class_name}_signals();
+
+    // 从公共库中复制属性信息
+    memcpy(&${properties}, ${class_name}_properties_const(), sizeof(${properties}));
+    gcl_interface_register(&_${class_name}_interface,
+                           "${intf.introspect_xml_sha256}",
+                           "/usr/share/dbus-1/interfaces/${intf.name}.xml");
+}

{lbkit-0.5.3 → lbkit-0.5.5}/lbkit/component/build.py

@@ -53,6 +53,7 @@ class BuildComponent():
         shutil.rmtree(self.rootfs_dir, ignore_errors=True)
         os.makedirs(self.rootfs_dir, exist_ok=True)
 
+        self.pkg = None
         self.gen_conaninfo()
         self.base_cmd = f" --user {self.user} --channel {self.channel}"
         self.base_cmd += f" -pr {self.profile} -s build_type={self.build_type} -r " + self.options.remote
@@ -108,6 +109,7 @@ class BuildComponent():
         # 构建命令未指定channel时从package.yml中读取
         pkg["channel"] = self.channel
         pkg["version"] = self.get_package_version()
+        self.pkg = pkg
         # 从package.yml加载基础信息
         self.name = pkg.get("name")
         self.version = pkg.get("version")
@@ -156,7 +158,7 @@ class BuildComponent():
         # 生成部署deploy命令
         lookup = TemplateLookup(directories=os.path.join(lb_cwd, "template"))
         template = lookup.get_template("deploy.mako")
-        deploy = template.render(lookup=lookup, packages=self.runtime_packages)
+        deploy = template.render(lookup=lookup, pkg=self.pkg, packages=self.runtime_packages)
         dir = os.path.join(cwd, ".temp", "deploy")
         # 创建临时目录并写入conanfile.py文件
         os.makedirs(dir, exist_ok=True)
@@ -178,7 +180,7 @@ class BuildComponent():
         template = lookup.get_template("deploy.mako")
         packages = self.runtime_packages
         packages.append(self.package)
-        deploy = template.render(lookup=lookup, packages=packages)
+        deploy = template.render(lookup=lookup, pkg=self.pkg, packages=packages)
         dir = os.path.join(cwd, ".temp", "deploy")
         # 创建临时目录并写入conanfile.py文件
         os.makedirs(dir, exist_ok=True)
@@ -202,7 +204,24 @@ class BuildComponent():
         # 设置ROOTFS_DIR环境变量，为DT测试提供相对路径
         os.environ["ROOTFS_DIR"] = self.rootfs_dir
 
+    def _validate_odf_files(self):
+        odf_dirs = self.pkg.get("odf_dirs", [])
+        for dir in odf_dirs:
+            for filename in os.listdir(dir):
+                filename = os.path.join(dir, filename)
+                if not os.path.isfile(filename):
+                    continue
+                if not filename.endswith(".yaml"):
+                    log.debug(f"file {filename} not endswith .yaml, skip validate")
+                    continue
+
+                log.info(f"start validate {filename}")
+                validate_yml_with_json_schema(filename, "/usr/share/litebmc/schema/odf.v1.json")
+
     def run(self):
+        # start validate all odf(Object Description file) files
+        self._validate_odf_files()
+
         cmd = f"conan remove {self.package} -c"
         tools.exec(cmd)
         gen = CodeGen([])

{lbkit-0.5.3 → lbkit-0.5.5}/lbkit/component/template/conanbase.mako

@@ -114,6 +114,28 @@ class LiteBmcConan(ConanFile):
 % endif
         pass
 
+    def configure(self):
+% if len(pkg.get("requires", {})) > 0:
+    % for conan in pkg["requires"].get("compile", []):
+        % if conan.get("option") is not None:
+            % for k, v in conan.get("option").items():
+        self.options["${conan.get("conan").split("/")[0]}"].${k} = ${("\"" + v + "\"") if isinstance(v, str) else str(v)}
+            % endfor
+        % endif
+    % endfor
+<%test_requires=pkg["requires"].get("test", [])%>\
+    % if len(test_requires):
+        % for conan in test_requires:
+            % if conan.get("option") is not None:
+                % for k, v in conan.get("option").items():
+        self.options["${conan.get("conan").split("/")[0]}"].${k} = ${("\"" + v + "\"") if isinstance(v, str) else str(v)}
+                % endfor
+            % endif
+        % endfor
+    % endif
+% endif
+        pass
+
     def _append_default_flags(self):
         flags = []
         if self.options.gcov:

lbkit-0.5.5/lbkit/component/template/deploy.mako

@@ -0,0 +1,42 @@
+from conan import ConanFile
+
+
+class DeployConan(ConanFile):
+    name = "deploy"
+    settings = "os", "arch", "compiler", "build_type"
+    description = "部署组件"
+    url = "https://litebmc.com"
+    homepage = ""
+    generators = "CMakeDeps"
+    package_type = "application"
+    version = "0.0.1"
+    license = "MulanPSL v2"
+
+    def requirements(self):
+    % for package in packages:
+        self.requires("${package}")
+    % endfor
+        pass
+
+    def configure(self):
+% if len(pkg.get("requires", {})) > 0:
+    % for conan in pkg["requires"].get("compile", []):
+        % if conan.get("option") is not None:
+            % for k, v in conan.get("option").items():
+        self.options["${conan.get("conan").split("/")[0]}"].${k} = ${("\"" + v + "\"") if isinstance(v, str) else str(v)}
+            % endfor
+        % endif
+    % endfor
+<%test_requires=pkg["requires"].get("test", [])%>\
+    % if len(test_requires):
+        % for conan in test_requires:
+            % if conan.get("option") is not None:
+                % for k, v in conan.get("option").items():
+        self.options["${conan.get("conan").split("/")[0]}"].${k} = ${("\"" + v + "\"") if isinstance(v, str) else str(v)}
+                % endfor
+            % endif
+        % endfor
+    % endif
+% endif
+        pass
+

{lbkit-0.5.3 → lbkit-0.5.5}/lbkit/misc.py

@@ -78,4 +78,6 @@ def validate_yml_with_json_schema(yml_file, default_json_schema_file):
         data = yaml.safe_load(fp)
         validate(data, schema)
     except ValidationError as exc:
-        raise PackageConfigException(f"validate {yml_file} failed, schema file is {schema_file}, message: {exc.message}")
+        raise PackageConfigException(f"validate {yml_file} failed, schema file is {schema_file}, "
+                                     f"message: {exc.message}\n"
+                                     "installing redhat.vscode-yaml plugin in vscode will help you write odf files")

{lbkit-0.5.3 → lbkit-0.5.5/lbkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lbkit
-Version: 0.5.3
+Version: 0.5.5
 Summary: Tools provided by litebmc.com
 Home-page: https://www.litebmc.com
 Author: xuhj@litebmc.com

lbkit-0.5.3/lbkit/__init__.py

@@ -1,2 +0,0 @@
-
-__version__ = '0.5.3'

lbkit-0.5.3/lbkit/codegen/template/server.c.mako

@@ -1,113 +0,0 @@
-#include "gcl_base.h"
-#include "${intf.name}.h"
-
-<%
-class_name = intf.alias
-properties = "_" + class_name + "_properties"
-signal_processer = "_" + class_name + "_signals"
-%>\
-static ${class_name}_Properties ${properties};
-static const ${class_name}_Signals *${signal_processer} = NULL;
-
-% for prop in intf.properties:
-/* ${prop.description} */
-    % if prop.deprecated:
-__attribute__((__deprecated__)) void ${class_name}_set_${prop.name}(const ${class_name} *object,
-    ${", ".join(prop.declare()).replace("<arg_name>", "value").replace("<const>", "const ")})
-    % else:
-void ${class_name}_set_${prop.name}(const ${class_name} *object,
-    ${", ".join(prop.declare()).replace("<arg_name>", "value").replace("<const>", "const ")})
-    % endif
-{
-    GVariant *tmp = NULL;
-    % for line in prop.encode_func():
-    ${line.replace("<arg_out>", "tmp").replace("n_<arg_name>", "n_value").replace("<arg_name>", "value")};
-    % endfor
-    gcl_set_value((GclObject *)object, &_${class_name}_properties.${prop.name}, tmp);
-    g_variant_unref(tmp);
-}
-
-% endfor
-% for signal in intf.signals:
-/*
- * Signal: ${signal.name}
- * ${signal.description}
- */
-    % if signal.deprecated:
-__attribute__((__deprecated__)) gboolean ${class_name}_${signal.name}_Signal(const ${class_name} *object,
-    const gchar *destination, const ${class_name}_${signal.name}_Msg *msg, GError **error)
-    % else:
-gboolean ${class_name}_${signal.name}_Signal(const ${class_name} *object, const gchar *destination,
-    const ${class_name}_${signal.name}_Msg *msg, GError **error)
-    % endif
-{
-    if (error == NULL) {
-        log_error("Emit ${signal.name} with parameter error, error is NULL");
-        return FALSE;
-    }
-    if (object == NULL) {
-        *error = g_error_new(G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Emit ${signal.name} with parameter error, object is NULL");
-        return FALSE;
-    }
-    return gcl_impl.emit_signal((GclObject *)object, destination,
-        (const GclSignal *)&${signal_processer}->${signal.name}, msg, error);
-}
-
-% endfor
-static GclObject *_${class_name}_create(const gchar *obj_name, gpointer opaque);
-/*
- * interface: ${intf.name}
-% for c in intf.description.split("\n"):
- * ${c}
-% endfor
- */
-static GclInterface _${class_name}_interface = {
-    .create = _${intf.alias}_create,
-    .is_remote = 0,
-    .name = "${intf.name}",
-    .properties = (GclProperty *)&${properties},
-    .interface = NULL,  /* load from usr/share/dbus-1/interfaces/${intf.name} by gcl_init */
-};
-
-/**
- * @brief 分配对象
- *
- * @param obj_name 对象名，需要由调用者分配内存
- * @param opaque 上层应用需要写入对象的用户数据，由上层应用使用
- */
-GclObject *_${class_name}_create(const gchar *obj_name, gpointer opaque)
-{
-    ${class_name} *obj = g_new0(${class_name}, 1);
-    memcpy(obj->_base.magic, GCL_MAGIC, strlen(GCL_MAGIC) + 1);
-    obj->_base.lock = g_new0(GRecMutex, 1);
-    g_rec_mutex_init(obj->_base.lock);
-    obj->_base.name = obj_name;
-    obj->_base.intf = &_${class_name}_interface;
-    obj->_base.opaque = opaque;
-    return (GclObject *)obj;
-}
-
-GclInterface *${class_name}_interface(void)
-{
-    return &_${class_name}_interface;
-}
-
-${class_name}_Properties *${class_name}_properties(void)
-{
-    return &${properties};
-}
-
-static void __attribute__((constructor(150))) ${class_name}_register(void)
-{
-    // 从公共库中复制信号处理函数
-    ${signal_processer} = ${class_name}_signals();
-    // 从公共库中复制方法处理函数
-    _${class_name}_interface.methods = (GclMethod *)${class_name}_methods();
-    _${class_name}_interface.signals = (GclSignal *)${class_name}_signals();
-
-    // 从公共库中复制属性信息
-    memcpy(&${properties}, ${class_name}_properties_const(), sizeof(${properties}));
-    gcl_interface_register(&_${class_name}_interface,
-                           "${intf.introspect_xml_sha256}",
-                           "/usr/share/dbus-1/interfaces/${intf.name}.xml");
-}

lbkit-0.5.3/lbkit/component/template/deploy.mako

@@ -1,20 +0,0 @@
-from conan import ConanFile
-
-
-class DeployConan(ConanFile):
-    name = "deploy"
-    settings = "os", "arch", "compiler", "build_type"
-    description = "部署组件"
-    url = "https://litebmc.com"
-    homepage = ""
-    generators = "CMakeDeps"
-    package_type = "application"
-    version = "0.0.1"
-    license = "MulanPSL v2"
-
-    def requirements(self):
-    % for package in packages:
-        self.requires("${package}")
-    % endfor
-        pass
-