strepsiades
256 lines
8.0 KiB
Python
256 lines
8.0 KiB
Python
from abc import ABC, abstractmethod
|
|
from typing import TypeVar, Generic, Type, Dict, List, Optional, Any
|
|
from pydantic import BaseModel
|
|
import logging
|
|
from pathlib import Path
|
|
|
|
from ..common.collection import DataCollection
|
|
from ..common.binding import BindingManager
|
|
from ..common.sync_node import SyncNode
|
|
from .config import StrategyConfig, OrphanAction, UpdateDirection
|
|
from ..config.strategy_config import resolve_domain_option_config
|
|
from .strategy_ops import (
|
|
run_bind,
|
|
run_create,
|
|
run_delete,
|
|
)
|
|
from .strategy_ops.update_ops import (
|
|
collect_bound_node_pairs,
|
|
default_get_node_update_payload,
|
|
default_needs_update,
|
|
default_update_pair,
|
|
prepare_directional_update,
|
|
run_update,
|
|
)
|
|
from ..engine import (
|
|
StateMachineConfig,
|
|
StateMachineRuntime,
|
|
)
|
|
from .strategy_ops.compare_ops import normalized_data_for_compare
|
|
|
|
T = TypeVar("T", bound=BaseModel)
|
|
logger = logging.getLogger(__name__)
|
|
|
|
class BaseSyncStrategy(ABC, Generic[T]):
|
|
"""
|
|
同步策略抽象接口。
|
|
|
|
子类可以通过覆盖以下类变量提供静态配置：
|
|
```python
|
|
class ProjectStrategy(DefaultSyncStrategy):
|
|
default_config = StrategyConfig(
|
|
auto_bind_fields=["name", "code"],
|
|
local_orphan_action=OrphanAction.CREATE_REMOTE
|
|
)
|
|
schema = ProjectResponse
|
|
```
|
|
|
|
跳过同步控制：
|
|
skip_sync: bool - 如果为 True，则跳过该类型的 bind/create/update/sync 阶段
|
|
数据仍会被加载，但不会执行任何同步操作
|
|
适用于只需要加载数据供其他类型引用的场景（如 supplier）
|
|
skip_post_check: bool - 如果为 True，则跳过该类型最终 post-check 的 reload 与一致性校验
|
|
"""
|
|
default_config: StrategyConfig
|
|
domain_option_model: Type[BaseModel] | None
|
|
schema: Type[T]
|
|
node_type: str
|
|
config: StrategyConfig
|
|
sm_runtime: Optional[StateMachineRuntime]
|
|
|
|
@abstractmethod
|
|
def __init__(
|
|
self,
|
|
node_type: str,
|
|
local_collection: DataCollection,
|
|
remote_collection: DataCollection,
|
|
binding_manager: BindingManager,
|
|
):
|
|
pass
|
|
|
|
@abstractmethod
|
|
async def bind(self, **kwargs):
|
|
"""进行绑定逻辑判定，设置 node.binding_status 和 node.action"""
|
|
pass
|
|
|
|
@abstractmethod
|
|
async def create(self) -> List[SyncNode]:
|
|
"""准备 CREATE 操作"""
|
|
pass
|
|
|
|
@abstractmethod
|
|
async def update(self) -> List[SyncNode]:
|
|
"""准备 UPDATE 操作"""
|
|
pass
|
|
|
|
@abstractmethod
|
|
async def delete(self) -> List[SyncNode]:
|
|
pass
|
|
|
|
@property
|
|
@abstractmethod
|
|
def skip_sync(self) -> bool:
|
|
pass
|
|
|
|
@property
|
|
@abstractmethod
|
|
def skip_post_check(self) -> bool:
|
|
pass
|
|
|
|
@abstractmethod
|
|
def normalize_compare_payload(
|
|
self,
|
|
data: Optional[Dict[str, Any]],
|
|
data_id_map: Optional[Dict[str, str]] = None,
|
|
) -> Dict[str, Any]:
|
|
pass
|
|
|
|
|
|
class DefaultSyncStrategy(BaseSyncStrategy[T]):
|
|
"""
|
|
基于 STATE_DEFINITIONS.md 实现的标准化同步策略。
|
|
采用四阶段管线：核心状态 -> 依赖检查 -> 自动匹配 -> 动作映射。
|
|
"""
|
|
|
|
default_config: StrategyConfig = StrategyConfig()
|
|
domain_option_model: Type[BaseModel] | None = None
|
|
schema: Type[T] = None # type: ignore
|
|
|
|
def __init__(
|
|
self,
|
|
node_type: str,
|
|
local_collection: DataCollection,
|
|
remote_collection: DataCollection,
|
|
binding_manager: BindingManager,
|
|
):
|
|
if self.schema is None:
|
|
raise ValueError(f"{self.__class__.__name__} must define schema as a class variable")
|
|
|
|
self.node_type = node_type
|
|
self.local_collection = local_collection
|
|
self.remote_collection = remote_collection
|
|
self.binding_manager = binding_manager
|
|
self.config = self.default_config.model_copy(deep=True)
|
|
self.sm_runtime: Optional[StateMachineRuntime] = None
|
|
self.config.domain_option = resolve_domain_option_config(
|
|
self.domain_option_model,
|
|
self.config.domain_option,
|
|
)
|
|
|
|
self.config.log_logic_warnings(node_type=self.node_type, logger=logger)
|
|
|
|
@classmethod
|
|
def get_default_domain_option(cls) -> Dict[str, Any]:
|
|
return resolve_domain_option_config(cls.domain_option_model, None)
|
|
|
|
def _validate_domain_option(self, domain_option: Optional[Dict[str, Any]]) -> BaseModel | Dict[str, Any]:
|
|
if self.domain_option_model is None:
|
|
return dict(domain_option or {})
|
|
return self.domain_option_model.model_validate(domain_option or {})
|
|
|
|
@property
|
|
def domain_option(self) -> BaseModel | Dict[str, Any]:
|
|
return self._validate_domain_option(self.config.domain_option)
|
|
|
|
@property
|
|
def skip_sync(self) -> bool:
|
|
return bool(self.config.skip_sync)
|
|
|
|
@skip_sync.setter
|
|
def skip_sync(self, value: bool) -> None:
|
|
self.config.skip_sync = bool(value)
|
|
|
|
@property
|
|
def skip_post_check(self) -> bool:
|
|
return bool(self.config.skip_post_check)
|
|
|
|
@skip_post_check.setter
|
|
def skip_post_check(self, value: bool) -> None:
|
|
self.config.skip_post_check = bool(value)
|
|
|
|
def ensure_runtime(self) -> StateMachineRuntime:
|
|
runtime = self.sm_runtime
|
|
if runtime is None:
|
|
cfg_path = Path(__file__).resolve().parents[1] / "config" / "node_state_machine.yaml"
|
|
runtime = StateMachineRuntime(StateMachineConfig.load(cfg_path))
|
|
self.sm_runtime = runtime
|
|
self.local_collection.set_state_machine_runtime(runtime)
|
|
self.remote_collection.set_state_machine_runtime(runtime)
|
|
return runtime
|
|
|
|
def normalize_compare_payload(
|
|
self,
|
|
data: Optional[Dict[str, Any]],
|
|
data_id_map: Optional[Dict[str, str]] = None,
|
|
) -> Dict[str, Any]:
|
|
normalized = normalized_data_for_compare(
|
|
data,
|
|
data_id_map,
|
|
ignore_fields=set(self.config.compare_ignore_fields),
|
|
ignore_list_item_fields=self.config.post_check_ignore_list_item_fields,
|
|
)
|
|
return normalized
|
|
|
|
async def bind(self, **kwargs):
|
|
self.ensure_runtime()
|
|
await run_bind(self, **kwargs)
|
|
|
|
async def create(self) -> List[SyncNode]:
|
|
self.ensure_runtime()
|
|
return await run_create(self)
|
|
|
|
async def update(self) -> List[SyncNode]:
|
|
self.ensure_runtime()
|
|
return await run_update(self)
|
|
|
|
def get_node_update_payload(self, node: SyncNode) -> Dict[str, Any]:
|
|
return default_get_node_update_payload(node)
|
|
|
|
def should_update_pair(
|
|
self,
|
|
source_node: SyncNode,
|
|
target_node: SyncNode,
|
|
*,
|
|
source_data: Dict[str, Any],
|
|
target_data: Dict[str, Any],
|
|
data_id_map: Optional[Dict[str, str]] = None,
|
|
) -> bool:
|
|
return default_needs_update(self, source_data, target_data, data_id_map)
|
|
|
|
async def collect_update_pairs(self):
|
|
return await collect_bound_node_pairs(self)
|
|
|
|
async def prepare_update_for_direction(
|
|
self,
|
|
local_node: SyncNode,
|
|
remote_node: SyncNode,
|
|
direction: UpdateDirection,
|
|
data_id_map: Optional[Dict[str, str]] = None,
|
|
*,
|
|
include_fields: Optional[List[str]] = None,
|
|
exclude_fields: Optional[List[str]] = None,
|
|
) -> Optional[SyncNode]:
|
|
return await prepare_directional_update(
|
|
self,
|
|
local_node=local_node,
|
|
remote_node=remote_node,
|
|
direction=direction,
|
|
data_id_map=data_id_map,
|
|
include_fields=include_fields,
|
|
exclude_fields=exclude_fields,
|
|
)
|
|
|
|
async def update_pair(
|
|
self,
|
|
local_node: SyncNode,
|
|
remote_node: SyncNode,
|
|
data_id_map: Optional[Dict[str, str]] = None,
|
|
) -> List[SyncNode]:
|
|
return await default_update_pair(self, local_node, remote_node, data_id_map)
|
|
|
|
async def delete(self) -> List[SyncNode]:
|
|
self.ensure_runtime()
|
|
return await run_delete(self)
|
|
|
|
|