lbkit 0.8.6__tar.gz → 0.8.8__tar.gz

{lbkit-0.8.6/lbkit.egg-info → lbkit-0.8.8}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: lbkit
-Version: 0.8.6
+Version: 0.8.8
 Summary: Tools provided by litebmc.com
 Home-page: https://www.litebmc.com
 Author: xuhj@litebmc.com
@@ -21,12 +21,14 @@ Requires-Dist: requests
 Requires-Dist: gitpython
 Requires-Dist: inflection
 Requires-Dist: meson>=1.4.0
+Requires-Dist: psutil
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: summary
 

lbkit-0.8.8/lbkit/__init__.py

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

{lbkit-0.8.6 → lbkit-0.8.8}/lbkit/cli.py

@@ -79,6 +79,8 @@ class Command(object):
         """
         env = EnvDetector()
         if env.component:
+            os.chdir(env.component.folder)
+            print(os.getcwd())
             arg_parser = ArgParser.new()
             build = BuildComponent(arg_parser, sys.argv[2:])
             build.run()
@@ -101,6 +103,10 @@ class Command(object):
 
         组件DT用例执行
         """
+        env = EnvDetector()
+        if not env.component:
+            raise Exception("The metadata/package.yml file was not detected, not a valid litebmc component.")
+        os.chdir(env.component.folder)
         argv = sys.argv[2:]
         build = TestComponent(argv)
         build.run()
@@ -239,11 +245,9 @@ def main(args):
     shutil.rmtree(misc.LOG_DIR, ignore_errors=True)
     os.makedirs(misc.LOG_DIR, exist_ok=True)
     def ctrl_c_handler(_, __):
-        print('You pressed Ctrl+C!')
         sys.exit(-3)
 
     def sigterm_handler(_, __):
-        print('Received SIGTERM!')
         sys.exit(-4)
 
     signal.signal(signal.SIGINT, ctrl_c_handler)

{lbkit-0.8.6 → lbkit-0.8.8}/lbkit/codegen/codegen.py

@@ -67,8 +67,9 @@ history_versions = {
     "5.0": CodeGenHistory("lb_base/[>=0.8.1 <0.9.0]", "简化接口类名定义;简化枚举变量在接口间传递时的字符串定义", "0"),
     "5.1": CodeGenHistory("lb_base/[>=0.8.3 <0.9.0]", "方法和信号添加保留字段用于功能扩展，同时设置请求和响应为空标志位", "8002"),
     "5.2": CodeGenHistory("lb_base/[>=0.8.4 <0.9.0]", "支持校验数值边界、字符串正则以及数组匹配等规则", "8004"),
+    "5.3": CodeGenHistory("lb_base/[>=0.8.5 <0.9.0]", "支持32位操作系统", "8004"),
 }
-__version__=Version("5.1")
+__version__=Version("5.3")
 
 
 def version_check(ver_str: str):

{lbkit-0.8.6 → lbkit-0.8.8}/lbkit/codegen/ctype_defination.py

@@ -93,9 +93,9 @@ class IdfValidator():
             val_str = f"static const gchar *_items[] = {{"
             val_str += '"' + '", "'.join(self.matches) + '", NULL'
         else:
-            if self.ctype in ["int16", "int32", "int64"]:
+            if self.ctype in ["int16", "int32", "int64", "ssize"]:
                 val_str = f"static gint64 _items[] = {{"
-            elif self.ctype in ["uint8", "uint16", "uint32", "uint64"]:
+            elif self.ctype in ["uint8", "uint16", "uint32", "uint64", "size"]:
                 val_str = f"static guint64 _items[] = {{"
             elif self.ctype in ["double"]:
                 val_str = f"static gdouble _items[] = {{"
@@ -784,17 +784,17 @@ CTYPE_OBJS = {
         ["gsize <arg_name>"],
         ["gsize *<arg_name>"],
         [],
-        ["<arg_out> = g_variant_new_uint64(<arg_name>)"],
-        ["<arg_in> = g_variant_get_uint64(<arg_name>)"],
-        IntegerValidator("uint64", 0xffff_ffff_ffff_ffff, 0)
+        ["<arg_out> = g_variant_new_tsize(<arg_name>)"],
+        ["<arg_in> = g_variant_get_tsize(<arg_name>)"],
+        IntegerValidator("size", 0xffff_ffff_ffff_ffff, 0)
     ),
     "ssize": CTypeBase(
         ["gssize <arg_name>"],
         ["gssize *<arg_name>"],
         [],
-        ["<arg_out> = g_variant_new_int64(<arg_name>)"],
-        ["<arg_in> = g_variant_get_int64(<arg_name>)"],
-        IntegerValidator("int64", 0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True)
+        ["<arg_out> = g_variant_new_tssize(<arg_name>)"],
+        ["<arg_in> = g_variant_get_tssize(<arg_name>)"],
+        IntegerValidator("ssize", 0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True)
     ),
     "double": CTypeBase(
         ["gdouble <arg_name>"],
@@ -921,17 +921,17 @@ CTYPE_OBJS = {
         ["gsize n_<arg_name>" ,"<const>gssize *<arg_name>"],
         ["gsize *n_<arg_name>" ,"gssize **<arg_name>"],
         ["lb_free_p((void **)&<arg_name>)"],
-        ["<arg_out> = lb_array_int64_encode(<arg_name>, n_<arg_name>)"],
-        ["<arg_in> = lb_array_int64_decode(<arg_name>, &n_<arg_in>)"],
-        IntegerArrayValidator("int64",0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True)
+        ["<arg_out> = lb_array_ssize_encode(<arg_name>, n_<arg_name>)"],
+        ["<arg_in> = lb_array_ssize_decode(<arg_name>, &n_<arg_in>)"],
+        IntegerArrayValidator("ssize",0x7fff_ffff_ffff_ffff, -(0x8000_0000_0000_0000), True)
     ),
     "array[size]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>gsize *<arg_name>"],
         ["gsize *n_<arg_name>" ,"gsize **<arg_name>"],
         ["lb_free_p((void **)&<arg_name>)"],
-        ["<arg_out> = lb_array_uint64_encode(<arg_name>, n_<arg_name>)"],
-        ["<arg_in> = lb_array_uint64_decode(<arg_name>, &n_<arg_in>)"],
-        IntegerArrayValidator("uint64", 0xffff_ffff_ffff_ffff, 0)
+        ["<arg_out> = lb_array_size_encode(<arg_name>, n_<arg_name>)"],
+        ["<arg_in> = lb_array_size_decode(<arg_name>, &n_<arg_in>)"],
+        IntegerArrayValidator("size", 0xffff_ffff_ffff_ffff, 0)
     ),
     "array[double]": CTypeBase(
         ["gsize n_<arg_name>" ,"<const>gdouble *<arg_name>"],

{lbkit-0.8.6 → lbkit-0.8.8}/lbkit/codegen/template/public.c.mako

@@ -526,7 +526,7 @@ static ${name}${dictionary.key} *${name}_lookup(const ${name} *dict, ${key_decla
     }
 
     const ${name}Real *dict_real = CONTAINER_OF(dict, ${name}Real, dict);
-    return (${name}${dictionary.key} *)g_hash_table_lookup(dict_real->_hash, GUINT_TO_POINTER((guint64)key));
+    return (${name}${dictionary.key} *)g_hash_table_lookup(dict_real->_hash, GUINT_TO_POINTER(key));
 }
 
 /**
@@ -547,7 +547,7 @@ static gboolean ${name}_insert(const ${name} *dict, ${key_declare}, ${name}${dic
     % if dictionary.key_type in ["string", "object_path", "signature"]:
     gboolean ret = g_hash_table_insert(dict_real->_hash, g_strdup(key), *value);
     % else:
-    gboolean ret = g_hash_table_insert(dict_real->_hash, GUINT_TO_POINTER((guint64)key), *value);
+    gboolean ret = g_hash_table_insert(dict_real->_hash, GUINT_TO_POINTER(key), *value);
     % endif
     if (ret) {
         *value = NULL;
@@ -571,7 +571,7 @@ static gboolean ${name}_remove(const ${name} *dict, ${key_declare})
     }
 
     const ${name}Real *dict_real = CONTAINER_OF(dict, ${name}Real, dict);
-    return g_hash_table_remove(dict_real->_hash, GUINT_TO_POINTER((guint64)key));
+    return g_hash_table_remove(dict_real->_hash, GUINT_TO_POINTER(key));
 }
 
 /**

{lbkit-0.8.6 → lbkit-0.8.8}/lbkit/component/build.py

@@ -20,7 +20,6 @@ from lbkit.codegen.codegen import Version
 
 tools = Tools("comp_build")
 log = tools.log
-cwd = os.getcwd()
 lb_cwd = os.path.split(os.path.realpath(__file__))[0]
 
 
@@ -52,6 +51,7 @@ class DeployComponent():
 
 class BuildComponent():
     def __init__(self, args_parser: ArgumentParser, args=None):
+        self.cwd = os.getcwd()
         self.deploy_success = True
         self.options = args_parser.parse_args(args)
         self.options.build_type = self.options.build_type.capitalize()
@@ -64,7 +64,7 @@ class BuildComponent():
         self.verbose = False if self.options.summary else True
         self.from_source = self.options.from_source
         # 当前组件及其依赖将被部署到rootfs目录
-        self.rootfs_dir = os.path.join(cwd, ".temp", "rootfs")
+        self.rootfs_dir = os.path.join(self.cwd, ".temp", "rootfs")
         shutil.rmtree(self.rootfs_dir, ignore_errors=True)
         os.makedirs(self.rootfs_dir, exist_ok=True)
 
@@ -117,7 +117,7 @@ class BuildComponent():
         return False
 
     def gen_conaninfo(self):
-        package_yml = os.path.join(cwd, "metadata/package.yml")
+        package_yml = os.path.join(self.cwd, "metadata/package.yml")
         if not os.path.isfile(package_yml):
             raise FileNotFoundError("metadata/package.yml文件不存在")
         # 验证失败时抛异常，此处不用处理，由外层处理
@@ -155,10 +155,10 @@ class BuildComponent():
                 self.base_cmd += f" -o {conan}/*:{k}={v}"
 
         # 生成conan构建脚本
-        conanfile = os.path.join(cwd, "conanbase.py")
+        conanfile = os.path.join(self.cwd, "conanbase.py")
         # 当git未跟踪conanfile.py时生成新的conanfile.py
         if not self._is_conanfile_tracked:
-            conanfile = os.path.join(cwd, "conanfile.py")
+            conanfile = os.path.join(self.cwd, "conanfile.py")
 
         # 使用litebmc.conanfile.mako模板生成基础litebmc公共conanfile
         lookup = TemplateLookup(directories=os.path.join(lb_cwd, "template"))
@@ -210,8 +210,8 @@ class BuildComponent():
         # import sys
         # sys.exit(-1)
 
-        lockfile = os.path.join(cwd, ".temp", "conan.lock")
-        graphfile = os.path.join(cwd, ".temp", "graph.info")
+        lockfile = os.path.join(self.cwd, ".temp", "conan.lock")
+        graphfile = os.path.join(self.cwd, ".temp", "graph.info")
         lock_cmd = f"conan lock create . {self.base_cmd} --lockfile-out={lockfile}"
         tools.run(lock_cmd, capture_output=False)
         graph_cmd = f"conan graph info . {self.base_cmd} -f json --lockfile={lockfile}"
@@ -232,7 +232,7 @@ class BuildComponent():
 
         # 设置ROOTFS_DIR环境变量，为DT测试提供相对路径
         os.environ["ROOTFS_DIR"] = self.rootfs_dir
-        os.chdir(cwd)
+        os.chdir(self.cwd)
 
     def _validate_odf_object(self, name, obj):
         properties = obj.get("properties")
@@ -276,7 +276,7 @@ class BuildComponent():
         for root, _, files in os.walk(self.rootfs_dir):
             for file in files:
                 file = os.path.join(root, file)
-                file = os.path.relpath(file, cwd)
+                file = os.path.relpath(file, self.cwd)
                 if not file.endswith(".yaml"):
                     log.debug(f"file {file} not endswith .yaml, skip validate")
                     continue

{lbkit-0.8.6 → lbkit-0.8.8}/lbkit/component/test.py

@@ -12,11 +12,11 @@ from lbkit.misc import Color
 
 tool = Tools("comp_test")
 log = tool.log
-cwd = os.getcwd()
 
 
 class TestComponent():
     def __init__(self, args=None):
+        self.cwd = os.getcwd()
         self.build_parser = ArgParser.new(True)
         self.build_parser.parse_args(args) # 共享命令参数
         self.origin_args = args
@@ -95,13 +95,13 @@ class TestComponent():
         self._make_ld_library_path(build.rootfs_dir)
 
         # 为确保路径正确，切换到初始路径
-        os.chdir(cwd)
+        os.chdir(self.cwd)
         # 必须存在test.py时才测试
         if not os.path.isfile("test.py"):
             log.warn("Test file(test.py) not exist, skip test")
             return 0
         # 从test.py加载LiteBmcComponentTest实例并运行用命
-        loader = importlib.machinery.SourceFileLoader("test", os.path.join(cwd, "test.py"))
+        loader = importlib.machinery.SourceFileLoader("test", os.path.join(self.cwd, "test.py"))
         mod = loader.load_module()
         klass = getattr(mod, "LiteBmcComponentTest")
         if klass is None:

{lbkit-0.8.6 → lbkit-0.8.8}/lbkit/tasks/config.py

@@ -55,9 +55,6 @@ class Config(object):
         self.mnt_path = os.path.join(self.temp_path, "mnt_path")
         self.rootfs_img = os.path.join(self.output_path, "rootfs.img")
         # rootfs、uboot和kernel关键文件路径
-        self.uboot_bin = None
-        self.linux_bin = None
-        self.rootfs_tar = None
         os.makedirs(self.temp_path, exist_ok=True)
         os.makedirs(self.tool_path, exist_ok=True)
         os.makedirs(self.output_path, exist_ok=True)
@@ -148,6 +145,36 @@ class Config(object):
             return product_cfg
         return Config.merge_cfg(global_cfg, product_cfg)
 
+    def _trans_dependencies_to_dict(self, deps):
+        out = {}
+        for dep in deps:
+            name = dep["package"]
+            name = name.split("/")[0]
+            out[name] = dep
+        return out
+
+    def _merge_dependencies(self, dst, src: dict[str, dict]):
+        for key, val in src.items():
+            dst[key] = val
+        return dst
+
+    def get_dependencies(self):
+        debug_cfg = self.get_manifest_config("debug_dependencies", [])
+        debug_dict = self._trans_dependencies_to_dict(debug_cfg)
+        global_cfg = self.get_manifest_config("dependencies", [])
+        global_dict = self._trans_dependencies_to_dict(global_cfg)
+        # debug_cfg优先级更高
+        tmp = self._merge_dependencies(global_dict, debug_dict)
+        key = f"products/{self.product}/dependencies"
+        # product_cfg优先级最高
+        product_cfg = self.get_manifest_config(key, [])
+        product_dict = self._trans_dependencies_to_dict(product_cfg)
+        tmp = self._merge_dependencies(tmp, product_dict)
+        out = []
+        for _, value in tmp.items():
+            out.append(value)
+        return out
+
     def load_manifest(self):
         """加载manifest.yml并验证schema文件"""
         template = {}

{lbkit-0.8.6 → lbkit-0.8.8}/lbkit/tasks/executor.py

@@ -5,6 +5,7 @@ import os
 import time
 import traceback
 import sys
+import psutil
 
 from multiprocessing import Process
 from multiprocessing import Manager
@@ -139,7 +140,7 @@ def task_handler(te:TaskExecutor):
     try:
         ret = te.run()
     except Exception as e:
-        log.error(traceback.print_exc())
+        traceback.print_exc()
         log.error(f"Task {te.status_key} exit with exceiption: {str(e)}")
         with status_lock:
             status_dict[te.status_key] = TASK_STATUS_EXCEPT
@@ -160,6 +161,19 @@ class TaskInfo():
         self.proc = proc
 
 
+def kill_process_and_children(pid):
+    try:
+        parent = psutil.Process(pid)
+    except psutil.NoSuchProcess:
+        return
+
+    children = parent.children(recursive=True)
+    for child in children:
+        child.terminate()
+
+    parent.terminate()
+
+
 def wait_tasks(tasks: dict[str, TaskInfo], alow_processes_alive=0):
     while True:
         new_results = {}
@@ -172,13 +186,12 @@ def wait_tasks(tasks: dict[str, TaskInfo], alow_processes_alive=0):
                 continue
             with status_lock:
                 status = status_dict.get(ti.te.status_key)
-            if status == TASK_STATUS_EXCEPT:
+            if status == TASK_STATUS_EXCEPT or status == TASK_STATUS_FAILED:
                 killall = True
                 break
         if killall:
             for _, ti in tasks.items():
-                if ti.proc.is_alive():
-                    ti.proc.terminate()
+                kill_process_and_children(ti.proc.pid)
             return None, False
         tasks = new_results
         if cnt > 0 and cnt >= alow_processes_alive:
@@ -244,7 +257,7 @@ class Executor(object):
             target = config.target
             succ = target_executor(config)
         except Exception as e:
-            log.error(str(e))
+            traceback.print_exc()
             raise Exception(f"任务 {target} 执行失败")
         if succ:
             log.success(f"任务 {target} 执行成功")

lbkit-0.8.8/lbkit/tasks/image_maker/make_image.py

@@ -0,0 +1,17 @@
+"""环境准备"""
+import os
+from lbkit.tasks.config import Config
+from lbkit.tasks.task import Task
+
+
+class TaskMakeImage(Task):
+    def available(self):
+        return False
+
+    def run(self):
+        return
+
+if __name__ == "__main__":
+    config = Config()
+    build = TaskMakeImage(config, "test")
+    build.run()

lbkit-0.8.8/lbkit/tasks/image_maker/make_qemu_image.py

@@ -0,0 +1,75 @@
+"""环境准备"""
+import os
+import tempfile
+from lbkit.tasks.config import Config
+from lbkit.log import Logger
+from lbkit.utils.images.emmc import MakeImage as MekeEmmcImage
+from lbkit.tasks.image_maker.make_image import TaskMakeImage
+
+log = Logger("build_image")
+
+src_cwd = os.path.split(os.path.realpath(__file__))[0]
+
+class TaskMakeQemuImage(TaskMakeImage):
+    def __init__(self, config, name):
+        super().__init__(config, name)
+        self.chip_model = None
+        chip_model = self.config.get_product_config("chip_model")
+        if chip_model not in ["qemu_arm64"]:
+            return
+        self.chip_model = chip_model
+        self.uboot = self.config.get_product_config("flash/uboot")
+        self.kernel = self.config.get_product_config("flash/kernel")
+        self.rootfs = self.config.rootfs_img
+
+    @staticmethod
+    def _trans_to_blk_1m(cfg: str):
+        if cfg.endswith("K"):
+            return int(cfg[:-1]) / 1024
+        elif cfg.endswith("M"):
+            return int(cfg[:-1])
+        elif cfg.endswith("G"):
+            return int(cfg[:-1]) * 1024
+
+    def available(self):
+        if not self.chip_model:
+            return False
+        if self.config.get_product_config("flash/type") != "emmc":
+            return False
+        return True
+
+    def run(self):
+        """任务入口"""
+        """检查manifest文件是否满足schema格式描述"""
+        os.chdir(self.config.output_path)
+
+        mk = MekeEmmcImage(os.path.join(self.config.temp_path, "emmc_tmp_dir"))
+        rootfs_size = self.config.get_product_config("rootfs/size")
+        if rootfs_size:
+            mk.rootfs_blk_1m = self._trans_to_blk_1m(rootfs_size)
+        emmc_size = self.config.get_product_config("flash/size")
+        if emmc_size:
+            mk.size_1m = self._trans_to_blk_1m(emmc_size)
+        tmpdir = tempfile.TemporaryDirectory()
+        cmd = f"fuse2fs {self.rootfs} {tmpdir.name} -o fakeroot"
+        self.exec(cmd)
+        # 复制内核文件到boot/extlinux/Image
+        cmd = f"cp {self.kernel} {tmpdir.name}/boot/Image"
+        self.exec(cmd)
+        cmd = f"umount {tmpdir.name}"
+        self.exec(cmd)
+        mk.run(self.config.rootfs_img, "qemu.img")
+        cmd = 'cp /usr/share/litebmc/qemu.conf qemu.conf'
+        self.exec(cmd)
+        cmd = f'cp {self.uboot} u-boot.bin'
+        self.exec(cmd)
+        output_img = os.path.join(self.config.output_path, "litebmc_qemu.tar.gz")
+        cmd = f'tar -czf {output_img} -C . qemu.img u-boot.bin qemu.conf'
+        self.exec(cmd)
+        log.success(f"Create litebmc image {output_img} successfully")
+        return 0
+
+if __name__ == "__main__":
+    config = Config()
+    build = TaskMakeQemuImage(config, "test")
+    build.run()

lbkit-0.8.8/lbkit/tasks/image_maker/make_rockchip_image.py

@@ -0,0 +1,78 @@
+"""环境准备"""
+import os
+import shutil
+from lbkit.tasks.config import Config
+from lbkit.tasks.task import Task
+from lbkit.log import Logger
+
+log = Logger("build_image")
+
+src_cwd = os.path.split(os.path.realpath(__file__))[0]
+
+class TaskMakeRockchipImage(Task):
+    def __init__(self, config, name):
+        super().__init__(config, name)
+        self.chip_model = None
+        chip_model = self.config.get_product_config("chip_model")
+        if chip_model not in ["rk3506"]:
+            return
+        self.chip_model = chip_model
+        self.uboot = self.config.get_product_config("flash/uboot")
+        self.kernel = self.config.get_product_config("flash/kernel")
+        self.loader = self.config.get_product_config("flash/loader")
+        self.parameter = self.config.get_product_config("flash/parameter")
+        self.package_file = self.config.get_product_config("flash/package-file")
+        self.rootfs = self.config.rootfs_img
+
+    def available(self):
+        if not self.chip_model:
+            return False
+        if self.config.get_product_config("flash/type") != "spi_nand":
+            return False
+        return True
+
+    def run(self):
+        """任务入口"""
+        if not self.available():
+            return -1
+        cwd = os.getcwd()
+        tmpdir = os.path.join(self.config.output_path, "temp_files")
+        if os.path.isdir(tmpdir):
+            shutil.rmtree(tmpdir)
+        os.makedirs(tmpdir)
+        os.chdir(tmpdir)
+        self.copyfile(self.uboot, os.path.basename(self.uboot))
+        self.copyfile(self.kernel, os.path.basename(self.kernel))
+        self.copyfile(self.loader, os.path.basename(self.loader))
+        self.copyfile(self.parameter, "parameter.txt")
+        self.copyfile(self.package_file, "package-file")
+        self.copyfile(self.rootfs, os.path.basename(self.rootfs))
+        with open(self.package_file) as fp:
+            lines = fp.readlines()
+        for line in lines:
+            line = line.strip()
+            if line.startswith("#"):
+                continue
+            infos = line.split("\t")
+            if len(infos) != 2:
+                raise Exception("the package-file with format error, each line of text must be in the format of `name\tfile\n`")
+            filename = infos[1]
+            if not os.path.isfile(filename):
+                cmd = f"dd if=/dev/zero of={filename} bs=1K count=1"
+                self.exec(cmd)
+        cmd = "rk_afptool -pack . firmware.img.raw"
+        self.exec(cmd, verbose=True)
+        cmds = [f"hexdump -s 21 -n 4 -e '4 \"%c\"' {self.loader}", "rev"]
+        tag = "RK" + self.pipe(cmds).decode("utf-8")
+        cmd = f"rk_image_maker -{tag} {self.loader} firmware.img.raw firmware.img -os_type:androidos"
+        self.exec(cmd, verbose=True)
+        cmd = f"mv firmware.img " + os.path.join(self.config.output_path, "firmware.img")
+        self.exec(cmd)
+        os.chdir(cwd)
+        return 0
+
+
+if __name__ == "__main__":
+    config = Config()
+    build = TaskMakeRockchipImage(config, "test")
+    build.run()

{lbkit-0.8.6 → lbkit-0.8.8}/lbkit/tasks/task.py

@@ -7,7 +7,6 @@ import shutil
 from multiprocessing import Process
 from lbkit.log import Logger
 from lbkit.tools import Tools
-from lbkit.misc import load_yml_with_json_schema_validate, DownloadFlag
 
 from lbkit.tasks.config import Config
 
@@ -33,7 +32,7 @@ class Task(Process):
 
     def pipe(self, cmds: list[str], ignore_error=False, out_file = None, **kwargs):
         kwargs["uptrace"] = kwargs.get("uptrace", 0) + 1
-        self.tools.pipe(cmds, ignore_error, out_file, **kwargs)
+        return self.tools.pipe(cmds, ignore_error, out_file, **kwargs)
 
     def exec_easy(self, cmd, ignore_error=False, **kwargs):
         kwargs["uptrace"] = kwargs.get("uptrace", 0) + 1
@@ -57,50 +56,7 @@ class Task(Process):
         """加载manifest.yml并验证schema文件"""
         return self.config.load_manifest()
 
-    def waitfile(self, src, timeout=1):
-        src = os.path.realpath(src)
-        if os.path.islink(src):
-            raise FileNotFoundError(f"Source file {src} is a symlink, copying failed")
-        if not os.path.isfile(src):
-            if timeout:
-                # 如果有timeout的，可能是正在下载的文件，需要等待超时时间再检查一次
-                time.sleep(timeout)
-                if not os.path.isfile(src):
-                    raise FileNotFoundError(f"Source file {src} does not exist, copying failed")
-            else:
-                raise FileNotFoundError(f"Source file {src} does not exist, copying failed")
-
-        # 检查是否由download下载器下载，如果是，需要检查是否下载完成
-        if src.startswith(self.config.download_path):
-            timeout_cnt = 0
-            timeout_sec = 0
-            while True:
-                _, hash = DownloadFlag.read(src)
-                if hash:
-                    filehash = self.tools.file_digest_sha256(src)
-                    if hash != filehash:
-                        DownloadFlag.clean(src)
-                        raise Exception(f"The hash of file {src} is {filehash}, not equal to {hash}")
-                    break
-                else:
-                    time.sleep(0.1)
-                    timeout_sec += 0.1
-                    timeout_cnt += 0.1
-                # 每10秒打印一次等等日志
-                if timeout_sec == 10:
-                    self.log.info(f"Wait file {src} download success")
-                    timeout_sec = 0
-                # 60秒未创建文件的，判定文件不存在，中止构建
-                if timeout_cnt == 60 and not os.path.isfile(src):
-                    raise Exception(f"Check file {src} failed because source file does not exist")
-                if timeout_cnt == 300:
-                    raise Exception(f"Check file {src} failed because file was not downloaded within 300 seconds")
-
     def copyfile(self, src, dst):
-        try:
-            self.waitfile(src)
-        except Exception as e:
-            raise Exception(f"Copy file {src} to {dst} failed because source file not ready") from e
 
         dst = os.path.realpath(dst)
         if not dst.startswith(self.config.temp_path):

lbkit-0.8.8/lbkit/tasks/task_build_image.py

@@ -0,0 +1,29 @@
+"""环境准备"""
+import os
+from lbkit.tasks.config import Config
+from lbkit.tasks.task import Task
+from lbkit.log import Logger
+from lbkit.tasks.image_maker.make_rockchip_image import TaskMakeRockchipImage
+from lbkit.tasks.image_maker.make_qemu_image import TaskMakeQemuImage
+
+log = Logger("build_image")
+
+src_cwd = os.path.split(os.path.realpath(__file__))[0]
+
+class TaskClass(Task):
+    def run(self):
+        """任务入口"""
+        maker = TaskMakeRockchipImage(self.config, self.name)
+        if maker.available():
+            maker.run()
+            return 0
+        maker = TaskMakeQemuImage(self.config, self.name)
+        if maker.available():
+            maker.run()
+            return 0
+        return -1
+
+if __name__ == "__main__":
+    config = Config()
+    build = TaskClass(config, "test")
+    build.run()