openubmc-bingo 0.6.45__py3-none-any.whl → 0.6.99__py3-none-any.whl

bmcgo/utils/fetch_component_code.py

@@ -10,14 +10,15 @@
 # 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 os
 import re
 import shutil
 import subprocess
-from multiprocessing import Pool
+from multiprocessing import Pool, Manager
 import patch_ng
 import yaml
-from git import Repo
+from git import Repo, exc
 
 from bmcgo import errors
 from bmcgo import misc
@@ -47,6 +48,7 @@ class FetchComponentCode:
              f" -r {misc.conan_remote()} --only None 2>/dev/null"
         if misc.conan_v2():
             cmd = f"conan graph info --requires='{version_range}' --filter {component_name}"
+        
         ret, output = subprocess.getstatusoutput(cmd)
         output = output.strip()
         if ret != 0 or not output:
@@ -113,15 +115,17 @@ class FetchComponentCode:
             log.info(f"{code_dir} 开始应用源码补丁{patch_file}")
             try:
                 FetchComponentCode._apply_patches_direct(real_patch, patch_file, changed_files)
-            except errors.BmcGoException:
-                # 尝试还原文件修改
+            except errors.BmcGoException as e:
                 for a_file, b_file in changed_files.items():
                     cmd = f"git checkout -- {a_file}"
                     tools.run_command(cmd, ignore_error=True)
                     cmd = f"git checkout -- {b_file}"
                     tools.run_command(cmd, ignore_error=True)
-                cmd = "git am " + real_patch
-                tools.run_command(cmd)
+                try:
+                    cmd = "git am " + real_patch
+                    tools.run_command(cmd)
+                except Exception as am_e:
+                    raise RuntimeError(f"git am 恢复补丁 {patch_file} 失败") from am_e
             log.info(f"{code_dir} 应用源码补丁{patch_file}")
         os.chdir(cwd)
 
@@ -184,6 +188,88 @@ class FetchComponentCode:
 
             return revision, url
 
+    # --- 新增：MDS修补方案 1 (Install) ---
+    @staticmethod
+    def _try_mds_install_plan(conan_version, component_name):
+        """
+        尝试使用 'conan install' 来获取 package_folder
+        """
+        log.info(f"MDS修补 (方案1: install): 正在尝试 {conan_version}...")
+        cmd_install = f"conan install --requires={conan_version} -r openubmc_dev\
+                      --build=missing -pr profile.ini --format=json --output-folder=tmp"
+        
+        command_result = tools.run_command(cmd_install, capture_output=True, ignore_error=True)
+        stdout = command_result.stdout.strip()
+        stderr = command_result.stderr.strip()
+
+        if command_result.returncode != 0 or not stdout:
+            log.warning(f"MDS修补 (方案1: install) 失败: 命令执行失败。 STDERR: {stderr}")
+            raise RuntimeError(f"Install plan failed (command error). stderr: {stderr}")
+
+        try:
+            result = json.loads(stdout)
+            nodes = result.get("graph", {}).get("nodes", {})
+            package_folder = None
+            for node in nodes.values():
+                if node.get("ref") and node.get("ref").startswith(conan_version):
+                    package_folder = node.get("package_folder")
+                    if package_folder:
+                        break
+            
+            if not package_folder:
+                log.warning(f"MDS修补 (方案1: install) 失败: 未在JSON中找到 package_folder。")
+                raise RuntimeError("Install plan failed (JSON parse).")
+            
+            log.info(f"MDS修补 (方案1: install) 成功。 找到 package_folder: {package_folder}")
+            return package_folder # 成功
+        except Exception as json_err:
+            log.warning(f"MDS修补 (方案1: install) 失败: JSON解析错误。 {json_err}")
+            raise RuntimeError(f"Install plan failed (JSON parse).") from json_err
+
+    # --- 新增：MDS修补方案 2 (Download) ---
+    @staticmethod
+    def _try_mds_download_plan(conan_version, component_name):
+        """
+        尝试使用 'conan download' (不带profile) 来获取 package_folder
+        """
+        log.warning(f"MDS修补 (方案1: install) 失败。 切换到 (方案2: download)...")
+        try:
+            cmd_download = f"conan download {conan_version} -r openubmc_dev --format=json"
+            log.info(f"MDS修补 (方案2: download): 执行: {cmd_download}")
+            command_result = tools.run_command(cmd_download, capture_output=True, ignore_error=True)
+            stdout = command_result.stdout.strip()
+            stderr = command_result.stderr.strip()
+
+            if command_result.returncode != 0 or not stdout:
+                log.error(f"MDS修补 (方案2: download) 失败: 命令执行失败。 STDERR: {stderr}")
+                raise RuntimeError(f"Download command failed. STDERR: {stderr}")
+
+            result = json.loads(stdout)
+            local_cache = result.get("Local Cache")
+            component_info = local_cache.get(conan_version)
+            revisions = component_info.get("revisions")
+            first_revision_id = next(iter(revisions))
+            first_revision_data = revisions[first_revision_id]
+            packages = first_revision_data.get("packages")
+            first_package_id = next(iter(packages))
+            full_pref = f"{conan_version}#{first_revision_id}:{first_package_id}"
+            
+            cmd_cache_path = f"conan cache path {full_pref}"
+            log.info(f"MDS修补 (方案2: download): 执行: {cmd_cache_path}")
+            path_cmd_info = tools.run_command(cmd_cache_path, capture_output=True, ignore_error=True)
+            
+            if path_cmd_info.returncode != 0 or not path_cmd_info.stdout:
+                log.error(f"MDS修补 (方案2: download) 失败: 'conan cache path' 失败。 STDERR: {path_cmd_info.stderr.strip()}")
+                raise RuntimeError(f"'conan cache path' 失败. STDERR: {path_cmd_info.stderr.strip()}")
+
+            package_folder = path_cmd_info.stdout.strip()
+            log.info(f"MDS修补 (方案2: download) 成功。 找到 package_folder: {package_folder}")
+            return package_folder # 成功
+
+        except Exception as download_e:
+            log.error(f"MDS修补 (方案2: download) 失败: {download_e}")
+            raise RuntimeError("Download plan failed.") from download_e
+
     def run(self):
         packages_to_fetch = dict()
         for component_name, package in self.packages.items():
@@ -201,14 +287,19 @@ class FetchComponentCode:
 
         process_count = min(len(packages_to_fetch), os.cpu_count())
         log.info("创建 %u 个进程拉取代码", process_count)
+
+        manager = Manager()
+        conan_lock = manager.Lock()
+        
         pool = Pool(processes=process_count)
         for component_name, conan_version in packages_to_fetch.items():
-            pool.apply_async(func=self.update_component_code, args=(component_name, conan_version),
+            pool.apply_async(func=self.update_component_code, 
+                             args=(component_name, conan_version, conan_lock),
                              error_callback=process_err_cb)
         pool.close()
         pool.join()
 
-    def update_component_code(self, component_name, conan_version):
+    def update_component_code(self, component_name, conan_version, conan_lock):
         """
         update component code by conan version
         """
@@ -219,9 +310,12 @@ class FetchComponentCode:
                 version_split = re.split(r'[/, @]', conan_version)
                 conan_dir = os.path.join(os.path.expanduser('~'), '.conan/data/', *version_split, 'export')
                 conandata = os.path.join(conan_dir, 'conandata.yml')
-                if not os.path.exists(conan_dir):
-                    conan_remote_list = tools.get_conan_remote_list(self.remote)
-                    tools.download_conan_recipes(conan_version, conan_remote_list)
+                
+                with conan_lock:
+                    if not os.path.exists(conan_dir):
+                        conan_remote_list = tools.get_conan_remote_list(self.remote)
+                        tools.download_conan_recipes(conan_version, conan_remote_list)
+                
                 if os.path.exists(conandata):
                     self.__update_component_code_by_conandata(version_split[0], version_split[1], conandata)
                     return
@@ -233,10 +327,12 @@ class FetchComponentCode:
                     return
                 log.error("conandata(%s) 和 conanfile(%s) 都没有找到", conandata, conanfile)
             else:
-                conan_remote_list = tools.get_conan_remote_list(self.remote)
-                tools.download_conan_recipes(conan_version, conan_remote_list)
-                path_cmd = f"conan cache path {conan_version}"
-                path_cmd_info = Tools().run_command(path_cmd, capture_output=True)
+                path_cmd_info = None
+                with conan_lock:
+                    conan_remote_list = tools.get_conan_remote_list(self.remote)
+                    tools.download_conan_recipes(conan_version, conan_remote_list)
+                    path_cmd = f"conan cache path {conan_version}"
+                    path_cmd_info = Tools().run_command(path_cmd, capture_output=True)
 
                 version_split = re.split(r'[/, @]', conan_version)
                 conan_dir = path_cmd_info.stdout.strip()
@@ -248,6 +344,41 @@ class FetchComponentCode:
                 log.error("conandata(%s) 没有找到", conandata)
             log.info("更新组件 %s 代码到 %s 失败, 无法获取到 conan 信息", component_name,
                      conan_version)
+        except exc.GitError as exp:
+            log.warning("Git 操作失败 (组件: %s): %s。 尝试MDS修补...", component_name, exp)
+            package_folder = None
+            
+            with conan_lock:
+                try:
+                    # --- 方案 1: install (优先) ---
+                    package_folder = FetchComponentCode._try_mds_install_plan(conan_version, component_name)
+                except Exception as install_e:
+                    # --- 方案 2: download (后备) ---
+                    try:
+                        package_folder = FetchComponentCode._try_mds_download_plan(conan_version, component_name)
+                    except Exception as download_e:
+                        # --- 两个方案都失败了 ---
+                        log.error(f"MDS修补: 方案1 和 方案2 均失败 (组件: {component_name})。")
+                        raise RuntimeError(f"MDS修补方案 'install' 和 'download' 均失败 (组件: {component_name})") from exp
+
+            # --- 复制步骤 (锁外) ---
+            if package_folder:
+                mds_src_path = f"{package_folder}/include"
+                if os.path.exists(mds_src_path):
+                    src = mds_src_path
+                    dest = os.path.abspath(f"{component_name}")
+                    shutil.copytree(src, dest, dirs_exist_ok=True)
+                    log.info(f"将组件 {component_name} 复制到 {dest}.")
+                else:
+                    log.warning(f"MDS修补: 在 {package_folder} 中未找到 'include/mds'。")
+            else:
+                # 这种情况不应该发生，因为如果两个方案都失败了，上面会抛出异常
+                log.error(f"MDS修补失败 (组件: {component_name}): 未能获取 package_folder。")
+                raise exp # 重新抛出原始 GitError
+            
+            # 清理 'install' 方案(如果成功)创建的 'tmp' 目录
+            shutil.rmtree(f"{self.target_dir}/tmp", ignore_errors=True)
+            
         except Exception as exp:
-            log.error("工作状态错误: %s", exp)
-            log.error("更新组件代码到 %s 失败", conan_version)
+            log.error("工作状态错误 (组件: %s): %s", component_name, exp)
+            log.error("更新组件 %s 代码到 %s 失败", component_name, conan_version)

bmcgo/utils/install_manager.py

@@ -38,7 +38,7 @@ class InstallManager:
     def custom_install_plan_path(self):
         return self._custom_path / install_consts.PLUGIN_INSTALL_PLAN_PATH
     
-    def init(self, app_name, operator, version, custom_path):
+    def init(self, app_name, version_range, custom_path):
         self._set_custom_path(custom_path)
 
         if app_name == install_consts.INSTALL_ALL:
@@ -54,7 +54,7 @@ class InstallManager:
                 if not inst_type:
                     raise ValueError(f"未配置 {wname}/{install_consts.PLAN_STEPS}/{install_consts.PLAN_INSTALL_TYPE}")
                 inst = BaseInstaller.get_installer(inst_type)
-                inst.init(plan, operator, version)
+                inst.init(plan, version_range)
                 self._installers.setdefault(wname, []).append(inst)
 
     def show_versions(self):

bmcgo/utils/installations/base_installer.py

@@ -86,11 +86,11 @@ class BaseInstaller(abc.ABC):
             raise ValueError(f"未定义的安装方法：{installer_type}")
         return installer_cls()
     
-    def init(self, plan, operator, version):
+    def init(self, plan, version_range):
         self.parse_plan(plan)
 
         versions = self.get_versions()
-        self.resolve_constraint(versions, operator, version)
+        self.resolve_constraint(versions, version_range)
 
         self.get_current_version()
 
@@ -113,39 +113,22 @@ class BaseInstaller(abc.ABC):
             return
         self.parse_custom_plan(plan)
 
-    def resolve_constraint(self, versions, opt, ver):
+    def resolve_constraint(self, versions, version_range):
         if not versions:
             self.warning("当前没有可下载版本!")
             return
 
-        if ver == install_consts.INSTALL_LATEST or not opt:
+        if install_consts.INSTALL_LATEST in version_range or not version_range:
             self._target_ver = versions[0]
             return
-
-        pkg_ver = PkgVersion(ver)
+        
+        import semver
         for avl_ver in versions:
-            v = PkgVersion(avl_ver)
-            if opt == ">=" and v >= pkg_ver:
-                self._target_ver = v.origin
-                break
-            elif opt == "<=" and v <= pkg_ver:
-                self._target_ver = v.origin
-                break
-            elif opt == "!=" and v != pkg_ver:
-                self._target_ver = v.origin
+            if semver.satisfies(avl_ver, version_range):
+                self._target_ver = avl_ver
                 break
-            elif opt == "<" and v < pkg_ver:
-                self._target_ver = v.origin
-                break
-            elif opt == ">" and v > pkg_ver:
-                self._target_ver = v.origin
-                break
-            elif opt == "=" and v == pkg_ver:
-                self._target_ver = v.origin
-                break
-        else:
-            self.warning(f"没有找到匹配的版本：{self._pkg_name}{opt}{ver}")
-            return
+        if not self._target_ver:
+            raise ValueError(f"没有找到匹配的版本：{self._pkg_name}{version_range}")
         
     def info(self, msg):
         self.logger and self.logger.info(f"[{self.type_name}] {msg}")

bmcgo/utils/installations/install_plans/studio.yml

@@ -3,4 +3,7 @@ install_steps:
   - type: apt
     package_name: bmc-studio
     doc: https://www.openubmc.cn/marketplace/BMC%20Studio
+  - type: apt
+    package_name: cangjie-runtime
+    doc: https://cangjie-lang.cn/docs
 

bmcgo/utils/mapping_config_patch.py

@@ -128,7 +128,7 @@ def rename_json_prop(obj, array, depth, new_key):
         elif isinstance(obj, list) and array[depth] < len(obj):
             node = obj[array[depth]]
         if node is not None:
-            remove_json_prop(node, array, depth + 1, new_key)
+            rename_json_prop(node, array, depth + 1, new_key)
 
 
 class MappingConfigPatch(Task):
@@ -351,7 +351,7 @@ class MappingConfigPatch(Task):
             target_uri = action.get("Uri")
             target_method = action.get("Method")
             if target is None or target_uri is None or target_method is None:
-                log.error(f"属性变更场景，Target、Uri、Method参数必须存在")
+                log.info(f"属性变更场景，Target、Uri、Method参数必须存在")
                 continue
             target_path = os.path.join(self.config_path, target)
             if not is_valid_path(target_path, self.config_path, True):
@@ -367,7 +367,7 @@ class MappingConfigPatch(Task):
             if flag:
                 save_json_file(target_path, target_object)
             else:
-                log.error(f"属性变更场景，没有找到Uri({target_uri})指定的配置")
+                log.info(f"属性变更场景，没有找到Uri({target_uri})指定的配置")
 
 
     def global_variables(self, global_variable):
@@ -411,7 +411,8 @@ class MappingConfigPatch(Task):
 
 
     def run(self):
-        if not os.path.isdir(self.config_patch_path):
+        ret = self.tools.run_command(f"test -d {self.config_patch_path}", ignore_error=True, sudo=True)
+        if ret.returncode != 0:
             return
 
         # 给予权限方便对文件做变更

bmcgo/utils/tools.py

@@ -67,7 +67,6 @@ class Tools():
     print_cnt = 0
 
     def __init__(self, log_name="bingo", log_file=None):
-        os.makedirs(misc.CACHE_DIR, exist_ok=True)
         self.lock_file = os.path.join(misc.CACHE_DIR, "frame_lock")
         if log_file is None:
             self.log_name = os.path.join(misc.CACHE_DIR, f"{log_name}.log")
@@ -104,6 +103,8 @@ class Tools():
 
     @property
     def conan_data(self):
+        if misc.conan_v2():
+            return os.path.join(self.conan_home, "p")
         return os.path.join(self.conan_home, "data")
 
     @staticmethod
@@ -245,16 +246,19 @@ class Tools():
         pkg_name = pkg_info[0]
         has_version = len(pkg_info) > 1
         for sub in base_manifest.get(dependency_type, {}):
+            overwrite = sub.get("overwrite", False)
             sub_name = sub.get(misc.CONAN)
             sub_pkg_name = sub_name.split("/")[0]
             # 上下层具有相同组件名的组件
             if pkg_name == sub_pkg_name:
-                if has_version:
+                if not has_version:
+                    com_package[misc.CONAN] = sub_name
+                elif overwrite:
+                    com_package[misc.CONAN] = name
+                else:
                     raise errors.BmcGoException(
                         "配置错误: 不允许删除平台组件或定制平台组件版本号{}".format(name)
                     )
-                else:
-                    com_package[misc.CONAN] = sub_name
                 break
 
     @staticmethod
@@ -630,7 +634,7 @@ class Tools():
         self.run_command(f"chown {user_group} {img_path}", sudo=True)
 
     def get_studio_path(self):
-        ret = self.run_command("whereis bmc_studio", sudo=True, ignore_error=True,
+        ret = self.run_command("whereis bmc_studio", sudo=False, ignore_error=True,
             command_echo=False, capture_output=True).stdout
         if not ret:
             return ""
@@ -676,7 +680,45 @@ class Tools():
         try:
             check = False if ignore_error else True
             if show_log:
-                ret = subprocess.run(command, check=check, timeout=timeout)
+                # 使用Popen来同时处理实时输出和日志文件写入
+                process = subprocess.Popen(
+                    command, 
+                    stdout=subprocess.PIPE, 
+                    stderr=subprocess.STDOUT,  # 将stderr合并到stdout
+                    universal_newlines=True,
+                    bufsize=1  # 行缓冲
+                )
+                
+                # 实时读取输出并同时显示和写入日志
+                output_lines = []
+                while True:
+                    line = process.stdout.readline()
+                    if not line and process.poll() is not None:
+                        break
+                    if line:
+                        # 实时显示到控制台
+                        self.log.info(line.strip())
+                        # 同时写入日志文件
+                        log_fd.write(line)
+                        log_fd.flush()
+                        output_lines.append(line)
+                
+                # 等待进程结束
+                returncode = process.wait()
+                stdout_str = ''.join(output_lines)
+                
+                # 创建类似subprocess.run的返回对象
+                ret = subprocess.CompletedProcess(
+                    args=command,
+                    returncode=returncode,
+                    stdout=stdout_str,
+                    stderr=''  # 因为stderr合并到stdout了
+                )
+                
+                # 检查返回码
+                if check and returncode != 0:
+                    raise subprocess.CalledProcessError(returncode, command, output=stdout_str)
+                    
             elif capture_output:
                 ret = subprocess.run(command, capture_output=capture_output, check=check, timeout=timeout, text=True)
                 if ret.stdout:
@@ -786,7 +828,7 @@ class Tools():
         graph_file = os.path.join(tmpdir.name, "package.json")
         cmd = f"conan install --requires='{package}' {install_args}"
         cmd += f" -f json --out-file={graph_file} -of temp"
-        self.run_command(cmd, ignore_error=False)
+        _ = self.run_command(cmd, show_log=True)
         return self.get_package_folder_from_graph_file(graph_file, package)
 
     def install_conan_package_to(self, package, install_args, outdir):

{openubmc_bingo-0.6.45.dist-info → openubmc_bingo-0.6.99.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openubmc-bingo
-Version: 0.6.45
+Version: 0.6.99
 Summary: Tools provided by openubmc
 Home-page: https://openubmc.cn
 Classifier: Programming Language :: Python :: 3