feat(runner): implement cluster mode with Redis-based task dispatching and registry

Introduce a distributed task execution system for gRPC runners. This includes:
- A `TaskBus` for cluster-mode task dispatching via Redis Pub/Sub.
- A `RunnerRegistry` to track active runner instances in Redis.
- Support for both standalone and cluster modes via configuration.
- Refactored `RunnerHub` and `TaskManager` to use a `TaskDispatcher` interface, decoupling task submission from local execution.
- Added distributed locking to `HotRankWorker` to ensure only one instance performs periodic hot rank recalculations in a multi-instance deployment.
- Updated dependency injection (Wire) to support the new runner components and registry.

internal/grpc/runner/task_manager.go

@@ -16,6 +16,11 @@ import (
 // TaskCallback 任务完成回调函数类型
 type TaskCallback func(result *runner.TaskResult)
 
+// TaskDispatcher 任务分发接口
+type TaskDispatcher interface {
+	DispatchTask(task *runner.Task) error
+}
+
 // PendingTask 表示一个等待处理的任务
 type PendingTask struct {
 	Task      *runner.Task
@@ -25,20 +30,20 @@ type PendingTask struct {
 
 // TaskManager 管理任务的生命周期
 type TaskManager struct {
-	mu      sync.RWMutex
-	pending map[string]*PendingTask
-	hub     *RunnerHub
-	timeout time.Duration
-	logger  *zap.Logger
+	mu         sync.RWMutex
+	pending    map[string]*PendingTask
+	dispatcher TaskDispatcher
+	timeout    time.Duration
+	logger     *zap.Logger
 }
 
 // NewTaskManager 创建新的任务管理器
-func NewTaskManager(hub *RunnerHub, timeout time.Duration, logger *zap.Logger) *TaskManager {
+func NewTaskManager(dispatcher TaskDispatcher, timeout time.Duration, logger *zap.Logger) *TaskManager {
 	return &TaskManager{
-		pending: make(map[string]*PendingTask),
-		hub:     hub,
-		timeout: timeout,
-		logger:  logger,
+		pending:    make(map[string]*PendingTask),
+		dispatcher: dispatcher,
+		timeout:    timeout,
+		logger:     logger,
 	}
 }
 
@@ -69,17 +74,10 @@ func (tm *TaskManager) SubmitTask(ctx context.Context, taskType runner.TaskType,
 		zap.String("task_id", task.TaskId),
 		zap.String("type", taskType.String()))
 
-	// 获取可用 Runner
-	conn, err := tm.hub.GetAvailableRunner(taskType)
-	if err != nil {
+	// 通过 dispatcher 分发任务
+	if err := tm.dispatcher.DispatchTask(task); err != nil {
 		tm.cleanupTask(task.TaskId)
-		return nil, fmt.Errorf("no available runner: %w", err)
-	}
-
-	// 发送任务
-	if err := tm.hub.SendTask(conn.ID, task); err != nil {
-		tm.cleanupTask(task.TaskId)
-		return nil, fmt.Errorf("failed to send task: %w", err)
+		return nil, fmt.Errorf("failed to dispatch task: %w", err)
 	}
 
 	// 启动超时检查
@@ -203,9 +201,9 @@ func (tm *TaskManager) GetPendingTaskCount() int {
 	return len(tm.pending)
 }
 
-// SetHub 设置 RunnerHub（用于解决循环依赖）
-func (tm *TaskManager) SetHub(hub *RunnerHub) {
-	tm.hub = hub
+// SetDispatcher 设置任务分发器（用于解决循环依赖）
+func (tm *TaskManager) SetDispatcher(dispatcher TaskDispatcher) {
+	tm.dispatcher = dispatcher
 }
 
 // CleanupStaleTasks 清理超时的任务