+[-] AlkaidReleaseFlow [✕ ]
+ [-] PhaseEnv [✕ ]
+ [-] Pre [✓ ]
+ [-] Process [✕ ]
+ --> plugins.baseline.phase_env._PhaseEnv_Process [✕ ]
+ [-] Post [- ]
+ [-] PhaseConfig [- ]
+ [-] Pre [- ]
+ [-] Process [- ]
+ [-] Post [- ]
+ [-] PhaseBuild [- ]
+ [-] Pre [- ]
+ [-] Process [- ]
+ [-] Post [- ]
+ [-] PhaseCheck [- ]
+ [-] Pre [- ]
+ [-] Process [- ]
+ [-] Post [- ]
+ [-] PhasePackage [- ]
+ [-] Pre [- ]
+ [-] Process [- ]
+ [-] Post [- ]
+ [-] PhaseVerify [- ]
+ [-] Pre [- ]
+ [-] Process [- ]
+ [-] Post [- ]
+
\ No newline at end of file
diff --git a/configs/customer_test.yaml b/configs/customer_test.yaml
new file mode 100644
index 0000000..c1d5a32
--- /dev/null
+++ b/configs/customer_test.yaml
@@ -0,0 +1,141 @@
+ConfigList:
+ - ipc_iford.nor.glibc-11.1.0-squashfs.ssc029a.512.bga12_ddr4_defconfig
+ - ipc-rtos_iford.spinand.glibc-11.1.0-ramdisk.ssc029a.512.bga12_ddr4_defconfig
+MiReleaseList: []
+MhalReleaseList: []
+
+RtosReleaseList:
+ - coremark
+ - common
+ - font
+ - iqserver
+ - disp_app
+ - dualos_pipeline
+ - aov_preload
+ - cm4_preload
+ - preload_rtos
+ - preload_sample
+ - lvgl
+ - usb_gadget_app
+ - aesdma
+ - bdma
+ - camclk
+ - cpufreq
+ - drvutil
+ - emac
+ - fcie
+ - flash
+ - fsp_qspi
+ - gpio
+ - i2c
+ - input
+ - int
+ - ir
+ - kernel
+ - loadns
+ - miu
+ - mmupte
+ - mspi
+ - msys
+ - padmux
+ - pwm
+ - rtc
+ - rtcpwc
+ - saradc
+ - sdmmc
+ - str
+ - timer
+ - tsensor
+ - uart
+ - voltage
+ - watchdog
+ - algo
+ - decompress
+ - freertos_plus_fat
+ - lwfs
+ - proxyfs
+ - tcpip
+ - arm
+ - riscv
+ - libc
+ - newlib_stub
+ - cam_dev_wrapper
+ - cam_drv_poll
+ - cam_fs_wrapper
+ - cam_os_wrapper
+ - cam_proc_wrapper
+ - env_util
+ - initcall
+ - loadable_module
+ - memmang
+ - memmap
+ - mempool
+ - MsWrapper
+ - newlib_stub
+ - freertos_main
+ - freertos_posix
+ - sys_I_SW
+
+
+PmRtosReleaseList:
+ - pm_aesdma
+ - pm_bdma
+ - pm_camclk
+ - pm_cpufreq
+ - pm_drvutil
+ - pm_loadns
+ - pm_emac
+ - pm_flash
+ - pm_fsp_qspi
+ - pm_gpio
+ - pm_i2c
+ - pm_int
+ - pm_ir
+ - pm_kernel
+ - pm_miu
+ - pm_mmupte
+ - pm_mspi
+ - pm_msys
+ - pm_padmux
+ - pm_pcie
+ - pm_pl011
+ - pm_mhal_pm_clk
+ - pm_pm_idle
+ - pm_mhal_pm_mbx
+ - pm_rtcpwc
+ - pm_mhal_pm_sys
+ - pm_mhal_pm_wdt
+ - pm_pspi
+ - pm_pwm
+ - pm_pm_power
+ - pm_rtc
+ - pm_rtcpwc
+ - pm_saradc
+ - pm_sdmmc
+ - pm_timer
+ - pm_tsensor
+ - pm_uart
+ - pm_voltage
+ - pm_watchdog
+ - pm_decompress
+ - pm_freertos_plus_fat
+ - pm_lwfs
+ - pm_proxyfs
+ - pm_tcpip
+ - pm_arm
+ - pm_riscv
+ - pm_cam_dev_wrapper
+ - pm_cam_drv_poll
+ - pm_cam_fs_wrapper
+ - pm_cam_os_wrapper
+ - pm_cam_proc_wrapper
+ - pm_env_util
+ - pm_initcall
+ - pm_libc
+ - pm_memmang
+ - pm_memmap
+ - pm_mempool
+ - pm_MsWrapper
+ - pm_freertos
+ - pm_freertos_posix
+ - pm_sys_I_SW
diff --git a/core/behavior_tree.py b/core/behavior_tree.py
new file mode 100644
index 0000000..63620f5
--- /dev/null
+++ b/core/behavior_tree.py
@@ -0,0 +1,214 @@
+import os, sys
+from abc import ABC, abstractmethod
+from enum import Enum
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+from core.defines import ReleaseErr
+from thirdparty.py_trees.behaviour import Behaviour
+from thirdparty.py_trees.common import Access
+from thirdparty.py_trees.composites import Selector, Parallel, Sequence, Composite
+# from thirdparty.py_trees.decorators import Decorator
+from thirdparty.py_trees import blackboard
+from thirdparty.py_trees.common import ParallelPolicy
+from thirdparty.py_trees.behaviour import Behaviour
+import typing
+from core.logger import get_logger
+
+log = get_logger()
+
+class ReleaseFlowBlackboard(blackboard.Client):
+ """
+ 重载blackboard.Client用于适配一些我们的需求
+ 每个节点访问其所需要的数据的时候都需要先进行注册，注册之后方可访问
+ """
+ def register_key(self, key: str, access: Access = Access.WRITE, required: bool=False, remap_to: str=None):
+ """
+ 重写register_key方法，用于注册key,默认具备可读可写的属性
+ """
+ super().register_key(key=key, access=access, required=required, remap_to=remap_to)
+
+ def require_key(self, key: str):
+ """
+ 强制要求key存在
+ """
+ self.register_key(key=key, access=Access.WRITE, required=True)
+
+class ReleaseFlowAction(Behaviour, ABC):
+ """
+ Release Flow 中的最小单元，其本质是一个Behaviour Tree的节点
+ 继承了py_trees.behaviour.Behaviour的接口
+ 同时针对我们的Release Flow添加了一些实现的细节
+ - setup() 方法用于初始化节点。需要主动调用
+ - process() 方法在每次节点开始执行时调用。
+ - update() 方法是节点的核心逻辑，返回节点的状态（SUCCESS, FAILURE, RUNNING）。
+ - shutdown() 方法用于清理节点。和setup()成对使用
+ """
+ def __init__(self, name: str, description: str = ""):
+ Behaviour.__init__(self, name)
+ # blackboard 是所有 flow action 共享的，每个action自己注册自己需要的key
+ self.blackboard = self.attach_blackboard_client(name=name)
+ self.description = description
+
+ # 重写attach_blackboard_client方法，用于创建ReleaseFlowBlackboard实例
+ def attach_blackboard_client(self, name: str=None, namespace: str=None
+ ) -> ReleaseFlowBlackboard:
+ if name is None:
+ count = len(self.blackboards)
+ name = self.name if (count == 0) else self.name + "-{}".format(count)
+ new_blackboard = ReleaseFlowBlackboard(
+ name=name,
+ namespace=namespace
+ )
+ self.blackboards.append(new_blackboard)
+ return new_blackboard
+
+ # 子类可以重写setup方法，用于初始化
+ def setup(self):
+ pass
+
+ @abstractmethod
+ def update(self):
+ pass
+
+ def initialise(self):
+ """
+ Behaviour 基类中每次tick都会call该函数执行实际的业务逻辑，我们为了方便理解，将名字改为process，
+ 只要子类实现了process方法，就可以在Release Flow中使用
+ """
+ try:
+ self.process()
+ except Exception as e:
+ from thirdparty.py_trees.common import Status
+ self.status = Status.FAILURE
+ log.error(f"Action {self.name} 执行失败: {str(e)}")
+
+ @abstractmethod
+ def process(self):
+ """
+ 子类实现process以用于实际的业务逻辑
+ """
+ pass
+
+def ReleaseFlowActionDecorator(cls):
+ """
+ 装饰器，用于自动生成行为树节点的名称，并自动处理__init__函数
+ 目的就是为了使得自动生成一个name，而不需要手动去写
+ 使用方法：
+ @ReleaseFlowActionDecorator
+ class MyAction(ReleaseFlowAction):
+ pass
+ """
+ # 保存原始的__init__（如果存在的话）
+ original_init = cls.__init__ if '__init__' in cls.__dict__ else None
+ # 如果不是ReleaseFlowAction的子类，则不进行装饰
+ if not issubclass(cls, ReleaseFlowAction):
+ return cls
+
+ def new_init(self, name:str=None, description:str=''):
+ if name is None:
+ name = f"{self.__module__}.{self.__class__.__name__}"
+ # 如果原始类有自定义的__init__，则调用它
+ if original_init:
+ original_init(self, name, description)
+ else:
+ super(cls, self).__init__(name, description)
+
+ cls.__init__ = new_init
+ return cls
+
+
+class ReleaseFlowBuilder:
+ """行为树构建器"""
+ def __init__(self):
+ self.current_node = None
+ self.root = None
+ self.node_stack = []
+
+ def sequence(self, name: str, description: str = "") -> 'ReleaseFlowBuilder':
+ """创建序列节点"""
+ if isinstance(name, Enum):
+ name = name.value
+ node = Sequence(name, description)
+ self._add_node(node)
+ self.node_stack.append(node)
+ return self
+
+ def selector(self, name: str, description: str = "") -> 'ReleaseFlowBuilder':
+ """创建选择节点"""
+ if isinstance(name, Enum):
+ name = name.value
+ node = Selector(name, description)
+ self._add_node(node)
+ self.node_stack.append(node)
+ return self
+
+ def parallel(self, name: str, description: str = "",
+ policy: ParallelPolicy.Base = ParallelPolicy.SuccessOnAll(),
+ children: typing.List[Behaviour] = None) -> 'ReleaseFlowBuilder':
+ """创建并行节点"""
+ if isinstance(name, Enum):
+ name = name.value
+ node = Parallel(name, policy, children)
+ self._add_node(node)
+ self.node_stack.append(node)
+ return self
+
+ def action(self, action: ReleaseFlowAction) -> 'ReleaseFlowBuilder':
+ """创建动作节点"""
+ if isinstance(action, list):
+ for a in action:
+ self._add_node(a)
+ else:
+ self._add_node(action)
+ return self
+
+ def end(self) -> 'ReleaseFlowBuilder':
+ """结束当前复合节点或装饰器节点"""
+ if self.node_stack:
+ self.node_stack.pop()
+ return self
+
+ def build(self) -> Behaviour:
+ """构建并返回行为树根节点"""
+ if not self.root:
+ raise ReleaseErr("No nodes added to behavior tree")
+
+ # 确保所有节点都已关闭
+ if self.node_stack:
+ raise ReleaseErr(f"Unclosed nodes: {[node.name for node in self.node_stack]}")
+
+ return self.root
+
+ def _add_node(self, node: Behaviour):
+ """添加节点到当前位置"""
+ if not self.root:
+ # 第一个节点作为根节点
+ self.root = node
+ self.current_node = node
+ return
+
+ if not self.node_stack:
+ # 如果没有开放的节点，直接替换根节点
+ self.root = node
+ self.current_node = node
+ return
+
+ parent = self.node_stack[-1]
+
+ # 将节点添加到父节点
+ if isinstance(parent, Composite):
+ parent.add_child(node)
+ else:
+ raise ReleaseErr(f"Parent node {parent.name} is not a Composite")
+ # elif isinstance(parent, Decorator):
+ # parent.set_child(node)
+ # # 装饰器只能有一个子节点，所以自动结束
+ # if isinstance(node, (Composite, Decorator)):
+ # # 但如果子节点是复合节点或装饰器，保持它开放
+ # pass
+ # else:
+ # self.node_stack.pop()
+ # 添加如下magic函数以用于支持with语句，可简化代码编写，依靠缩进使得层次关系更加清晰
+ def __enter__(self):
+ return self
+ def __exit__(self, exc_type, exc_val, exc_tb):
+ self.end() # 结束序列
\ No newline at end of file
diff --git a/core/defines.py b/core/defines.py
new file mode 100644
index 0000000..954d76b
--- /dev/null
+++ b/core/defines.py
@@ -0,0 +1,85 @@
+from enum import Enum
+import json
+
+
+class ReleasePhase(str, Enum):
+ ENV = "PhaseEnv"
+ CONFIG = "PhaseConfig"
+ BUILD = "PhaseBuild"
+ CHECK = "PhaseCheck"
+ PACKAGE = "PhasePackage"
+ VERIFY = "PhaseVerify"
+
+
+class ProcessStep(str, Enum):
+ """
+ ReleaseFlow中每个阶段的几个执行步骤，顺序执行
+ """
+
+ PRE = "Pre"
+ PROCESS = "Process"
+ POST = "Post"
+
+
+class ReleaseErr(Exception):
+ """Release tool专用异常基类，包含错误信息和上下文"""
+
+ def __init__(self, message: str, ctx: dict = None):
+ self.message = message
+ self.ctx = ctx or {}
+ super().__init__(message)
+
+ def __str__(self):
+ return f"{self.message} (context: {self.ctx})" if self.ctx else self.message
+
+
+class Dict(dict):
+ """
+ 一个字典，支持点号访问，从xxx[xxx][xxx] 的方式转化为 xxx.xxx.xxx 的形式访问字典中的值
+ 如果key不存在，返回一个空的字典
+ """
+
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ # 将字典中的所有值递归转换为 Dict
+ for key, value in self.items():
+ if isinstance(value, dict):
+ self[key] = Dict(value)
+
+ @classmethod
+ def from_dict(cls, data: dict) -> "Dict":
+ """
+ 从普通字典创建一个 Dict 对象
+ :param data: 要转换的字典
+ :return: Dict 对象
+ """
+ return cls(data)
+
+ def __getattr__(self, key):
+ if key in self:
+ value = self[key]
+ # 如果值是字典，递归转换为 Dict
+ if isinstance(value, dict):
+ return Dict(value)
+ return value
+ # 如果key不存在，返回None
+ # return Dict()
+ raise AttributeError(f"In object not found '{key}'")
+
+ def __setattr__(self, key, value):
+ self[key] = value
+
+ def __str__(self):
+ string = json.dumps(self, indent=4)
+ return string
+
+ def __repr__(self):
+ return self.__str__()
+
+
+class List(list):
+ def __str__(self):
+ return json.dumps(self, indent=4)
+
+ def __repr__(self):
+ return self.__str__()
diff --git a/core/logger.py b/core/logger.py
new file mode 100644
index 0000000..1b4d82f
--- /dev/null
+++ b/core/logger.py
@@ -0,0 +1,82 @@
+import logging
+import sys
+import os
+
+TRACE = 5
+DEBUG = logging.DEBUG
+INFO = logging.INFO
+WARNING = logging.WARNING
+ERROR = logging.ERROR
+CRITICAL = logging.CRITICAL
+NOTSET = logging.NOTSET
+
+def get_logger(name=None):
+ if name is None:
+ name = 'alkaid_release_platform'
+ # 创建一个 logger
+ logger = logging.getLogger(name)
+ if logger.handlers:
+ return logger
+
+ #定义一个新的日志级别，用于输出trace信息
+ logging.TRACE = TRACE
+ logging.addLevelName(logging.TRACE, "TRACE")
+ def trace(self, message, *args, **kws):
+ self._log(logging.TRACE, message, args, **kws)
+ logging.Logger.trace = trace
+
+ logger.setLevel(INFO)
+ class LogColors:
+ RESET = "\033[0m"
+ TRACE = "\033[35m" # 紫色
+ DEBUG = "\033[34m" # 蓝色
+ INFO = "\033[32m" # 绿色
+ WARNING = "\033[33m" # 黄色
+ ERROR = "\033[31m" # 红色
+ CRITICAL = "\033[41m" # 红底白字
+
+ # 创建一个log的颜色格式化器，使得输出的log信息在控制台上有颜色区分
+ class ColoredFormatter(logging.Formatter):
+ def __init__(self, msg, use_color=True):
+ logging.Formatter.__init__(self, msg)
+ self.use_color = use_color
+ def format(self, record):
+ level_color = {
+ logging.TRACE: LogColors.TRACE,
+ logging.DEBUG: LogColors.DEBUG,
+ logging.INFO: LogColors.INFO,
+ logging.WARNING: LogColors.WARNING,
+ logging.ERROR: LogColors.ERROR,
+ logging.CRITICAL: LogColors.CRITICAL
+ }
+ color = level_color.get(record.levelno, LogColors.RESET)
+ message = super().format(record)
+ return f"{color}{message}{LogColors.RESET}" if os.isatty(sys.stdout.fileno()) else message
+
+ # 创建一个带颜色的控制台处理器
+ console_handler = logging.StreamHandler(sys.stdout)
+ console_handler.setLevel(INFO)
+ # 创建一个带颜色的格式化器并将其添加到处理器
+ formatter = ColoredFormatter('[%(asctime)s][%(levelname)s][%(filename)s:%(lineno)d]: %(message)s')
+ console_handler.setFormatter(formatter)
+
+ # 将处理器添加到 logger
+ logger.addHandler(console_handler)
+
+ # 定义一个方法，用于设置日志级别，并将其绑定到 logger 对象
+ def set_level(self, level):
+ lv_map = {
+ "trace":TRACE,
+ "debug":DEBUG,
+ "info":INFO,
+ "warning":WARNING,
+ "error":ERROR,
+ "critical":CRITICAL
+ }
+ level = lv_map.get(level, DEBUG)
+ for handler in self.handlers:
+ handler.setLevel(level)
+ logger.setLevel(level)
+ logging.Logger.set_level = set_level
+ return logger
+
diff --git a/core/plugin.py b/core/plugin.py
new file mode 100644
index 0000000..ee2b391
--- /dev/null
+++ b/core/plugin.py
@@ -0,0 +1,219 @@
+# core/plugin.py
+from abc import ABC, abstractmethod
+import importlib
+from enum import Enum
+import os,sys
+import pkgutil
+import inspect
+from typing import Dict, List, Type
+
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+from core.behavior_tree import ReleaseFlowAction
+from core.defines import ReleasePhase, ProcessStep, Dict
+import core.logger as logger
+log = logger.get_logger()
+
+"""
+# format: PluginName.ReleaseStep.ProcessStep
+ReleaseFlowCommon.StepEnv.Pre
+"""
+
+class PluginType(str, Enum):
+ """
+ 为插件分类，目前仅有一种插件，FLOW类型的插件用于执行Release Flow
+ """
+ FLOW = 'flow'
+
+class PluginInterface(ABC):
+ """PluginInterface 插件基类"""
+ def __init__(self, type: PluginType):
+ self.type = type
+
+ def get_type(self) -> PluginType:
+ return self.type
+
+ @abstractmethod
+ def get_version(self) -> str:
+ pass
+
+ @abstractmethod
+ def get_description(self) -> str:
+ """返回插件描述"""
+ pass
+
+class ReleaseFlowPlugin(PluginInterface, ABC):
+ """ReleaseFlowPlugin 插件基类"""
+ def __init__(self):
+ PluginInterface.__init__(self, PluginType.FLOW)
+ self.btrees:Dict = Dict()
+
+ @abstractmethod
+ def get_version(self) -> str:
+ """返回插件版本"""
+ pass
+
+ @abstractmethod
+ def get_description(self) -> str:
+ """返回插件描述"""
+ pass
+ # 支持使用.操作符访问btrees
+ def __getattr__(self, name: str) -> Dict:
+ return self.btrees[name]
+
+def ReleaseFlowPluginDecorator(cls):
+ """装饰器，用于自动注册ReleaseFlow插件， 每个 ReleaseFlowPlugin 插件上加上这个装饰器， 插件初始化时会自动搜索并注册行为树
+ Args:
+ cls: 插件类
+ Returns:
+ 插件类
+ """
+ original_init = cls.__init__
+ # 如果不是ReleaseFlowPlugin的子类，则不进行装饰
+ if not issubclass(cls, ReleaseFlowPlugin):
+ return cls
+ def behavior_tree_register(self: ReleaseFlowPlugin):
+ """
+ 搜索当前目录下的所有行为树节点，并根据命名注册到btrees中
+ """
+ def _load_actions_from_package(self, package_name: str):
+ """从包中加载插件"""
+ package = importlib.import_module(package_name)
+ for _, name, is_pkg in pkgutil.iter_modules(package.__path__, f"{package_name}."):
+ if not is_pkg:
+ _load_actions(self, name)
+ else:
+ _load_actions_from_package(self, f"{package_name}.{name}")
+ def _load_actions(self, module_name: str):
+ """加载单个behavior action"""
+ # log.debug(f"Try to check action: {module_name}")
+ module = importlib.import_module(module_name)
+ # 遍历模块中的所有属性名称
+ for attribute_name in dir(module):
+ attribute = getattr(module, attribute_name)
+ if not isinstance(attribute, type): # 检查是否是类
+ continue
+ if not issubclass(attribute, ReleaseFlowAction): # 检查是否是插件类
+ continue
+ if inspect.isabstract(attribute): # 检查是否是抽象类
+ continue
+ log.info(f"Loaded action: {attribute.__name__}")
+ self.sub_actions[attribute.__name__] = attribute
+ def discover_actions(self:ReleaseFlowPlugin):
+ module = inspect.getmodule(self)
+ path = os.path.relpath(os.path.dirname(module.__file__)).replace('/', '.')
+ # log.debug(f"Try to search action in: {path}")
+ self.sub_actions = {}
+ for _, name, is_pkg in pkgutil.iter_modules([os.path.dirname(module.__file__)]):
+ # log.trace(f"Try to load action: {name}")
+ if is_pkg:
+ _load_actions_from_package(self, f"{path}.{name}")
+ else:
+ _load_actions(self, f"{path}.{name}")
+
+ if not isinstance(self, ReleaseFlowPlugin):
+ log.warning(f"Plugin class {self.__class__.__name__} is not a ReleaseFlowPlugin")
+ raise ReleaseErr("The plugin class decorator is not a ReleaseFlowPlugin")
+ discover_actions(self)
+ for phase in ReleasePhase:
+ phase = phase.value
+ self.btrees[phase] = Dict()
+ for step in ProcessStep:
+ step = step.value
+ action_class = f"_{phase}_{step}"
+ if not self.sub_actions.get(action_class):
+ log.trace(f"Action {action_class} not found")
+ continue
+ log.debug(f"Register ReleaseFlow behavior tree node: {action_class}")
+ if not self.btrees[phase].get(step):
+ self.btrees[phase][step] = self.sub_actions[action_class]
+ else:
+ log.warning(f"Behavior tree node {action_class} already exists: {self.btrees[phase][step]}")
+ def new_init(self, *args, **kwargs):
+ original_init(self, *args, **kwargs)
+ behavior_tree_register(self)
+ # 添加标记，表示该类使用了flow action 装饰器，用于检查是否注册了行为树
+ cls._is_action_registered = True
+ cls.__init__ = new_init
+ return cls
+
+class PluginManager:
+ """插件管理器"""
+ def __init__(self, plugin_dir: str = "plugins"):
+ self.plugin_dir = plugin_dir
+ self.plugins: Dict[str, Type[PluginInterface]] = {}
+ self.loaded_plugins: Dict[str, PluginInterface] = {}
+ self.discover_plugins()
+
+ def discover_plugins(self):
+ """发现并加载所有插件"""
+ for _, name, is_pkg in pkgutil.iter_modules([self.plugin_dir]):
+ plugin_dir = f"{self.plugin_dir}.{name}"
+ log.trace(f"Try to search plugin in: {plugin_dir}")
+ if is_pkg:
+ self._load_plugins_from_package(plugin_dir)
+ else:
+ self._load_plugin(plugin_dir)
+
+ def _load_plugins_from_package(self, package_name: str):
+ """从包中加载插件"""
+ package = importlib.import_module(package_name)
+ for _, name, is_pkg in pkgutil.iter_modules(package.__path__, f"{package_name}."):
+ if not is_pkg:
+ self._load_plugin(name)
+ else:
+ self._load_plugins_from_package(f"{package_name}.{name}")
+
+ def _load_plugin(self, module_name: str):
+ """加载单个插件"""
+ module = importlib.import_module(module_name)
+ for attribute_name in dir(module):
+ plugin_class = getattr(module, attribute_name)
+ if not isinstance(plugin_class, type): # 检查是否是类
+ continue
+ if not issubclass(plugin_class, PluginInterface): # 检查是否是插件类
+ continue
+ if inspect.isabstract(plugin_class): # 检查是否是抽象类
+ continue
+ # 检查插件类是否使用了 ReleaseFlowActionRegister 装饰器
+ if issubclass(plugin_class, ReleaseFlowPlugin) and not hasattr(plugin_class, '_is_action_registered'):
+ log.warning(f"Plugin class {plugin_class.__name__} does not have the ReleaseFlowActionRegister decorator.")
+ continue
+
+ log.info(f"Loaded plugin: {plugin_class.__name__}")
+ self.plugins[plugin_class.__name__] = plugin_class
+
+ def get_plugin(self, name: str) -> PluginInterface:
+ """获取插件实例, 每个插件实例只初始化一次
+ Args:
+ name: 插件名称
+ Returns:
+ 插件实例
+ """
+ if name not in self.loaded_plugins:
+ if name in self.plugins:
+ self.loaded_plugins[name] = self.plugins[name]()
+ else:
+ raise ValueError(f"Plugin {name} not found")
+ return self.loaded_plugins[name]
+
+
+ def get_available_plugins(self) -> List[str]:
+ """获取所有可用插件名称"""
+ return list(self.plugins.keys())
+
+ def __str__(self) -> str:
+ string = ""
+ string += f"Plugin directory: {self.plugin_dir}\n"
+ string += "Available plugins:"
+ string += "[" + " \n".join(self.plugins.keys()) + "]\n"
+ string += "Loaded plugins:"
+ string += "[" + " \n".join(self.loaded_plugins.keys()) + "]\n"
+ return string
+
+ def __repr__(self) -> str:
+ return str(self)
+
+ def __getattr__(self, name: str) -> PluginInterface:
+ # 获取插件实例
+ plugin = self.get_plugin(name)
+ return plugin
\ No newline at end of file
diff --git a/core/release_flow.py b/core/release_flow.py
new file mode 100644
index 0000000..07939ac
--- /dev/null
+++ b/core/release_flow.py
@@ -0,0 +1,157 @@
+import functools
+import os,sys
+import threading
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..'))
+import thirdparty.py_trees as py_trees
+from thirdparty.py_trees.trees import BehaviourTree
+from core.behavior_tree import ReleaseFlowBuilder
+from core.plugin import PluginManager
+from core.defines import ReleasePhase, ProcessStep, ReleaseErr, Dict
+from database import *
+import core.logger as logger
+log = logger.get_logger()
+
+def draw_release_flow_status(snapshot_visitor, behaviour_tree):
+ """保存行为树状态为HTML文件"""
+ mutex = threading.Lock()
+ with mutex:
+ # timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+ filename = f"alkaid_release_flow_status.html"
+ with open(filename, 'w') as f:
+ f.write('dbPd3PYyX07AGvS`hkw%MWAP9FHbZJ8U?NrV}*BO=vurX56-OQbyUZwe&UJ@9U%M+MNNV