feat: backend executor implement

internal/backendupdate/updater.go

@@ -14,6 +14,8 @@ import (
 	"path/filepath"
 	"time"
 
+	"yms-daemon/internal/backendexecutor"
+	"yms-daemon/internal/containerengine"
 	"yms-daemon/internal/daemonapi"
 	"yms-daemon/internal/deploymentconfig"
 	"yms-daemon/internal/filestore"
@@ -36,16 +38,22 @@ const (
 
 // Updater executes the current native backend contract on one server.
 type Updater struct {
-	config       deploymentconfig.Config
-	workRoot     string
-	store        *transaction.Store
-	coordinator  *transaction.Coordinator
-	releaseStore *filestore.Store
-	units        systemd.Manager
-	gateway      gatewayController
-	executor     nativeExecutor
-	logger       *slog.Logger
-	drain        time.Duration
+	config                deploymentconfig.Config
+	workRoot              string
+	store                 *transaction.Store
+	coordinator           *transaction.Coordinator
+	releaseStore          *filestore.Store
+	units                 systemd.Manager
+	gateway               gatewayController
+	executor              nativeExecutor
+	containerExecutor     containerExecutor
+	engine                containerengine.Engine
+	containerConfigSource string
+	containerConfigTarget string
+	containerTmpSource    string
+	containerTmpTarget    string
+	logger                *slog.Logger
+	drain                 time.Duration
 }
 
 type gatewayController interface {
@@ -57,6 +65,10 @@ type nativeExecutor interface {
 	Run(context.Context, string, nativebackendexecutor.Request) error
 }
 
+type containerExecutor interface {
+	Run(context.Context, string, backendexecutor.Request) error
+}
+
 // New creates the complete native backend update orchestrator.
 func New(
 	config deploymentconfig.Config,
@@ -72,6 +84,9 @@ func New(
 	if err := config.Validate(); err != nil {
 		return nil, err
 	}
+	if config.Backend.Type != deploymentconfig.BackendTypeNative {
+		return nil, errors.New("backend.type must be native")
+	}
 	if !filepath.IsAbs(workRoot) || filepath.Clean(workRoot) != workRoot {
 		return nil, errors.New("backend update work root must be a clean absolute path")
 	}
@@ -99,8 +114,54 @@ func New(
 	}, nil
 }
 
+// NewContainer creates the Docker standalone backend update orchestrator.
+func NewContainer(
+	config deploymentconfig.Config,
+	workRoot string,
+	store *transaction.Store,
+	coordinator *transaction.Coordinator,
+	engine containerengine.Engine,
+	gateway gatewayController,
+	httpClient *http.Client,
+	logger *slog.Logger,
+) (*Updater, error) {
+	if err := config.Validate(); err != nil {
+		return nil, err
+	}
+	if config.Backend.Type != deploymentconfig.BackendTypeContainer {
+		return nil, errors.New("backend.type must be container")
+	}
+	if config.Daemon.Environment != deploymentconfig.EnvironmentDev {
+		return nil, errors.New("--container-image requires daemon.environment = dev")
+	}
+	if !filepath.IsAbs(workRoot) || filepath.Clean(workRoot) != workRoot {
+		return nil, errors.New("container backend update work root must be a clean absolute path")
+	}
+	if store == nil || coordinator == nil || engine == nil || gateway == nil {
+		return nil, errors.New("container backend update dependencies are required")
+	}
+	if logger == nil {
+		logger = slog.Default()
+	}
+	executor, err := backendexecutor.New(store, coordinator, engine, httpClient)
+	if err != nil {
+		return nil, err
+	}
+	return &Updater{
+		config: config, workRoot: workRoot, store: store, coordinator: coordinator, gateway: gateway,
+		containerExecutor: executor, engine: engine, logger: logger, drain: drainDuration,
+		containerConfigSource: deploymentconfig.ContainerConfigSource,
+		containerConfigTarget: deploymentconfig.ContainerConfigTarget,
+		containerTmpSource:    deploymentconfig.ContainerTmpSource,
+		containerTmpTarget:    deploymentconfig.ContainerTmpTarget,
+	}, nil
+}
+
 // UpdateRepack applies one repack ZIP selected by an absolute local path.
 func (u *Updater) UpdateRepack(ctx context.Context, packagePath string, report ProgressReporter) (transaction.Transaction, error) {
+	if u.config.Backend.Type == deploymentconfig.BackendTypeContainer {
+		return transaction.Transaction{}, errors.New("repack ZIP update is not implemented for container backend")
+	}
 	reportProgress(report, Progress{Message: "Validating repack ZIP"})
 	updatePackage, err := updatepackage.OpenBackendNative(packagePath)
 	if err != nil {
@@ -125,6 +186,9 @@ func (u *Updater) UpdateRepack(ctx context.Context, packagePath string, report P
 
 // UpdateNativeJAR applies one JAR copied directly to the server.
 func (u *Updater) UpdateNativeJAR(ctx context.Context, jarPath string, report ProgressReporter) (transaction.Transaction, error) {
+	if u.config.Backend.Type == deploymentconfig.BackendTypeContainer {
+		return transaction.Transaction{}, errors.New("--native-jar requires backend.type = native")
+	}
 	reportProgress(report, Progress{Message: "Validating direct native backend JAR and computing SHA-256"})
 	jar, err := updatepackage.OpenDirectNativeJAR(jarPath)
 	if err != nil {