finalize

package
v1.0.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 16, 2026 License: MIT Imports: 30 Imported by: 0

README

Finalization

Import github.com/JSYoo5B/ceph-testcontainers-go/ceph/finalize alongside ceph to end a test's dedicated cluster on one ordered cleanup path: post-test checks, verification of the daemons' log lines and new crashes against expected events, a failure archive of diagnostics and crash metadata when the test has failed, caller cleanups, then Terminate. Nothing in this package is needed to run a cluster: a cluster terminated with testcontainers.CleanupContainer needs nothing from finalize. See API purpose and purpose tags for where this fits.

Order of use

  1. Start a cluster with ceph.Run.

  2. Register finalization with finalize.TerminateOnCleanup(t, cluster, config) right after Run, instead of another cleanup that terminates the cluster. A partially started cluster returned with an error is still finalized.

  3. Add steps to the returned Finalization:

    Step Method
    A post-test check Check
    Log and crash expectations for the test window Verify
    A packet capture to settle (metadata, or with its raw file) Capture, CaptureWithFile
    An override.SetDebugLevel window to record in the manifest TrackDebugLevel
    The removal of a caller-owned client the archive should still see Cleanup
  4. Run the SUT. The registered cleanup does the rest.

cluster, err := ceph.Run(ctx, ceph.DefaultImage)
finalization, ferr := finalize.TerminateOnCleanup(t, cluster, finalize.Config{Archive: true})
if err != nil { // a partially started cluster is still finalized
	t.Fatal(err)
}
if ferr != nil {
	t.Fatal(ferr)
}
observer, err := ceph.Observe(cluster)
if err != nil {
	t.Fatal(err)
}
finalization.Check("pool still clean", observer.WaitForClean)

Concepts and limits

  • The cleanup runs, in this order: the checks in registration order, the settlement of registered captures, the failure archive (only when the test has failed by then), the cleanups in reverse registration order, then Terminate. A check or a capture settlement that fails the test triggers the archive too; a cleanup that fails when nothing had failed before triggers an archive of what still runs.
  • Test cleanups registered after TerminateOnCleanup run before all of this, as Go runs cleanups last-in first-out. Route the removal of clients the archive should see through Cleanup.
  • Every phase uses a fresh context bounded by its own timeout in Config (CheckTimeout, ArchiveTimeout, CleanupTimeout), because the test's context has ended. Check, collection and storage errors never skip the cleanups or Terminate. A check's error and Terminate's error fail the test; collection and storage errors are logged and recorded in the manifest.
  • The archive holds a manifest and the reports of diagnostics.Collect and diagnostics.CollectCrashMetadata, configured through Config.Diagnostics and Config.CrashMetadata, plus verification and capture reports. A verification with ArchiveLogs adds every line of its window that its log check read, where the diagnostics keep only a log tail. The finalization of a passing run collects nothing. By default it goes into the test's ArtifactDir, which go test keeps only with -artifacts.
  • A verification that is unexpected or incomplete fails the test. It never changes the cluster, and clean is evidence for the reported sources and window only.
  • When the test binary has a -timeout, a before-deadline archive is armed ArchiveTimeout plus ten seconds before that deadline, because Go's timeout panic runs no cleanup; see the failure archive for when it is taken and what its manifest holds.
  • Adding a step after finalization has started fails the test. Nothing runs after another forced process exit (os.Exit, a signal, a cancelled job) or a lost runner.

Reference

The full contract of every type and function is in go doc: pkg.go.dev or go doc -all github.com/JSYoo5B/ceph-testcontainers-go/ceph/finalize. The archive layout, the manifest and the verification model are in Ceph operations; contexts in cleanup code in Contexts and cleanup; standalone collection in diagnostics.

Documentation

Overview

Package finalize ends a test's dedicated Ceph cluster on one ordered cleanup path. TerminateOnCleanup registers a single t.Cleanup that runs the post-test checks, settles registered packet captures, writes a failure archive when the test has failed, runs the finalization cleanups and then terminates the cluster. The returned Finalization collects the checks, cleanups, captures and debug level windows, and Finalization.Verify activates a post-test verification of the daemons' log lines and new crashes against expected events.

The failure archive holds a manifest and the reports of diagnostics.Collect and diagnostics.CollectCrashMetadata, configured through Config; the finalization of a passing run collects nothing, and only a before-deadline archive taken while the test still ran remains. Nothing in this package is needed to run a cluster: a test that terminates its cluster with testcontainers.CleanupContainer does not import it.

The error categories are those of package ceph: a refused configuration or registration matches ceph.ErrInvalidRequest.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type CaptureFileSource

type CaptureFileSource interface {
	CaptureSettler
	CaptureFile(ctx context.Context) (io.ReadCloser, int64, string, error)
}

CaptureFileSource is a settled capture with a read-only local file. CaptureFile returns a reader, the complete retrieved byte count and its SHA256. The descriptor must remain the settlement's frozen identity even if the file is later edited. It must not start or settle a capture, change or delete the caller's file, or expose a host path in errors. Opening and reading must honor ctx; Finalization waits for operations to return rather than abandoning them.

type CaptureSettler

type CaptureSettler interface {
	// SettlementAllowance bounds the context that finalization gives Settle.
	// A capture.Session can also wait for a concurrent Stop before beginning
	// its own bounded Docker work. Finalization waits for Settle to return.
	SettlementAllowance() time.Duration
	// Settle ends the capture, delivers its file and removes its helper. It
	// must not abandon work that is still running when its context ends, and
	// it returns the report, which must be JSON-marshalable and hold no host
	// path, also with an error. Settling twice returns the first report.
	Settle(ctx context.Context) (report any, err error)
}

CaptureSettler is a running packet capture that a Finalization settles. *capture.Session implements it.

type Config

type Config struct {
	// Archive enables the failure archive: when the test has failed, a
	// check failed or a finalization cleanup failed, the diagnostics, crash
	// metadata and a manifest are written before the cluster is terminated.
	// The finalization of a passing run collects nothing. For a testing.T
	// with a deadline, it also arms a before-deadline archive: when the test
	// still runs ArchiveTimeout plus ten seconds before the test binary's
	// -timeout, whose panic runs no cleanup, the archive is written while
	// the test and the cluster still run, whether or not the test has
	// failed. A test that then passes keeps that archive, with its manifest
	// not final.
	Archive bool
	// ArchiveDirectory is the root under which each archive gets its own
	// directory, named after the test, the cluster and a random execution
	// ID. Empty selects the test's ArtifactDir, which go test keeps only
	// with its -artifacts flag; otherwise it is removed after the test.
	ArchiveDirectory string
	// Scenario labels the manifest, for example with a batch or profile name.
	Scenario string
	// CheckTimeout bounds all checks together (default 2 minutes),
	// ArchiveTimeout the whole archive with both collectors and every write
	// (default 3 minutes), and CleanupTimeout the cleanups together and
	// Terminate separately (default 3 minutes). Each is at most 10 minutes;
	// invalid fields are refused before anything is registered.
	CheckTimeout   time.Duration
	ArchiveTimeout time.Duration
	CleanupTimeout time.Duration
	// Diagnostics and CrashMetadata configure the two collectors; select
	// caller-owned clients or mirror daemons with their AdditionalContainers.
	Diagnostics   diagnostics.Config
	CrashMetadata diagnostics.CrashMetadataConfig
}

Config selects what the cleanup that TerminateOnCleanup registers does before it terminates the cluster. Zero durations select two minutes for the checks together, three minutes for the failure archive, and three minutes for the cleanups together and again for Terminate; each is at most ten minutes.

type CrashExpectation

type CrashExpectation struct {
	Name     string
	Required bool
	MinCount int
	MaxCount int
	// Daemon is the source whose crash directory held the crash, such as
	// "osd.0".
	Daemon string
	// Process is the crashed process, such as "ceph-osd".
	Process string
	// Signature is a regular expression (RE2 syntax) that must match one
	// line of the crash's stack_sig, assert_condition, assert_func,
	// assert_msg or backtrace fields.
	Signature string
}

CrashExpectation permits, or with Required requires, new crashes that match all of its non-empty criteria; at least one of Daemon, Process and Signature is required.

type DebugLevelReceipter

type DebugLevelReceipter interface {
	Receipt() override.DebugLevelReceipt
}

DebugLevelReceipter is a source of one debug level window's receipt. A *override.DebugLevelHandle implements it. A registration is absent when it is a nil interface, when its dynamic value is a nil pointer, map, slice, func, chan or interface (Receipt is then never called, so a method that is not nil-safe, including a value-receiver method reached through a nil pointer, cannot panic), or when Receipt returns the zero receipt (State is empty). Absence is not decided by a nil comparison of the interface alone.

type ExpectationResult

type ExpectationResult struct {
	Name      string `json:"name"`
	Required  bool   `json:"required"`
	MinCount  int    `json:"min_count"`
	MaxCount  int    `json:"max_count"`
	Matched   int    `json:"matched"`
	Satisfied bool   `json:"satisfied"`
}

ExpectationResult is how many events one expectation matched.

type Finalization

type Finalization struct {
	// contains filtered or unexported fields
}

Finalization is the single cleanup path that TerminateOnCleanup registers. It runs, in this order: the checks in registration order, the failure archive, the cleanups in reverse registration order, then Terminate, so that a check registered after the test body still decides whether to archive and that a client removed by a cleanup is still there to inspect. Captures registered with Capture are settled after the checks and before the archive. The archive is written when the test has failed by then, so a failure reported by a check or a capture settlement triggers it too, and a cleanup that fails when nothing had failed before triggers an archive of what still runs, labelled after-cleanup. Test cleanups registered after TerminateOnCleanup run before all of this, as Go runs cleanups last-in first-out, so route the removal of clients the archive should see through Cleanup. A check fails the test by returning an error, by panicking or through t. Adding a step after the finalization has started fails the test.

func TerminateOnCleanup

func TerminateOnCleanup(t testing.TB, cluster *ceph.Container, config Config) (*Finalization, error)

TerminateOnCleanup registers one t.Cleanup that finalizes and then terminates the cluster, and returns the Finalization to add checks and cleanups to. Register it right after ceph.Run instead of another cleanup that terminates the cluster, and route the removal of caller-owned clients that the archive should still see through Finalization.Cleanup: test cleanups registered later run before it.

Every phase uses a fresh context bounded by its own timeout, because the test's context has ended by then. Check, collection and storage errors never skip the cleanups or Terminate. A check's error and Terminate's error fail the test; collection and storage errors are logged and recorded in the manifest. With Config.Archive and a test binary deadline, it also arms the before-deadline archive that Config.Archive describes. Nothing else runs after a forced process exit or a lost runner.

func (*Finalization) Capture

func (f *Finalization) Capture(name string, session CaptureSettler)

Capture registers a packet capture that the finalization settles after the checks and before the failure archive, so that a check or a failed test body that never called Stop still ends the capture before the archive and before any Cleanup removes a caller-owned target.

The settlement is a phase of its own. It does not use CheckTimeout or the expired test context: each capture gets a fresh context bounded by its SettlementAllowance, and the finalization waits for the settlement to return instead of abandoning it, because the capture's target must not be removed underneath a running settlement. An explicit Stop that already ran is not repeated; its report is the one kept. Settlement errors fail the test, and the report is kept for the archive even then. Nil sessions (including a typed nil pointer) and registration after finalization started fail the test instead.

With Config.Archive the archive keeps each settled report as capture-<n>-<name>.json, n being the registration order, and the manifest lists each settlement under captures with its error, failed_test, allowance and reported fields; a settlement failure marks the trigger capture_failed. The archived report names its output file by base name only, and its strings are masked like the manifest's errors (the configured RedactValues and the recognized secret patterns). Only metadata is archived: this never copies or retains the pcap file itself, which CaptureWithFile does on explicit consent.

func (*Finalization) CaptureWithFile

func (f *Finalization) CaptureWithFile(name string, session CaptureFileSource, maxBytes int64)

CaptureWithFile registers a capture with explicit consent to copy its raw, unsanitized packet payloads and endpoint identifiers into the failure archive. Use Capture for metadata alone. Registration requires a positive maxBytes of at most 64 MiB. All registered captures settle. When archiving, only the first 16 file registrations are eligible, in order, and published copies share a 64 MiB budget. Registration reserves no space. There is no implicit truncation. Settlement, copying, archive retention and later upload are separate outcomes. A passing run settles without opening the source. Local filesystem calls may finish after a deadline (for example on a stalled filesystem); no background copying is abandoned underneath cleanup.

Each copy shares ArchiveTimeout, checks it between reads, verifies the complete retrieved size/SHA256 and publishes atomically. Invalid/partial pcap structure does not prevent preserving its exact retrieved bytes. The caller retains its original file and must keep it and its directory available until finalization returns. If cleanup produces the first failure, copying runs after cleanup and reports an unavailable source rather than recovering bytes that were removed.

func (*Finalization) Check

func (f *Finalization) Check(name string, check func(context.Context) error)

Check adds a post-test check. Checks run before the archive decision, in registration order, while the cluster and every client still run. A check that returns an error, or panics, fails the test and triggers the archive; a check may also report through the test itself, including with t.Fatal, which ends only the check. Adding a check after finalization has started fails the test instead.

func (*Finalization) Cleanup

func (f *Finalization) Cleanup(name string, cleanup func(context.Context) error)

Cleanup adds a cleanup that runs after the archive and before Terminate, in reverse registration order, such as the removal of a caller-owned client. Its error, or panic, fails the test; when nothing has failed before, it also triggers an archive of what still runs.

func (*Finalization) TrackDebugLevel

func (f *Finalization) TrackDebugLevel(handle DebugLevelReceipter)

TrackDebugLevel registers a debug level window for the manifest. Every call is a separate window, in registration order, even for the same daemon, option and generation: windows are never merged or deduplicated. Register the handle right after override.SetDebugLevel returns, including the non-nil handle that comes with an apply error. A nil interface, a typed nil (a nil pointer, map, slice, func, chan or interface dynamic value), a zero-value handle, or any receipter whose receipt has no State is recorded as absent; Receipt is not called on a typed nil. Other panics in a foreign Receipt are not recovered, never as a restored window. A receipt in state DebugLevelNotApplied is recorded as present, with its Reason.

The manifest keeps a copy of the window's receipt when the failure archive is taken, labeled with the archive's phase, and a second copy after the cleanups, so that a restoration run by Finalization.Cleanup is a separate, later record. Taking a copy reads only the handle's local state; it never applies or restores a level and never queries the daemon. The finalization of a passing run archives nothing; a before-deadline archive taken while the test still ran keeps its copy, labeled with that phase. Registering after finalization started fails the test.

func (*Finalization) Verify

func (f *Finalization) Verify(ctx context.Context, config VerificationConfig) (*Verification, error)

Verify activates a post-test verification of the cluster and adds a check that evaluates it, so that a verification that is not clean fails the test and, with Config.Archive, triggers the failure archive before any cleanup. Activation records the baseline: the selected container generations (the cluster's daemon containers and config.AdditionalContainers), the crash IDs already in their crash directories, and the start of the window on the Docker engine's clock. It returns an error when the configuration is invalid, when the engine cannot be reached or after finalization has started.

The check fails the test both for an unexpected and for an incomplete verification. It never changes the cluster: it restarts, archives and removes nothing, and a failure never skips the cleanups or Terminate.

type LogEvent

type LogEvent string

LogEvent is the kind of a log line that verification evaluates. Lines of no kind are not events. Cluster log entries use these envelopes:

<stamp> <thread> <level> log_channel(<channel>) log [<PRIO>] : <message>
[<channel> ]<stamp> <name> (<rank>) <seq> : <channel> [<PRIO>] <message>

In the second form the optional leading channel must equal the entry's channel. PRIO is DBG, INF, SEC, WRN or ERR. The stamp is a calendar date and time (YYYY-MM-DDThh:mm:ss) with three or six fractional digits and a numeric timezone (±hhmm). The parser accepts offset hours up to 12 west or 14 east and offset minutes from 00 to 59.

A MON writes the second form to its standard error in pieces, and its own daemon lines can land between the pieces of the header, so one entry can be split over several lines. Such an entry is restored, on the standard error of a MON only (a MON's whole output with a TTY), before it is classified: a line that ends with a whole daemon line after a head, and the line after one or more of them, are joined into the entry when every split lies in the entry's header. The daemon lines are read on their own. A split inside a message is not restored, since a message can quote any text. A line with a log envelope of its own is a record and is never joined as the rest of an entry.

const (
	// LogAssertion is a failed Ceph assertion or abort ("FAILED ceph_assert",
	// "ceph_abort").
	LogAssertion LogEvent = "assertion"
	// LogFatalSignal is a daemon's report of a fatal signal ("Caught
	// signal").
	LogFatalSignal LogEvent = "fatal-signal"
	// LogClusterError, LogClusterSecurity and LogClusterWarning are cluster
	// log entries of level ERR, SEC and WRN, which every daemon writes to
	// its output and the MON writes again as the cluster log. The level is
	// the one of the entry's own log envelope (see LogExpectation.Pattern);
	// a marker in the message of a lower level entry makes no event, and a
	// line with a marker but no recognized envelope is a gap, not an event.
	// The entry's channel (such as cluster or audit) does not select the
	// kind: a level ERR, SEC or WRN entry of any channel is an event.
	LogClusterError    LogEvent = "cluster-error"
	LogClusterSecurity LogEvent = "cluster-security"
	LogClusterWarning  LogEvent = "cluster-warning"
)

type LogExpectation

type LogExpectation struct {
	// Name identifies the expectation in the report.
	Name string
	// Required makes the expectation fail the verification unless at least
	// MinCount events (at least one) match it. Without Required, MinCount
	// must be zero.
	Required bool
	MinCount int
	// MaxCount limits how many events it permits; zero is no limit. Further
	// events go on to the next expectations and are unexpected when none
	// permits them.
	MaxCount int
	// Daemon is the source as the report names it, such as "osd.0".
	Daemon string
	// Event is the kind of line.
	Event LogEvent
	// Pattern is a regular expression (RE2 syntax), searched unanchored in
	// the whole redacted line without its Docker timestamp, including the log
	// envelope; anchor it with ^ and $ to require a full match. Event, not Pattern, selects the structural kind.
	Pattern string
}

LogExpectation permits, or with Required requires, log events that match all of its non-empty criteria. Pattern is required.

type Verification

type Verification struct {
	// contains filtered or unexported fields
}

Verification is one activated post-test verification of a dedicated cluster. It keeps the baseline that its activation recorded.

func (*Verification) Evaluate

func (v *Verification) Evaluate(ctx context.Context) (*VerificationReport, error)

Evaluate evaluates the window from the activation until now and returns its report. It changes nothing and can be repeated; each evaluation starts from the activation's baseline. Gaps make a report incomplete instead of returning an error: Evaluate returns an error only when it cannot evaluate at all.

type VerificationCheck

type VerificationCheck struct {
	Outcome         VerificationOutcome   `json:"outcome"`
	Permitted       int                   `json:"permitted"`
	Unexpected      int                   `json:"unexpected"`
	Findings        []VerificationFinding `json:"findings"`
	OmittedFindings int                   `json:"omitted_findings"`
	Expectations    []ExpectationResult   `json:"expectations"`
	Gaps            []VerificationGap     `json:"gaps"`
}

VerificationCheck is the result of the log or the crash check. Findings keep the unexpected events first and then the permitted ones, up to MaxFindings; OmittedFindings counts the rest. Permitted and Unexpected count all of them.

type VerificationConfig

type VerificationConfig struct {
	// Name labels the verification, its check and its report. Empty selects
	// "post-test". Names are unique within one Finalization.
	Name string
	// Logs and Crashes are the expected events. A log expectation never
	// matches a crash, nor a crash expectation a log line.
	Logs    []LogExpectation
	Crashes []CrashExpectation

	Timeout          time.Duration
	OperationTimeout time.Duration
	MaxLogBytes      int64
	MaxFindings      int
	// AdditionalContainers are caller-owned daemon containers, such as
	// mirror daemons, that are verified like the cluster's own. Verification
	// never adopts them.
	AdditionalContainers []diagnostics.Target
	// RedactValues removes additional opaque secrets from the report and
	// the archived lines. Each value must be one line: log lines are masked
	// one at a time, so a value with a line break could never match and its
	// parts would stay readable on consecutive lines. Such a value is
	// refused.
	RedactValues []string
	// ArchiveLogs keeps every line of the window that the log check reads,
	// events or not, redacted and in the order received (an entry split by
	// daemon lines as restored, see LogEvent), and the failure
	// archive writes them next to the report. They have the log check's
	// coverage: its gaps (a restarted, removed or rotating source, the
	// MaxLogBytes limit, a cut stream) apply to them as well.
	ArchiveLogs bool
}

VerificationConfig selects what Finalization.Verify checks after the test: the log lines and the new crashes of the cluster's daemons since activation, each against its own expectations. Zero fields select a two minute timeout for the activation and for each evaluation (at most five), 20 seconds per Docker operation (at most one minute), 32 MiB of log stream per container (at most 256 MiB) and 256 retained findings per check (at most 4096). Name is one line of at most 128 bytes, Logs and Crashes take at most 256 expectations each, and AdditionalContainers and RedactValues have the limits of diagnostics.Config (64 containers, 128 values of at most 4096 bytes).

type VerificationFinding

type VerificationFinding struct {
	Source      string `json:"source"`
	ContainerID string `json:"container_id,omitempty"`
	// Event is a LogEvent, or "crash".
	Event string `json:"event"`
	Time  string `json:"time,omitempty"`
	// Text is the redacted line, or a summary of the crash, at most 1 KiB.
	Text        string `json:"text"`
	Truncated   bool   `json:"truncated,omitempty"`
	CrashID     string `json:"crash_id,omitempty"`
	Expectation string `json:"expectation,omitempty"`
}

VerificationFinding is one evaluated event. Expectation names the expectation that permitted it; it is empty for an unexpected event.

type VerificationGap

type VerificationGap struct {
	Source string `json:"source,omitempty"`
	Reason string `json:"reason"`
}

VerificationGap is an observation that could not be completed.

type VerificationOutcome

type VerificationOutcome string

VerificationOutcome is the result of one check or of a whole verification.

const (
	// VerificationClean means that no unexpected event was observed and
	// every required expectation was satisfied within the reported sources
	// and window, all of which were observed.
	VerificationClean VerificationOutcome = "clean"
	// VerificationUnexpected means that an observed event was not permitted
	// or that a required expectation was not satisfied.
	VerificationUnexpected VerificationOutcome = "unexpected"
	// VerificationIncomplete means that no unexpected event was found, but a
	// requested observation could not be completed; Gaps say which.
	VerificationIncomplete VerificationOutcome = "incomplete"
)

type VerificationReport

type VerificationReport struct {
	SchemaVersion int                 `json:"schema_version"`
	Name          string              `json:"name"`
	Cluster       string              `json:"cluster"`
	Outcome       VerificationOutcome `json:"outcome"`
	Window        VerificationWindow  `json:"window"`
	// Images are the cluster's role images; a daemon started with DaemonOptions.WithImage
	// is not reflected.
	Images  ceph.ImageSet        `json:"images"`
	Sources []VerificationSource `json:"sources"`
	Logs    VerificationCheck    `json:"logs"`
	Crashes VerificationCheck    `json:"crashes"`
	// LogExpectations and CrashExpectations are the effective policy.
	LogExpectations   []LogExpectation   `json:"log_expectations"`
	CrashExpectations []CrashExpectation `json:"crash_expectations"`
	Notes             []string           `json:"notes"`
	// contains filtered or unexported fields
}

VerificationReport is the JSON-serializable result of one evaluation. Outcome is unexpected when a check is, else incomplete when a check is, else clean.

type VerificationSource

type VerificationSource struct {
	Source       string `json:"source"`
	Role         string `json:"role"`
	Name         string `json:"name"`
	ContainerID  string `json:"container_id,omitempty"`
	ImageID      string `json:"image_id,omitempty"`
	StartedAt    string `json:"started_at,omitempty"`
	RestartCount int    `json:"restart_count"`
	State        string `json:"state,omitempty"`
	LogDriver    string `json:"log_driver,omitempty"`
	// LogBytes counts the log stream bytes read in the window.
	LogBytes int64 `json:"log_bytes"`
	// LogLines counts the lines of the window read from the stream, events
	// or not.
	LogLines int `json:"log_lines"`
	// BaselineCrashes are the crash IDs that were present at activation.
	BaselineCrashes []string `json:"baseline_crashes"`
}

VerificationSource is one container generation that was selected at activation. StartedAt and RestartCount identify the generation.

type VerificationWindow

type VerificationWindow struct {
	Phase     string    `json:"phase"`
	StartedAt time.Time `json:"started_at"`
	// EndedAt is zero when the engine's clock could not be read.
	EndedAt     time.Time `json:"ended_at"`
	EvaluatedAt time.Time `json:"evaluated_at"`
}

VerificationWindow is the observed interval, on the Docker engine's clock. Phase is "test": bootstrap before the activation and the cleanups and termination after the evaluation are outside it.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL