mirror of
https://github.com/moby/moby.git
synced 2026-01-11 10:41:43 +00:00
0df791cb72
The Container.State struct holds the container's state, and most of
its fields are expected to change dynamically. Some o these state-changes
are explicit, for example, setting the container to be "stopped". Other
state changes can be more explicit, for example due to the containers'
process exiting or being "OOM" killed by the kernel.
The distinction between explicit ("desired") state changes and "state"
("actual state") is sometimes vague; for some properties, we clearly
separated them, for example if a user requested the container to be
stopped or restarted, we store state in the Container object itself;
HasBeenManuallyStopped bool // used for unless-stopped restart policy
HasBeenManuallyRestarted bool `json:"-"` // used to distinguish restart caused by restart policy from the manual one
Other properties are more ambiguous. such as "HasBeenStartedBefore" and
"RestartCount", which are stored on the Container (and persisted to
disk), but may be more related to "actual" state, and likely should
not be persisted;
RestartCount int
HasBeenStartedBefore bool
Given that (per the above) concurrency must be taken into account, most
changes to the `container.State` struct should be protected; here's where
things get blurry. While the `State` type provides various accessor methods,
only some of them take concurrency into account; for example, [State.IsRunning]
and [State.GetPID] acquire a lock, whereas [State.ExitCodeValue] does not.
Even the (commonly used) [State.StateString] has no locking at all.
The way to handle this is error-prone; [container.State] contains a mutex,
and it's exported. Given that its embedded in the [container.Container]
struct, it's also exposed as an exported mutex for the container. The
assumption here is that by "merging" the two, the caller to acquire a lock
when either the container _or_ its state must be mutated. However, because
some methods on `container.State` handle their own locking, consumers must
be deeply familiar with the internals; if both changes to the `Container`
AND `Container.State` must be made. This gets amplified more as some
(exported!) methods, such as [container.SetRunning] mutate multiple fields,
but don't acquire a lock (so expect the caller to hold one), but their
(also exported) counterpart (e.g. [State.IsRunning]) do.
It should be clear from the above, that this needs some architectural
changes; a clearer separation between "desired" and "actual" state (opening
the potential to update the container's config without manually touching
its `State`), possibly a method to obtain a read-only copy of the current
state (for those querying state), and reviewing which fields belong where
(and should be persisted to disk, or only remain in memory).
This PR preserves the status quo; it makes no structural changes, other
than exposing where we access the container's state. Where previously the
State fields and methods were referred to as "part of the container"
(e.g. `ctr.IsRunning()` or `ctr.Running`), we now explicitly reference
the embedded `State` (`ctr.State.IsRunning`, `ctr.State.Running`).
The exception (for now) is the mutex, which is still referenced through
the embedded struct (`ctr.Lock()` instead of `ctr.State.Lock()`), as this
is (mostly) by design to protect the container, and what's in it (including
its `State`).
[State.IsRunning]: c4afa77157/daemon/container/state.go (L205-L209)
[State.GetPID]: c4afa77157/daemon/container/state.go (L211-L216)
[State.ExitCodeValue]: c4afa77157/daemon/container/state.go (L218-L228)
[State.StateString]: c4afa77157/daemon/container/state.go (L102-L131)
[container.State]: c4afa77157/daemon/container/state.go (L15-L23)
[container.Container]: c4afa77157/daemon/container/container.go (L67-L75)
[container.SetRunning]: c4afa77157/daemon/container/state.go (L230-L277)
Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
76 lines
2.6 KiB
Go
76 lines
2.6 KiB
Go
package daemon
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
containertypes "github.com/moby/moby/api/types/container"
|
|
"github.com/moby/moby/api/types/events"
|
|
"github.com/moby/moby/v2/daemon/container"
|
|
"github.com/moby/moby/v2/daemon/server/backend"
|
|
)
|
|
|
|
// ContainerRestart stops and starts a container. It attempts to
|
|
// gracefully stop the container within the given timeout, forcefully
|
|
// stopping it if the timeout is exceeded. If given a negative
|
|
// timeout, ContainerRestart will wait forever until a graceful
|
|
// stop. Returns an error if the container cannot be found, or if
|
|
// there is an underlying error at any stage of the restart.
|
|
func (daemon *Daemon) ContainerRestart(ctx context.Context, name string, options backend.ContainerStopOptions) error {
|
|
ctr, err := daemon.GetContainer(name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = daemon.containerRestart(ctx, daemon.config(), ctr, options)
|
|
if err != nil {
|
|
return fmt.Errorf("Cannot restart container %s: %v", name, err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// containerRestart attempts to gracefully stop and then start the
|
|
// container. When stopping, wait for the given duration in seconds to
|
|
// gracefully stop, before forcefully terminating the container. If
|
|
// given a negative duration, wait forever for a graceful stop.
|
|
func (daemon *Daemon) containerRestart(ctx context.Context, daemonCfg *configStore, container *container.Container, options backend.ContainerStopOptions) error {
|
|
// Restarting is expected to be an atomic operation, and cancelling
|
|
// the request should not cancel the stop -> start sequence.
|
|
ctx = context.WithoutCancel(ctx)
|
|
|
|
// Determine isolation. If not specified in the hostconfig, use daemon default.
|
|
actualIsolation := container.HostConfig.Isolation
|
|
if containertypes.Isolation.IsDefault(actualIsolation) {
|
|
actualIsolation = daemon.defaultIsolation
|
|
}
|
|
|
|
// Avoid unnecessarily unmounting and then directly mounting
|
|
// the container when the container stops and then starts
|
|
// again. We do not do this for Hyper-V isolated containers
|
|
// (implying also on Windows) as the HCS must have exclusive
|
|
// access to mount the containers filesystem inside the utility
|
|
// VM.
|
|
if !containertypes.Isolation.IsHyperV(actualIsolation) {
|
|
if err := daemon.Mount(container); err == nil {
|
|
defer daemon.Unmount(container)
|
|
}
|
|
}
|
|
|
|
if container.State.IsRunning() {
|
|
container.Lock()
|
|
container.HasBeenManuallyRestarted = true
|
|
container.Unlock()
|
|
|
|
err := daemon.containerStop(ctx, container, options)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
if err := daemon.containerStart(ctx, daemonCfg, container, "", "", true); err != nil {
|
|
return err
|
|
}
|
|
|
|
daemon.LogContainerEvent(container, events.ActionRestart)
|
|
return nil
|
|
}
|