526 lines
20 KiB
Go
526 lines
20 KiB
Go
package backendexecutor
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"io"
|
|
"log/slog"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"slices"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
|
|
"yms-daemon/internal/containerengine"
|
|
"yms-daemon/internal/transaction"
|
|
)
|
|
|
|
const (
|
|
// testDigest 测试中使用的固定镜像清单摘要。
|
|
testDigest = "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
|
|
// testRepository 测试中使用的镜像仓库前缀。
|
|
testRepository = "harbor.ymswell.asia/ymswell/glory-ymswell"
|
|
// healthyResponse 测试中健康检查端点返回的固定 UP 响应体。
|
|
healthyResponse = `{"status":"UP","components":{"db":{"status":"UP"},"diskSpace":{"status":"UP"},"ping":{"status":"UP"},"redis":{"status":"UP"}}}`
|
|
)
|
|
|
|
// TestExecutorPreservesOpaqueImageTagsAndReachesSwitching 验证执行器对不透明镜像标签保持原样传递，
|
|
// 并能使事务推进到 StateSwitching；同时验证在 StateSwitching 状态重复执行不会产生额外引擎调用。
|
|
func TestExecutorPreservesOpaqueImageTagsAndReachesSwitching(t *testing.T) {
|
|
tags := []string{
|
|
"20260814-093609-d7ed70f0-v1.1.8.1",
|
|
"20260814-093609-d7ed70f0",
|
|
}
|
|
for _, tag := range tags {
|
|
tag := tag
|
|
t.Run(tag, func(t *testing.T) {
|
|
ctx := context.Background()
|
|
store, coordinator := testTransactionKernel(t)
|
|
imageReference := testRepository + ":" + tag
|
|
request := testRequest(t, imageReference)
|
|
engine := newFakeEngine(request)
|
|
executor := testExecutor(t, store, coordinator, engine, healthyResponse)
|
|
record := createTransaction(t, store, "opaque-"+tag)
|
|
|
|
if err := executor.Run(ctx, record.ID, request); err != nil {
|
|
t.Fatalf("run backend executor: %v", err)
|
|
}
|
|
current, err := store.Transaction(ctx, record.ID)
|
|
if err != nil {
|
|
t.Fatalf("read completed preparation: %v", err)
|
|
}
|
|
if current.State != transaction.StateSwitching {
|
|
t.Fatalf("unexpected transaction state: %s", current.State)
|
|
}
|
|
pending, err := store.PendingSteps(ctx, record.ID)
|
|
if err != nil || len(pending) != 0 {
|
|
t.Fatalf("unexpected pending steps: steps=%+v err=%v", pending, err)
|
|
}
|
|
|
|
engine.mu.Lock()
|
|
if engine.lastCreateSpec.ImageReference != imageReference {
|
|
engine.mu.Unlock()
|
|
t.Fatalf("image reference changed: got %q want %q", engine.lastCreateSpec.ImageReference, imageReference)
|
|
}
|
|
if !slices.Contains(engine.lastCreateSpec.Environment, "SERVER_PORT=8081") || !slices.Contains(engine.lastCreateSpec.Environment, "SPRING_CONFIG_LOCATION=file:/app/config/yms.yaml") {
|
|
engine.mu.Unlock()
|
|
t.Fatalf("missing explicit port environment: %+v", engine.lastCreateSpec.Environment)
|
|
}
|
|
initialCalls := engine.callCounts()
|
|
engine.mu.Unlock()
|
|
|
|
if err := executor.Run(ctx, record.ID, request); err != nil {
|
|
t.Fatalf("repeat executor at switching state: %v", err)
|
|
}
|
|
engine.mu.Lock()
|
|
repeatedCalls := engine.callCounts()
|
|
engine.mu.Unlock()
|
|
if repeatedCalls != initialCalls {
|
|
t.Fatalf("switching state repeated engine calls: before=%+v after=%+v", initialCalls, repeatedCalls)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestExecutorRecoversRecordedCreateIntentWithoutRepeatingCreate 验证在 crash 窗口内已记录创建步骤意图后，
|
|
// 恢复执行不会重复创建容器，而是直接复用已完成的创建步骤并最终进入 StateSwitching。
|
|
func TestExecutorRecoversRecordedCreateIntentWithoutRepeatingCreate(t *testing.T) {
|
|
ctx := context.Background()
|
|
store, coordinator := testTransactionKernel(t)
|
|
request := testRequest(t, testRepository+":20260814-093609-d7ed70f0-v1.1.8.1")
|
|
engine := newFakeEngine(request)
|
|
engine.imageAvailable = true
|
|
engine.containers[request.ContainerName] = engine.containerFromSpec(containerSpec(request), false)
|
|
executor := testExecutor(t, store, coordinator, engine, healthyResponse)
|
|
record := createTransaction(t, store, "recover-create")
|
|
transitionToPrepared(t, store, record.ID)
|
|
|
|
loadStep := loadIntent(request)
|
|
if _, _, err := store.RecordStepIntent(ctx, record.ID, loadStep); err != nil {
|
|
t.Fatalf("record completed image intent: %v", err)
|
|
}
|
|
if _, err := store.CompleteStep(ctx, record.ID, loadStep.Key, transaction.StepSucceeded, []byte(`{"loaded":true}`), ""); err != nil {
|
|
t.Fatalf("complete image step: %v", err)
|
|
}
|
|
removeStep := removeIntent(request)
|
|
if _, _, err := store.RecordStepIntent(ctx, record.ID, removeStep); err != nil {
|
|
t.Fatalf("record completed remove intent: %v", err)
|
|
}
|
|
if _, err := store.CompleteStep(ctx, record.ID, removeStep.Key, transaction.StepSucceeded, []byte(`{"absent":true}`), ""); err != nil {
|
|
t.Fatalf("complete remove step: %v", err)
|
|
}
|
|
createStep := createIntent(request, engine.loadedImage.ID)
|
|
if _, _, err := store.RecordStepIntent(ctx, record.ID, createStep); err != nil {
|
|
t.Fatalf("record crash-window create intent: %v", err)
|
|
}
|
|
|
|
if err := executor.Run(ctx, record.ID, request); err != nil {
|
|
t.Fatalf("recover backend executor: %v", err)
|
|
}
|
|
engine.mu.Lock()
|
|
calls := engine.callCounts()
|
|
engine.mu.Unlock()
|
|
if calls.load != 0 || calls.remove != 0 || calls.create != 0 || calls.start != 1 {
|
|
t.Fatalf("unexpected recovery calls: %+v", calls)
|
|
}
|
|
current, err := store.Transaction(ctx, record.ID)
|
|
if err != nil || current.State != transaction.StateSwitching {
|
|
t.Fatalf("unexpected recovered state: record=%+v err=%v", current, err)
|
|
}
|
|
}
|
|
|
|
// TestExecutorMarksValidationFailureTerminal 验证请求校验失败时事务被置为 StateFailed 终态。
|
|
func TestExecutorMarksValidationFailureTerminal(t *testing.T) {
|
|
ctx := context.Background()
|
|
store, coordinator := testTransactionKernel(t)
|
|
request := testRequest(t, testRepository+":20260814-093609-d7ed70f0")
|
|
request.Port = 9090
|
|
engine := newFakeEngine(request)
|
|
executor := testExecutor(t, store, coordinator, engine, healthyResponse)
|
|
record := createTransaction(t, store, "invalid-port")
|
|
|
|
if err := executor.Run(ctx, record.ID, request); err == nil {
|
|
t.Fatal("expected validation failure")
|
|
}
|
|
current, err := store.Transaction(ctx, record.ID)
|
|
if err != nil || current.State != transaction.StateFailed {
|
|
t.Fatalf("unexpected failed transaction: record=%+v err=%v", current, err)
|
|
}
|
|
}
|
|
|
|
// TestExecutorReplacesInactiveContainerWithConflictingImage 验证当存在镜像标识冲突的非活动容器时，
|
|
// 执行器会移除该容器并重新创建，最终进入 StateSwitching。
|
|
func TestExecutorReplacesInactiveContainerWithConflictingImage(t *testing.T) {
|
|
ctx := context.Background()
|
|
store, coordinator := testTransactionKernel(t)
|
|
request := testRequest(t, testRepository+":20260814-093609-d7ed70f0")
|
|
engine := newFakeEngine(request)
|
|
engine.imageAvailable = true
|
|
conflicting := engine.containerFromSpec(containerSpec(request), false)
|
|
conflicting.ImageID = "sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
|
|
engine.containers[request.ContainerName] = conflicting
|
|
executor := testExecutor(t, store, coordinator, engine, healthyResponse)
|
|
record := createTransaction(t, store, "container-conflict")
|
|
|
|
if err := executor.Run(ctx, record.ID, request); err != nil {
|
|
t.Fatalf("replace inactive container: %v", err)
|
|
}
|
|
current, readErr := store.Transaction(ctx, record.ID)
|
|
if readErr != nil || current.State != transaction.StateSwitching {
|
|
t.Fatalf("replacement did not reach switching: record=%+v err=%v", current, readErr)
|
|
}
|
|
engine.mu.Lock()
|
|
calls := engine.callCounts()
|
|
engine.mu.Unlock()
|
|
if calls.remove != 1 || calls.create != 1 {
|
|
t.Fatalf("inactive replacement calls mismatch: %+v", calls)
|
|
}
|
|
}
|
|
|
|
// TestExecutorRejectsChangedRecoveryRequestWithoutChangingState 验证恢复执行时若请求参数被改动，
|
|
// 执行器会因持久化意图冲突而拒绝，且不改变事务的 StateStarting 状态。
|
|
func TestExecutorRejectsChangedRecoveryRequestWithoutChangingState(t *testing.T) {
|
|
ctx := context.Background()
|
|
store, coordinator := testTransactionKernel(t)
|
|
request := testRequest(t, testRepository+":20260814-093609-d7ed70f0-v1.1.8.1")
|
|
engine := newFakeEngine(request)
|
|
engine.imageAvailable = true
|
|
executor := testExecutor(t, store, coordinator, engine, healthyResponse)
|
|
record := createTransaction(t, store, "changed-recovery-request")
|
|
transitionToPrepared(t, store, record.ID)
|
|
if err := executor.prepare(ctx, record.ID, request); err != nil {
|
|
t.Fatalf("prepare original request: %v", err)
|
|
}
|
|
if _, err := store.Transition(ctx, record.ID, transaction.StateStarting, "test starting"); err != nil {
|
|
t.Fatalf("transition to starting: %v", err)
|
|
}
|
|
|
|
changed := request
|
|
changed.ImageReference = testRepository + ":20260814-093609-d7ed70f0"
|
|
err := executor.Run(ctx, record.ID, changed)
|
|
if !errors.Is(err, transaction.ErrStepConflict) {
|
|
t.Fatalf("expected persisted intent conflict, got %v", err)
|
|
}
|
|
current, readErr := store.Transaction(ctx, record.ID)
|
|
if readErr != nil || current.State != transaction.StateStarting {
|
|
t.Fatalf("changed recovery request altered transaction: record=%+v err=%v", current, readErr)
|
|
}
|
|
}
|
|
|
|
// TestImageMatchesRequiresDigestEvidenceAndExactPlatform 验证镜像匹配逻辑要求存在摘要证据且平台完全一致，
|
|
// 镜像 ID 单独存在不足以满足清单摘要匹配，平台不一致时不得判定匹配。
|
|
func TestImageMatchesRequiresDigestEvidenceAndExactPlatform(t *testing.T) {
|
|
t.Parallel()
|
|
platform := containerengine.Platform{OS: "linux", Architecture: "arm64"}
|
|
image := containerengine.Image{
|
|
ID: "sha256:cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
|
|
RepoDigests: []string{testRepository + "@" + testDigest},
|
|
Platform: platform,
|
|
}
|
|
matched, err := imageMatches(image, testDigest, platform)
|
|
if err != nil || !matched {
|
|
t.Fatalf("expected exact image match: matched=%t err=%v", matched, err)
|
|
}
|
|
image.RepoDigests = nil
|
|
matched, err = imageMatches(image, testDigest, platform)
|
|
if err != nil || matched {
|
|
t.Fatalf("image ID alone must not satisfy manifest digest: matched=%t err=%v", matched, err)
|
|
}
|
|
image.DescriptorDigest = testDigest
|
|
matched, err = imageMatches(image, testDigest, containerengine.Platform{OS: "linux", Architecture: "amd64"})
|
|
if err != nil || matched {
|
|
t.Fatalf("platform mismatch accepted: matched=%t err=%v", matched, err)
|
|
}
|
|
}
|
|
|
|
// testRequest 构造一个合法的测试请求，并在临时目录中写入镜像归档与后端配置文件。
|
|
func testRequest(t *testing.T, imageReference string) Request {
|
|
t.Helper()
|
|
directory := t.TempDir()
|
|
archivePath := filepath.Join(directory, "backend-image.tar")
|
|
configPath := filepath.Join(directory, "yms.yaml")
|
|
if err := os.WriteFile(archivePath, []byte("image archive"), 0o600); err != nil {
|
|
t.Fatalf("write image archive: %v", err)
|
|
}
|
|
if err := os.WriteFile(configPath, []byte("server: {}\n"), 0o600); err != nil {
|
|
t.Fatalf("write backend configuration: %v", err)
|
|
}
|
|
return Request{
|
|
ImageAcquisition: ImageAcquisitionLoad,
|
|
ArchivePath: archivePath,
|
|
ImageReference: imageReference,
|
|
ExpectedImageDigest: testDigest,
|
|
Platform: containerengine.Platform{OS: "linux", Architecture: "amd64"},
|
|
ContainerName: "explicit-backend-8081",
|
|
Port: 8081,
|
|
PortEnvironmentKey: "SERVER_PORT",
|
|
ConfigSource: configPath,
|
|
ConfigTarget: "/app/config/yms.yaml",
|
|
TmpSource: directory,
|
|
TmpTarget: "/home/yms/tmp",
|
|
ConfigEnvironmentKey: "SPRING_CONFIG_LOCATION",
|
|
ConfigLocation: "file:/app/config/yms.yaml",
|
|
RestartPolicy: containerengine.RestartPolicy{Name: "unless-stopped"},
|
|
HealthEndpoint: "http://127.0.0.1:8081/yms/actuator/health",
|
|
}
|
|
}
|
|
|
|
// testTransactionKernel 创建测试用的事务存储与协调器，并在测试结束时自动关闭存储。
|
|
func testTransactionKernel(t *testing.T) (*transaction.Store, *transaction.Coordinator) {
|
|
t.Helper()
|
|
store, err := transaction.OpenStore(context.Background(), filepath.Join(t.TempDir(), "transactions.db"))
|
|
if err != nil {
|
|
t.Fatalf("open transaction store: %v", err)
|
|
}
|
|
t.Cleanup(func() { _ = store.Close() })
|
|
coordinator, err := transaction.NewCoordinator(store, slog.New(slog.NewTextHandler(io.Discard, nil)))
|
|
if err != nil {
|
|
t.Fatalf("create transaction coordinator: %v", err)
|
|
}
|
|
return store, coordinator
|
|
}
|
|
|
|
// testExecutor 使用固定响应体构造健康检查 HTTP 客户端并创建后端执行器。
|
|
func testExecutor(t *testing.T, store *transaction.Store, coordinator *transaction.Coordinator, engine containerengine.Engine, body string) *Executor {
|
|
t.Helper()
|
|
client := &http.Client{Transport: roundTripFunc(func(*http.Request) (*http.Response, error) {
|
|
return &http.Response{StatusCode: http.StatusOK, Header: make(http.Header), Body: io.NopCloser(bytes.NewBufferString(body))}, nil
|
|
})}
|
|
executor, err := New(store, coordinator, engine, client)
|
|
if err != nil {
|
|
t.Fatalf("create backend executor: %v", err)
|
|
}
|
|
return executor
|
|
}
|
|
|
|
// createTransaction 以给定后缀创建一个新的后端测试事务并返回其记录。
|
|
func createTransaction(t *testing.T, store *transaction.Store, suffix string) transaction.Transaction {
|
|
t.Helper()
|
|
record, _, err := store.CreateTransaction(context.Background(), transaction.CreateRequest{
|
|
ID: "backend-" + suffix,
|
|
IdempotencyKey: "backend-request-" + suffix,
|
|
Source: "test",
|
|
Service: "backend",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("create backend transaction: %v", err)
|
|
}
|
|
return record
|
|
}
|
|
|
|
// transitionToPrepared 将指定事务依次推进到 StateValidating 与 StatePrepared 状态。
|
|
func transitionToPrepared(t *testing.T, store *transaction.Store, transactionID string) {
|
|
t.Helper()
|
|
ctx := context.Background()
|
|
if _, err := store.Transition(ctx, transactionID, transaction.StateValidating, "test validating"); err != nil {
|
|
t.Fatalf("transition to validating: %v", err)
|
|
}
|
|
if _, err := store.Transition(ctx, transactionID, transaction.StatePrepared, "test prepared"); err != nil {
|
|
t.Fatalf("transition to prepared: %v", err)
|
|
}
|
|
}
|
|
|
|
// roundTripFunc http.RoundTripper 的函数式适配器，用于在测试中固定 HTTP 响应。
|
|
type roundTripFunc func(*http.Request) (*http.Response, error)
|
|
|
|
// RoundTrip 实现 http.RoundTripper 接口，直接调用底层函数。
|
|
func (f roundTripFunc) RoundTrip(request *http.Request) (*http.Response, error) {
|
|
return f(request)
|
|
}
|
|
|
|
// engineCalls 记录 fakeEngine 各方法被调用的次数，用于断言执行路径。
|
|
type engineCalls struct {
|
|
ping int
|
|
load int
|
|
inspect int
|
|
create int
|
|
start int
|
|
remove int
|
|
}
|
|
|
|
// fakeEngine containerengine.Engine 的内存实现，用于测试中模拟容器引擎行为。
|
|
type fakeEngine struct {
|
|
// mu 保护下方字段的并发访问。
|
|
mu sync.Mutex
|
|
// request 构造该引擎时使用的请求参数。
|
|
request Request
|
|
// loadedImage 引擎加载后提供的镜像。
|
|
loadedImage containerengine.Image
|
|
// imageAvailable 表示镜像当前是否可用。
|
|
imageAvailable bool
|
|
// containers 引擎维护的容器表，键为容器名称。
|
|
containers map[string]containerengine.Container
|
|
// lastCreateSpec 记录最近一次创建容器所用的规格。
|
|
lastCreateSpec containerengine.ContainerSpec
|
|
pingCalls int
|
|
loadCalls int
|
|
inspectCalls int
|
|
createCalls int
|
|
startCalls int
|
|
removeCalls int
|
|
}
|
|
|
|
// newFakeEngine 构造一个已按请求平台预置镜像的 fakeEngine。
|
|
func newFakeEngine(request Request) *fakeEngine {
|
|
return &fakeEngine{
|
|
request: request,
|
|
loadedImage: containerengine.Image{
|
|
ID: "sha256:cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
|
|
RepoDigests: []string{testRepository + "@" + testDigest},
|
|
Platform: request.Platform,
|
|
},
|
|
containers: make(map[string]containerengine.Container),
|
|
}
|
|
}
|
|
|
|
// Ping 实现容器引擎的 Ping，记录调用次数并始终返回成功。
|
|
func (e *fakeEngine) Ping(context.Context) error {
|
|
e.mu.Lock()
|
|
defer e.mu.Unlock()
|
|
e.pingCalls++
|
|
return nil
|
|
}
|
|
|
|
// LoadImage 实现容器引擎的 LoadImage，读取输入流后标记镜像可用并记录调用次数。
|
|
func (e *fakeEngine) LoadImage(_ context.Context, input io.Reader) error {
|
|
e.mu.Lock()
|
|
defer e.mu.Unlock()
|
|
e.loadCalls++
|
|
if _, err := io.ReadAll(input); err != nil {
|
|
return err
|
|
}
|
|
e.imageAvailable = true
|
|
return nil
|
|
}
|
|
|
|
// PullImage 实现容器引擎的 PullImage，标记镜像可用并记录调用次数。
|
|
func (e *fakeEngine) PullImage(context.Context, string) error {
|
|
e.mu.Lock()
|
|
defer e.mu.Unlock()
|
|
e.loadCalls++
|
|
e.imageAvailable = true
|
|
return nil
|
|
}
|
|
|
|
// InspectImage 实现容器引擎的 InspectImage，镜像不可用时返回 ErrNotFound，否则返回已加载镜像。
|
|
func (e *fakeEngine) InspectImage(context.Context, string) (containerengine.Image, error) {
|
|
e.mu.Lock()
|
|
defer e.mu.Unlock()
|
|
e.inspectCalls++
|
|
if !e.imageAvailable {
|
|
return containerengine.Image{}, containerengine.ErrNotFound
|
|
}
|
|
return e.loadedImage, nil
|
|
}
|
|
|
|
// CreateContainer 实现容器引擎的 CreateContainer，记录规格并创建容器，同名时返回错误。
|
|
func (e *fakeEngine) CreateContainer(_ context.Context, spec containerengine.ContainerSpec) (containerengine.Container, error) {
|
|
e.mu.Lock()
|
|
defer e.mu.Unlock()
|
|
e.createCalls++
|
|
e.lastCreateSpec = spec
|
|
if _, exists := e.containers[spec.Name]; exists {
|
|
return containerengine.Container{}, errors.New("container name already exists")
|
|
}
|
|
record := e.containerFromSpec(spec, false)
|
|
e.containers[spec.Name] = record
|
|
return record, nil
|
|
}
|
|
|
|
// StartContainer 实现容器引擎的 StartContainer，将指定容器标记为运行状态，不存在时返回 ErrNotFound。
|
|
func (e *fakeEngine) StartContainer(_ context.Context, name string) error {
|
|
e.mu.Lock()
|
|
defer e.mu.Unlock()
|
|
e.startCalls++
|
|
record, exists := e.containers[name]
|
|
if !exists {
|
|
return containerengine.ErrNotFound
|
|
}
|
|
record.Running = true
|
|
record.Status = "running"
|
|
e.containers[name] = record
|
|
return nil
|
|
}
|
|
|
|
// ContainerLogs 实现容器引擎的 ContainerLogs，返回空的日志读取器。
|
|
func (e *fakeEngine) ContainerLogs(context.Context, string) (io.ReadCloser, error) {
|
|
return io.NopCloser(strings.NewReader("")), nil
|
|
}
|
|
|
|
// StopContainer 实现容器引擎的 StopContainer，将指定容器标记为已退出状态，不存在时返回 ErrNotFound。
|
|
func (e *fakeEngine) StopContainer(_ context.Context, name string, _ int) error {
|
|
e.mu.Lock()
|
|
defer e.mu.Unlock()
|
|
record, exists := e.containers[name]
|
|
if !exists {
|
|
return containerengine.ErrNotFound
|
|
}
|
|
record.Running = false
|
|
record.Status = "exited"
|
|
e.containers[name] = record
|
|
return nil
|
|
}
|
|
|
|
// InspectContainer 实现容器引擎的 InspectContainer，返回容器记录，不存在时返回 ErrNotFound。
|
|
func (e *fakeEngine) InspectContainer(_ context.Context, name string) (containerengine.Container, error) {
|
|
e.mu.Lock()
|
|
defer e.mu.Unlock()
|
|
record, exists := e.containers[name]
|
|
if !exists {
|
|
return containerengine.Container{}, containerengine.ErrNotFound
|
|
}
|
|
return record, nil
|
|
}
|
|
|
|
// RemoveContainer 实现容器引擎的 RemoveContainer，删除指定容器并记录调用次数，不存在时返回 ErrNotFound。
|
|
func (e *fakeEngine) RemoveContainer(_ context.Context, name string, _ bool) error {
|
|
e.mu.Lock()
|
|
defer e.mu.Unlock()
|
|
e.removeCalls++
|
|
if _, exists := e.containers[name]; !exists {
|
|
return containerengine.ErrNotFound
|
|
}
|
|
delete(e.containers, name)
|
|
return nil
|
|
}
|
|
|
|
// Close 实现容器引擎的 Close，不做任何清理并返回 nil。
|
|
func (e *fakeEngine) Close() error { return nil }
|
|
|
|
// containerFromSpec 根据容器规格构造一条容器记录，running 指定其初始运行状态。
|
|
func (e *fakeEngine) containerFromSpec(spec containerengine.ContainerSpec, running bool) containerengine.Container {
|
|
return containerengine.Container{
|
|
ID: "container-id-" + spec.Name,
|
|
Name: spec.Name,
|
|
ImageID: e.loadedImage.ID,
|
|
ImageReference: spec.ImageReference,
|
|
Platform: spec.Platform.OS + "/" + spec.Platform.Architecture,
|
|
Running: running,
|
|
Status: "created",
|
|
Environment: append([]string(nil), spec.Environment...),
|
|
NetworkMode: spec.NetworkMode,
|
|
RestartPolicy: spec.RestartPolicy,
|
|
Mounts: append([]containerengine.Mount(nil), spec.Mounts...),
|
|
User: spec.User,
|
|
StopTimeoutSeconds: spec.StopTimeoutSeconds,
|
|
}
|
|
}
|
|
|
|
// callCounts 返回 fakeEngine 各方法当前的调用次数快照。
|
|
func (e *fakeEngine) callCounts() engineCalls {
|
|
return engineCalls{
|
|
ping: e.pingCalls,
|
|
load: e.loadCalls,
|
|
inspect: e.inspectCalls,
|
|
create: e.createCalls,
|
|
start: e.startCalls,
|
|
remove: e.removeCalls,
|
|
}
|
|
}
|
|
|
|
// 编译期断言确保 fakeEngine 实现 containerengine.Engine 接口。
|
|
var _ containerengine.Engine = (*fakeEngine)(nil)
|