lbkit 0.6.1__tar.gz → 0.6.3__tar.gz

{lbkit-0.6.1/lbkit.egg-info → lbkit-0.6.3}/PKG-INFO

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

lbkit-0.6.3/lbkit/__init__.py

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

{lbkit-0.6.1 → lbkit-0.6.3}/lbkit/build_conan_parallel.py

@@ -85,9 +85,10 @@ class BuildConanParallel(object):
         cmd += " --build=missing"
         cmd += f" --lockfile={self.lockfile}"
         try:
-            log.info(f">>>> build {cp.ref} start")
+            logfile = f"{misc.LOG_DIR}/conan_{cp.name}.log"
+            log.info(f">>>> build {cp.ref} start, logfile: {logfile}")
             log.debug(f">>>> {cmd}")
-            tools.exec(cmd, echo_cmd=False, log_name=f"{misc.LOG_DIR}/conan_{cp.name}.log")
+            tools.exec(cmd, echo_cmd=False, log_name=logfile)
             log.success(f"<<<< build {cp.ref} finished")
         except Exception as e:
             self.exception = e

{lbkit-0.6.1 → lbkit-0.6.3}/lbkit/ci_robot/gitee.py

@@ -78,6 +78,8 @@ class Gitee():
         self.check_parameter_format("token", f"^[a-z0-9]+$", self.token)
 
         self.owner = os.environ.get("giteeTargetNamespace")
+        if not self.owner:
+            self.owner = os.environ.get("giteeSourceNamespace")
         if self.options.owner is not None:
             self.owner = self.options.owner
         if self.owner is None:
@@ -85,6 +87,8 @@ class Gitee():
         self.check_parameter_format("owner", f"^[a-z0-9_a-z-]+$", self.owner)
 
         self.repo = os.environ.get("giteeTargetRepoName")
+        if not self.repo:
+            self.repo = os.environ.get("giteeSourceRepoName")
         if self.options.repo is not None:
             self.repo = self.options.repo
         if self.repo is None:

{lbkit-0.6.1 → lbkit-0.6.3}/lbkit/component/build.py

@@ -71,7 +71,10 @@ class BuildComponent():
         self.pkg = None
         self.base_cmd = ""
         self.gen_conaninfo()
-        self.base_cmd += f" --user {self.user} --channel {self.channel}"
+        # 此场景发布的包名不带@user/channel
+        if self.user != "litebmc" or self.channel != "release":
+            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
         self.base_cmd += f" -pr:b {self.profile_build}"
         if self.options.cov:
@@ -126,8 +129,9 @@ class BuildComponent():
         self.name = pkg.get("name")
         self.version = pkg.get("version")
 
-        self.package = self.name + "/" + self.version + \
-            "@" + self.user + "/" + self.channel
+        self.package = self.name + "/" + self.version
+        if self.user != "litebmc" or self.channel != "release":
+            self.package += "@" + self.user + "/" + self.channel
         # 准备部署依赖
         requires = pkg.get("requires")
         deps = []
@@ -190,8 +194,12 @@ class BuildComponent():
     def build(self):
         log.info(os.getcwd())
 
-        export_cmd = f"conan export . --user={self.user} --channel={self.channel}"
+        export_cmd = "conan export . "
+        if self.user != "litebmc" or self.channel != "release":
+            export_cmd += f"--user={self.user} --channel={self.channel}"
         tools.run(export_cmd, capture_output=False)
+        # import sys
+        # sys.exit(-1)
 
         lockfile = os.path.join(cwd, ".temp", "conan.lock")
         graphfile = os.path.join(cwd, ".temp", "graph.info")

{lbkit-0.6.1 → lbkit-0.6.3}/lbkit/component/template/conanbase.mako

@@ -28,8 +28,11 @@ libs = pkg.get("package_info", {}).get("libs", [])
 class LiteBmcConan(ConanFile):
     name = "${pkg_name}"
     version = "${pkg["version"]}"
+% if pkg["user"] != "litebmc" or pkg["channel"] != "release":
+## @litebmc/release则生成的包名不带@user/channel
     user = "${pkg["user"]}"
     channel = "${pkg["channel"]}"
+% endif
     settings = "os", "arch", "compiler", "build_type"
     description = "${pkg["description"]}"
     url = "${pkg["url"]}"
@@ -78,16 +81,12 @@ class LiteBmcConan(ConanFile):
             return
 
         scm_url = None
-        remotes = git.run("remote -v")
-        checked_name = []
-        for r in remotes.splitlines():
-            name, url = r.split(maxsplit=1)
-            if name in checked_name:
-                continue
-            checked_name.append(name)
-            url, scm_commit = git.get_url_and_commit(remote=name)
-            if url.startswith("https://"):
-                scm_url = url
+        scm_commit = git.get_commit()
+        branches = git.run("branch -r --contains {}".format(scm_commit))
+        remotes = git.run("remote")
+        for remote in remotes.splitlines():
+            if "{}/".format(remote) in branches:
+                scm_url = git.get_remote_url(remote)
                 break
         if not scm_url:
             files.update_conandata(self, {"sources": {"commit": None, "url": None, "pwd": os.getcwd()}})

lbkit-0.6.3/lbkit/integration/build_image.py

@@ -0,0 +1,49 @@
+"""环境准备"""
+import os
+import tarfile
+from lbkit.integration.config import Config
+from lbkit.integration.task import Task
+from lbkit.log import Logger
+from lbkit import errors
+from lbkit.utils.images.emmc import MakeImage as MekeEmmcImage
+
+log = Logger("build_image")
+
+src_cwd = os.path.split(os.path.realpath(__file__))[0]
+
+class BuildImage(Task):
+    @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 run(self):
+        """任务入口"""
+        """检查manifest文件是否满足schema格式描述"""
+        os.chdir(self.config.output_path)
+        cmd = "qemu-system-aarch64 -M virt -cpu cortex-a57 -M virt,dumpdtb=virt.dtb"
+        self.exec(cmd)
+
+        mk = MekeEmmcImage(os.path.join(self.config.temp_path, "emmc_tmp_dir"))
+        rootfs_size = self.get_manifest_config("metadata/rootfs_size")
+        if rootfs_size:
+            mk.rootfs_blk_1m = self._trans_to_blk_1m(rootfs_size)
+        emmc_size = self.get_manifest_config("metadata/emmc_size")
+        if emmc_size:
+            mk.size_1m = self._trans_to_blk_1m(emmc_size)
+        mk.run("virt.dtb", self.config.rootfs_img, "qemu.img")
+        cmd = 'cp /usr/share/litebmc/qemu.conf qemu.conf'
+        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 {self.config.uboot_bin} qemu.conf'
+        self.exec(cmd)
+        log.success(f"Create litebmc image {output_img} successfully")
+
+if __name__ == "__main__":
+    config = Config()
+    build = BuildImage(config)
+    build.run()

{lbkit-0.6.1 → lbkit-0.6.3}/lbkit/integration/build_manifest.py

@@ -8,6 +8,7 @@ from lbkit.integration.task import Task
 from lbkit.log import Logger
 from lbkit.build_conan_parallel import BuildConanParallel
 from concurrent.futures import ThreadPoolExecutor
+from lbkit.errors import LiteBmcException
 
 log = Logger("product_build")
 
@@ -47,6 +48,17 @@ class BuildManifest(Task):
                 continue
             cmd = f"conan cache path {ref}:{id}"
             package_folder = self.tools.run(cmd).stdout.strip()
+            rootfs_tar = os.path.join(package_folder, "rootfs.tar")
+            uboot_bin = os.path.join(package_folder, "u-boot.bin")
+            linux_bin = os.path.join(package_folder, "boot/Image")
+            if os.path.isfile(rootfs_tar):
+                self.config.rootfs_tar = rootfs_tar
+                continue
+            elif os.path.isfile(uboot_bin):
+                self.config.uboot_bin = uboot_bin
+                continue
+            elif os.path.isfile(linux_bin):
+                self.config.linux_bin = linux_bin
             self.config.conan_install.append(package_folder)
 
     def download_recipe(self, pkg):
@@ -106,6 +118,18 @@ class BuildManifest(Task):
     def run(self):
         """任务入口"""
         self.build_litebmc()
+        error = False
+        if not self.config.rootfs_tar:
+            error = True
+            self.log.error("rootfs.tar not found in any conan package")
+        if not self.config.uboot_bin:
+            error = True
+            self.log.error("u-boot.bin not found in any conan package")
+        if not self.config.linux_bin:
+            error = True
+            self.log.error("boot/Image not found in any conan package")
+        if error:
+            raise FileNotFoundError("Build failed because important files are missing")
 
 if __name__ == "__main__":
     config = Config()

{lbkit-0.6.1 → lbkit-0.6.3}/lbkit/integration/build_prepare.py

@@ -50,7 +50,7 @@ class BuildPrepare(Task):
     def run(self):
         """任务入口"""
         """检查manifest文件是否满足schema格式描述"""
-        self.load_manifest()
+        self.config.load_manifest()
         self.load_conan_profile()
 
 if __name__ == "__main__":

{lbkit-0.6.1 → lbkit-0.6.3}/lbkit/integration/build_rootfs.py

@@ -58,39 +58,15 @@ class BuildRootfs(Task):
                     cmd = f"chown {uid}:{gid} {chunk[0]}"
                     self.exec(cmd)
 
-    def download_rootfs(self, rootfs_img):
-        """下载rootfs基础镜像"""
-        os.chdir(self.config.download_path)
-        rootfs_tar = "rootfs.tar.gz"
-
-        url = self.get_manifest_config("components/rootfs/url")
-        sha256 = None
-        if not self.config.not_check_download_sha:
-            sha256 = self.get_manifest_config("components/rootfs/sha256")
-        self.tools.download(url, rootfs_tar, sha256)
-        tar = tarfile.open(rootfs_tar)
-        members = tar.getmembers()
-        for member in members:
-            if not member.isfile():
-                continue
-            if member.name != "rootfs.img" and member.name != "rootfs.ext4" and member.name != "rootfs.ext2":
-                continue
-            io = tar.extractfile(member)
-            fp = open(rootfs_img, "wb+")
-            while True:
-                buf = io.read(65536)
-                if len(buf) == 0:
-                    break
-                fp.write(buf)
-            fp.close()
-            return
-        raise errors.ExtractRootfsTarFileError("Extract failed, the rootfs.img can't be found in rootfs.tar")
-
     def copy_conan_install(self, src_dir, mnt_path):
         src_dir += "/"
-        cmd = f"rsync -aHK --exclude 'include' --exclude '*.a' --chown=0:0 {src_dir} {mnt_path}"
+        cmd = f"rsync -aHK --exclude '*.hpp' --exclude '*.h'"
+        cmd += f" --exclude 'rootfs.tar' --exclude 'u-boot.bin'"
+        cmd += f" --exclude 'conanmanifest.txt' --exclude 'conaninfo.txt'"
+        cmd += f" --exclude '*.a' --chown=0:0 {src_dir} {mnt_path}"
         log.info("copy %s to %s", src_dir, mnt_path)
         self.exec(cmd, echo_cmd=False)
+        strip = self.get_manifest_config("metadata/strip")
         for root, dirs, files in os.walk(src_dir):
             root = root.replace(src_dir, "")
             for dir in dirs:
@@ -101,18 +77,27 @@ class BuildRootfs(Task):
                 self.exec(cmd, echo_cmd=False)
             for file in files:
                 name = os.path.join(mnt_path, root, file)
+                cmd = f"chown -h 0:0 {name}"
                 if not os.path.isfile(name):
                     continue
-                cmd = f"chown 0:0 {name}"
                 self.exec(cmd, echo_cmd=False)
+                if name.find("usr/share") > 0 and name.find("bin") == -1:
+                    continue
+                suffix = name.split(".")[-1]
+                no_need_strip = ["json", "html", "md", "txt", "yaml", "xml"]
+                no_need_strip.extend(["yml", "mo", "conf", "gz", "inc", "service", "py"])
+                no_need_strip.extend(["m4", "pc", "cmake", "rules", "ts", "js", "png"])
+                no_need_strip.extend(["jpg", "jpeg", "mpeg", "c", "h", "hpp"])
+                if suffix != name and suffix in no_need_strip:
+                    continue
                 strip = self.get_manifest_config("metadata/strip")
                 if strip:
-                    cmds = [f"file {name}", "grep \"not stripped\", "f"{self.config.strip} -s {name}"]
+                    cmds = [f"file {name}", "grep \"not stripped\"", f"{self.config.strip} -s {name}"]
                     self.pipe(cmds, error_log="", ignore_error=True)
         per_file = os.path.join(src_dir, "permissions")
         self.do_permission(per_file)
 
-    def merge_rootfs(self, rootfs_img):
+    def merge_rootfs(self):
         """将产品依赖的所有组件安装到rootfs镜像中"""
         mnt_path = self.config.mnt_path
         self.exec("umount " + mnt_path, ignore_error=True)
@@ -120,13 +105,20 @@ class BuildRootfs(Task):
         os.makedirs(mnt_path)
         # 按manifest配置的大小调整rootfs
         rootfs_size = self.get_manifest_config("metadata/rootfs_size")
-        self.exec(f"resize2fs {rootfs_img} {rootfs_size}")
+        if self.config.rootfs_tar:
+            cmd = f"mkfs.ext4 -d {mnt_path} -r 1 -N 0 -m 5 -L \"rootfs\" -O ^64bit {self.config.rootfs_img} \"{rootfs_size}\""
+            self.exec(cmd)
         # 挂载rootfs镜像
-        self.exec(f"fuse2fs {rootfs_img} {mnt_path} -o fakeroot")
+        self.exec(f"fuse2fs {self.config.rootfs_img} {mnt_path} -o fakeroot")
+        # 从rootfs.tar解压内容
+        if self.config.rootfs_tar:
+            cmd = f"tar -pxf {self.config.rootfs_tar} -C {mnt_path} ."
+            self.exec(cmd)
+            cmd = f"chown root:root {mnt_path} -R"
+            self.exec(cmd)
         # 切换到rootfs挂载目录
         os.chdir(mnt_path)
         log.info("Copy customization rootfs......")
-        per_files = []
         for src_dir in self.config.conan_install:
             self.copy_conan_install(src_dir, mnt_path)
 
@@ -135,8 +127,6 @@ class BuildRootfs(Task):
         if os.path.isdir(product_rootfs):
             self.copy_conan_install(product_rootfs, mnt_path)
 
-        for per_file in per_files:
-            self.do_permission(per_file)
         # 执行rootfs定制化脚本
         os.chdir(self.config.work_dir)
         hook_name = "hook.post_rootfs"
@@ -156,13 +146,8 @@ class BuildRootfs(Task):
         self.exec("umount " + mnt_path)
 
     def run(self):
-        rootfs_img = os.path.join(self.config.download_path, IMG_FILE)
-        if os.path.isfile(rootfs_img):
-            os.unlink(rootfs_img)
         # 任务入口
-        self.download_rootfs(rootfs_img)
-        self.merge_rootfs(rootfs_img)
-        os.rename(rootfs_img, self.config.rootfs_img)
+        self.merge_rootfs()
         log.success(f"Create image {self.config.rootfs_img} successfully")
 
 if __name__ == "__main__":

{lbkit-0.6.1 → lbkit-0.6.3}/lbkit/integration/config.py

@@ -2,6 +2,7 @@
 import argparse
 import os, sys
 from lbkit.log import Logger
+from lbkit.misc import load_yml_with_json_schema_validate
 
 log = Logger("build_config")
 
@@ -25,7 +26,6 @@ class Config(object):
         self.build_type = args.build_type
         # conan中心仓
         self.remote = args.remote
-        self.not_check_download_sha = args.not_check_download_sha
 
         if not os.path.isfile(self.manifest):
             raise FileNotFoundError(f"File {args.manifest} not exist")
@@ -43,16 +43,17 @@ class Config(object):
         self.temp_path = os.path.join(self.code_path, ".temp")
         self.output_path = os.path.join(self.temp_path, "output")
         self.tool_path = os.path.join(self.temp_path, "tools")
-        self.download_path = os.path.join(self.temp_path, "download")
-        self.rootfs_path = os.path.join(self.temp_path, "rootfs")
+        # conan组件打包目录
         self.conan_install = []
         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)
-        os.makedirs(self.download_path, exist_ok=True)
-        os.makedirs(self.rootfs_path, exist_ok=True)
         # 制作rootfs时需要strip镜像，所以需要单独指定stip路径
         self.strip = "strip"
 
@@ -65,7 +66,23 @@ class Config(object):
         parser.add_argument("-pr", "--profile", help="Apply the specified profile to the host machine", default="litebmc.ini")
         parser.add_argument("-pr:b", "--profile_build", help="Apply the specified profile to the build machine", default="default")
         parser.add_argument("-t", "--build_type", type=str, choices=['debug', 'release', 'minsize'], help="Set the build type", default="debug")
-        parser.add_argument("--not_check_download_sha", help="don't check sha256 of download file", action="store_true")
         parser.add_argument("-r", "--remote", help="specified conan server", default="litebmc")
         parser.add_argument("-l", "--create_conan_lock", help="Create new conan.lock", action="store_true")
         return parser
+
+    def get_manifest_config(self, key: str, default=None):
+        """从manifest中读取配置"""
+        manifest = self.load_manifest()
+        keys = key.split("/")
+        for k in keys:
+            manifest = manifest.get(k, None)
+            if manifest is None:
+                return default
+        return manifest
+
+    def load_manifest(self):
+        """加载manifest.yml并验证schema文件"""
+        template = {}
+        template["code_path"] = self.code_path
+        template["temp_path"] = self.temp_path
+        return load_yml_with_json_schema_validate(self.manifest, "/usr/share/litebmc/schema/pdf.v1.json", **template)

{lbkit-0.6.1 → lbkit-0.6.3}/lbkit/integration/task.py

@@ -50,17 +50,9 @@ class Task(Process):
         hook = module.TaskHook(self.config, "do_hook")
         hook.run()
 
-    def get_manifest_config(self, key: str):
-        """从manifest中读取配置"""
-        with open(self.config.manifest, "r", encoding="utf-8") as fp:
-            manifest = yaml.load(fp, yaml.FullLoader)
-        keys = key.split("/")
-        for k in keys:
-            manifest = manifest.get(k, None)
-            if manifest is None:
-                return None
-        return manifest
+    def get_manifest_config(self, key: str, default=None):
+        return self.config.get_manifest_config(key, default)
 
     def load_manifest(self):
         """加载manifest.yml并验证schema文件"""
-        return load_yml_with_json_schema_validate(self.config.manifest, "/usr/share/litebmc/schema/pdf.v1.json")
+        return self.config.load_manifest()

{lbkit-0.6.1 → lbkit-0.6.3}/lbkit/misc.py

@@ -5,6 +5,7 @@ import json
 import yaml
 import re
 import requests
+from string import Template
 from colorama import Fore, Style
 from jsonschema import validate, ValidationError
 from lbkit.errors import PackageConfigException, HttpRequestException
@@ -80,7 +81,7 @@ def load_json_schema(schema_file):
             tmp = fp.read()
             return json.loads(tmp)
 
-def load_yml_with_json_schema_validate(yml_file, default_json_schema_file):
+def load_yml_with_json_schema_validate(yml_file, default_json_schema_file, **kwargs):
     """使用json schema文件校验yml_file配置文件"""
     schema_file = get_json_schema_file(yml_file, default_json_schema_file)
     if schema_file is None:
@@ -89,8 +90,10 @@ def load_yml_with_json_schema_validate(yml_file, default_json_schema_file):
     schema = load_json_schema(schema_file)
     try:
         fp = open(yml_file, "r")
-        data = yaml.safe_load(fp)
+        template = Template(fp.read())
         fp.close()
+        content = template.safe_substitute(kwargs)
+        data = yaml.safe_load(content)
         validate(data, schema)
         return data
     except ValidationError as exc:

lbkit-0.6.3/lbkit/utils/__init__.py

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

lbkit-0.6.3/lbkit/utils/images/__init__.py

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

lbkit-0.6.3/lbkit/utils/images/emmc.py

@@ -0,0 +1,109 @@
+"""环境准备"""
+import os
+import tempfile
+from lbkit import errors
+from lbkit.tools import Tools
+
+
+src_cwd = os.path.split(os.path.realpath(__file__))[0]
+
+class MakeImage():
+    def __init__(self, tmp_dir):
+        self.tools = Tools("make emmc_image")
+        self.log = self.tools.log
+        self.size_1m = 4096
+        self.misc_blk_1k = 1024
+        self.ubootenv_blk_1k = 1024
+        self.vbmeta_blk_1k = 1024
+        # 会创建3个rootfs镜像
+        self.rootfs_blk_1m = 1024
+        # 用户数据区最小512m
+        self.userdata_blk_1m = 512
+        self.tmp_dir = tmp_dir
+        if not os.path.isdir(tmp_dir):
+            os.makedirs(self.tmp_dir)
+        else:
+            cmd = "umount " + tmp_dir
+            self.tools.exec(cmd, ignore_error=True, echo_cmd=False)
+
+    def run(self, dtb, rootfs, output="emmc.img"):
+        blk_1k = self.misc_blk_1k + self.ubootenv_blk_1k + self.vbmeta_blk_1k
+        blk_1k += self.rootfs_blk_1m * 1024 * 3
+        blk_1k += self.userdata_blk_1m * 1024
+        if self.size_1m * 1024 < blk_1k:
+            blk_1m = int((blk_1k + 1023) / 1024)
+            raise errors.LiteBmcException(f"参数检测错误，镜像文件{self.size_1m}M小于需要的{blk_1m}M大小")
+        if self.userdata_blk_1m == 512:
+            self.userdata_blk_1m = int(self.size_1m - blk_1k / 1024) - 128
+            self.log.info(f"重置userdata大小为{self.userdata_blk_1m}M")
+        if os.path.isfile(output):
+            os.unlink(output)
+        self.log.info(f"创建一个{self.size_1m}M大小的镜像")
+        self.tools.exec(f"dd if=/dev/zero of={output} bs=1M count=1 seek={self.size_1m -1}")
+        self.tools.exec(f"parted {output} mktable gpt")
+        start = 4096
+        end = start + self.misc_blk_1k * 2
+        self.log.info(f"创建misc区")
+        self.tools.exec(f"parted {output} mkpart misc {start}s {end - 1}s")
+        start = end
+        end += self.ubootenv_blk_1k * 2
+        self.log.info(f"创建ubootenv区")
+        self.tools.exec(f"parted -s -a none {output} mkpart ubootenv {start}s {end - 1}s")
+        start = end
+        end += self.vbmeta_blk_1k * 2
+        self.log.info(f"创建vbmeta区")
+        self.tools.exec(f"parted -s -a none {output} mkpart vbmeta {start}s {end - 1}s")
+        start = end
+        end += self.rootfs_blk_1m * 1024 * 2
+        self.log.info("创建rootfs镜像区")
+        self.tools.exec(f"parted -s -a none {output} mkpart rootfs_a {start}s {end - 1}s")
+        self.log.info(f"挂载rootfs分区并复制内容，注意，此时会修改原始{rootfs}镜像并添加dtb以及启动参数")
+        self.tools.exec(f"fuse2fs {rootfs} {self.tmp_dir} -o fakeroot -o nonempty")
+        extlinux = os.path.join(self.tmp_dir, "boot/extlinux")
+        os.makedirs(extlinux, exist_ok=True)
+        with open(os.path.join(extlinux, "extlinux.conf"), "w+") as fp:
+            fp.write("menu title U-Boot menu\n")
+            fp.write("prompt 0\n")
+            fp.write("timeout 10\n")
+            fp.write("\n")
+            fp.write("label litebmc-active\n")
+            fp.write("    kernel /boot/Image\n")
+            fp.write("    fdt /boot/litebmc.dtb\n")
+            fp.write("    append console=ttyAMA0 loglevel=10 rootwait root=/dev/nvme0n1p4 rw\n")
+        self.tools.exec(f"cp {dtb} {self.tmp_dir}/boot/litebmc.dtb")
+        self.tools.exec(f"chown 0:0 {self.tmp_dir}/boot/ -R")
+        self.tools.exec(f"chmod 700 {self.tmp_dir}/boot/extlinux/")
+        self.tools.exec(f"chmod 600 {self.tmp_dir}/boot/extlinux/extlinux.conf")
+        self.tools.exec(f"chmod 600 {self.tmp_dir}/boot/Image")
+        self.tools.exec(f"chmod 600 {self.tmp_dir}/boot/litebmc.dtb")
+        self.tools.exec(f"umount {self.tmp_dir}")
+        self.log.info("复制镜像文件到rootfs_a区域")
+        self.tools.exec(f"dd if={rootfs} of={output} bs=512 seek={start} conv=notrunc")
+        self.log.info("制作rootfs_b")
+        start = end
+        end += self.rootfs_blk_1m * 1024 * 2
+        self.tools.exec(f"parted -s -a none {output} mkpart rootfs_b {start}s {end - 1}s")
+        self.log.info("复制镜像文件到rootfs_b")
+        self.tools.exec(f"dd if={rootfs} of={output} bs=512 seek={start} conv=notrunc")
+        self.log.info("制作rootfs_c")
+        start = end
+        end += self.rootfs_blk_1m * 1024 * 2
+        self.tools.exec(f"parted -s -a none {output} mkpart rootfs_c {start}s {end - 1}s")
+        self.log.info("复制镜像文件到rootfs_c")
+        self.tools.exec(f"dd if={rootfs} of={output} bs=512 seek={start} conv=notrunc")
+        start = end
+        self.log.info("制作userdata区")
+        end += self.userdata_blk_1m * 1024 * 2
+        self.tools.exec(f"parted -s -a none {output} mkpart userdata ext4 {start}s {end - 1}s")
+        self.log.info("为userdata区创建一个空镜像")
+        tmpfile = tempfile.NamedTemporaryFile()
+        empty_img = tmpfile.name
+        self.tools.exec(f"dd if=/dev/zero of={empty_img} bs=1M seek={self.userdata_blk_1m - 1} count=1")
+        self.tools.exec(f"mkfs.ext4 {empty_img}")
+        self.log.info("复制空镜像到userdata区")
+        self.tools.exec(f"dd if={empty_img} of={output} bs=512 seek={start} conv=notrunc")
+        self.tools.exec(f"parted {output} set 4 boot on")
+
+if __name__ == "__main__":
+    mk = MakeImage()
+    mk.run("./Image", "./virt.dtb", "./rootfs.img", "./qemu.img")

{lbkit-0.6.1 → lbkit-0.6.3/lbkit.egg-info}/PKG-INFO

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

{lbkit-0.6.1 → lbkit-0.6.3}/lbkit.egg-info/SOURCES.txt

@@ -47,6 +47,9 @@ lbkit/integration/build_rootfs.py
 lbkit/integration/config.py
 lbkit/integration/task.py
 lbkit/integration/template/conanfile.py.mako
+lbkit/utils/__init__.py
+lbkit/utils/images/__init__.py
+lbkit/utils/images/emmc.py
 test/__init__.py
 test/test_codegen.py
 test/test_helper.py

lbkit-0.6.1/lbkit/__init__.py

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

lbkit-0.6.1/lbkit/integration/build_image.py

@@ -1,89 +0,0 @@
-"""环境准备"""
-import os
-import tempfile
-import tarfile
-import shutil
-from lbkit.integration.config import Config
-from lbkit.integration.task import Task
-from lbkit.log import Logger
-from lbkit import errors
-
-log = Logger("build_image")
-
-src_cwd = os.path.split(os.path.realpath(__file__))[0]
-
-class BuildImage(Task):
-    def download_uboot(self, img_file):
-        tar_file = os.path.join(self.config.download_path, "uboot.tar.gz")
-
-        url = self.get_manifest_config("components/uboot/url")
-        sha256 = None
-        if not self.config.not_check_download_sha:
-            sha256 = self.get_manifest_config("components/uboot/sha256")
-        self.tools.download(url, tar_file, sha256)
-        tar = tarfile.open(tar_file)
-        members = tar.getmembers()
-        for member in members:
-            if not member.isfile():
-                continue
-            if member.name != "uboot.bin" and member.name != "u-boot.bin":
-                continue
-            io = tar.extractfile(member)
-            fp = open(img_file, "wb+")
-            while True:
-                buf = io.read(65536)
-                if len(buf) == 0:
-                    break
-                fp.write(buf)
-            fp.close()
-            return
-        raise errors.ExtractRootfsTarFileError("Extract failed, the u-boot.bin can't be found in " + url)
-
-    def download_kernel(self, img_file):
-        tar_file = os.path.join(self.config.download_path, "kernel.tar.gz")
-
-        url = self.get_manifest_config("components/kernel/url")
-        sha256 = None
-        if not self.config.not_check_download_sha:
-            sha256 = self.get_manifest_config("components/kernel/sha256")
-        self.tools.download(url, tar_file, sha256)
-        tar = tarfile.open(tar_file)
-        members = tar.getmembers()
-        for member in members:
-            if not member.isfile():
-                continue
-            if member.name != "Image":
-                continue
-            io = tar.extractfile(member)
-            fp = open(img_file, "wb+")
-            while True:
-                buf = io.read(65536)
-                if len(buf) == 0:
-                    break
-                fp.write(buf)
-            fp.close()
-            return
-        raise errors.ExtractRootfsTarFileError("Extract failed, the Image can't be found in " + url)
-
-    def run(self):
-        """任务入口"""
-        """检查manifest文件是否满足schema格式描述"""
-        os.chdir(self.config.output_path)
-        self.download_uboot("u-boot.bin")
-        self.download_kernel("Image")
-        cmd = "qemu-system-aarch64 -M virt -cpu cortex-a57 -M virt,dumpdtb=virt.dtb"
-        self.exec(cmd)
-
-        cmd = 'lbpack_emmc.sh ./Image ./virt.dtb ./rootfs.img ./qemu.img'
-        self.exec(cmd)
-        cmd = 'cp /usr/share/litebmc/qemu.conf ./qemu.conf'
-        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")
-
-if __name__ == "__main__":
-    config = Config()
-    build = BuildImage(config)
-    build.run()