| package container |
| |
| import ( |
| "fmt" |
| "sync" |
| "time" |
| |
| "golang.org/x/net/context" |
| |
| "github.com/docker/docker/api/types" |
| "github.com/docker/go-units" |
| ) |
| |
| // State holds the current container state, and has methods to get and |
| // set the state. Container has an embed, which allows all of the |
| // functions defined against State to run against Container. |
| type State struct { |
| sync.Mutex |
| // FIXME: Why do we have both paused and running if a |
| // container cannot be paused and running at the same time? |
| Running bool |
| Paused bool |
| Restarting bool |
| OOMKilled bool |
| RemovalInProgress bool // Not need for this to be persistent on disk. |
| Dead bool |
| Pid int |
| ExitCodeValue int `json:"ExitCode"` |
| ErrorMsg string `json:"Error"` // contains last known error when starting the container |
| StartedAt time.Time |
| FinishedAt time.Time |
| waitChan chan struct{} |
| Health *Health |
| } |
| |
| // StateStatus is used to return an error type implementing both |
| // exec.ExitCode and error. |
| // This type is needed as State include a sync.Mutex field which make |
| // copying it unsafe. |
| type StateStatus struct { |
| exitCode int |
| error string |
| } |
| |
| func newStateStatus(ec int, err string) *StateStatus { |
| return &StateStatus{ |
| exitCode: ec, |
| error: err, |
| } |
| } |
| |
| // ExitCode returns current exitcode for the state. |
| func (ss *StateStatus) ExitCode() int { |
| return ss.exitCode |
| } |
| |
| // Error returns current error for the state. |
| func (ss *StateStatus) Error() string { |
| return ss.error |
| } |
| |
| // NewState creates a default state object with a fresh channel for state changes. |
| func NewState() *State { |
| return &State{ |
| waitChan: make(chan struct{}), |
| } |
| } |
| |
| // String returns a human-readable description of the state |
| func (s *State) String() string { |
| if s.Running { |
| if s.Paused { |
| return fmt.Sprintf("Up %s (Paused)", units.HumanDuration(time.Now().UTC().Sub(s.StartedAt))) |
| } |
| if s.Restarting { |
| return fmt.Sprintf("Restarting (%d) %s ago", s.ExitCodeValue, units.HumanDuration(time.Now().UTC().Sub(s.FinishedAt))) |
| } |
| |
| if h := s.Health; h != nil { |
| return fmt.Sprintf("Up %s (%s)", units.HumanDuration(time.Now().UTC().Sub(s.StartedAt)), h.String()) |
| } |
| |
| return fmt.Sprintf("Up %s", units.HumanDuration(time.Now().UTC().Sub(s.StartedAt))) |
| } |
| |
| if s.RemovalInProgress { |
| return "Removal In Progress" |
| } |
| |
| if s.Dead { |
| return "Dead" |
| } |
| |
| if s.StartedAt.IsZero() { |
| return "Created" |
| } |
| |
| if s.FinishedAt.IsZero() { |
| return "" |
| } |
| |
| return fmt.Sprintf("Exited (%d) %s ago", s.ExitCodeValue, units.HumanDuration(time.Now().UTC().Sub(s.FinishedAt))) |
| } |
| |
| // HealthString returns a single string to describe health status. |
| func (s *State) HealthString() string { |
| if s.Health == nil { |
| return types.NoHealthcheck |
| } |
| |
| return s.Health.String() |
| } |
| |
| // IsValidHealthString checks if the provided string is a valid container health status or not. |
| func IsValidHealthString(s string) bool { |
| return s == types.Starting || |
| s == types.Healthy || |
| s == types.Unhealthy || |
| s == types.NoHealthcheck |
| } |
| |
| // StateString returns a single string to describe state |
| func (s *State) StateString() string { |
| if s.Running { |
| if s.Paused { |
| return "paused" |
| } |
| if s.Restarting { |
| return "restarting" |
| } |
| return "running" |
| } |
| |
| if s.RemovalInProgress { |
| return "removing" |
| } |
| |
| if s.Dead { |
| return "dead" |
| } |
| |
| if s.StartedAt.IsZero() { |
| return "created" |
| } |
| |
| return "exited" |
| } |
| |
| // IsValidStateString checks if the provided string is a valid container state or not. |
| func IsValidStateString(s string) bool { |
| if s != "paused" && |
| s != "restarting" && |
| s != "removing" && |
| s != "running" && |
| s != "dead" && |
| s != "created" && |
| s != "exited" { |
| return false |
| } |
| return true |
| } |
| |
| func wait(waitChan <-chan struct{}, timeout time.Duration) error { |
| if timeout < 0 { |
| <-waitChan |
| return nil |
| } |
| select { |
| case <-time.After(timeout): |
| return fmt.Errorf("Timed out: %v", timeout) |
| case <-waitChan: |
| return nil |
| } |
| } |
| |
| // WaitStop waits until state is stopped. If state already stopped it returns |
| // immediately. If you want wait forever you must supply negative timeout. |
| // Returns exit code, that was passed to SetStopped |
| func (s *State) WaitStop(timeout time.Duration) (int, error) { |
| s.Lock() |
| if !s.Running { |
| exitCode := s.ExitCodeValue |
| s.Unlock() |
| return exitCode, nil |
| } |
| waitChan := s.waitChan |
| s.Unlock() |
| if err := wait(waitChan, timeout); err != nil { |
| return -1, err |
| } |
| s.Lock() |
| defer s.Unlock() |
| return s.ExitCode(), nil |
| } |
| |
| // WaitWithContext waits for the container to stop. Optional context can be |
| // passed for canceling the request. |
| func (s *State) WaitWithContext(ctx context.Context) error { |
| // todo(tonistiigi): make other wait functions use this |
| s.Lock() |
| if !s.Running { |
| state := newStateStatus(s.ExitCode(), s.Error()) |
| defer s.Unlock() |
| if state.ExitCode() == 0 { |
| return nil |
| } |
| return state |
| } |
| waitChan := s.waitChan |
| s.Unlock() |
| select { |
| case <-waitChan: |
| s.Lock() |
| state := newStateStatus(s.ExitCode(), s.Error()) |
| s.Unlock() |
| if state.ExitCode() == 0 { |
| return nil |
| } |
| return state |
| case <-ctx.Done(): |
| return ctx.Err() |
| } |
| } |
| |
| // IsRunning returns whether the running flag is set. Used by Container to check whether a container is running. |
| func (s *State) IsRunning() bool { |
| s.Lock() |
| res := s.Running |
| s.Unlock() |
| return res |
| } |
| |
| // GetPID holds the process id of a container. |
| func (s *State) GetPID() int { |
| s.Lock() |
| res := s.Pid |
| s.Unlock() |
| return res |
| } |
| |
| // ExitCode returns current exitcode for the state. Take lock before if state |
| // may be shared. |
| func (s *State) ExitCode() int { |
| return s.ExitCodeValue |
| } |
| |
| // SetExitCode sets current exitcode for the state. Take lock before if state |
| // may be shared. |
| func (s *State) SetExitCode(ec int) { |
| s.ExitCodeValue = ec |
| } |
| |
| // SetRunning sets the state of the container to "running". |
| func (s *State) SetRunning(pid int, initial bool) { |
| s.ErrorMsg = "" |
| s.Running = true |
| s.Restarting = false |
| s.ExitCodeValue = 0 |
| s.Pid = pid |
| if initial { |
| s.StartedAt = time.Now().UTC() |
| } |
| } |
| |
| // SetStopped sets the container state to "stopped" without locking. |
| func (s *State) SetStopped(exitStatus *ExitStatus) { |
| s.Running = false |
| s.Paused = false |
| s.Restarting = false |
| s.Pid = 0 |
| s.FinishedAt = time.Now().UTC() |
| s.setFromExitStatus(exitStatus) |
| close(s.waitChan) // fire waiters for stop |
| s.waitChan = make(chan struct{}) |
| } |
| |
| // SetRestarting sets the container state to "restarting" without locking. |
| // It also sets the container PID to 0. |
| func (s *State) SetRestarting(exitStatus *ExitStatus) { |
| // we should consider the container running when it is restarting because of |
| // all the checks in docker around rm/stop/etc |
| s.Running = true |
| s.Restarting = true |
| s.Pid = 0 |
| s.FinishedAt = time.Now().UTC() |
| s.setFromExitStatus(exitStatus) |
| close(s.waitChan) // fire waiters for stop |
| s.waitChan = make(chan struct{}) |
| } |
| |
| // SetError sets the container's error state. This is useful when we want to |
| // know the error that occurred when container transits to another state |
| // when inspecting it |
| func (s *State) SetError(err error) { |
| s.ErrorMsg = err.Error() |
| } |
| |
| // IsPaused returns whether the container is paused or not. |
| func (s *State) IsPaused() bool { |
| s.Lock() |
| res := s.Paused |
| s.Unlock() |
| return res |
| } |
| |
| // IsRestarting returns whether the container is restarting or not. |
| func (s *State) IsRestarting() bool { |
| s.Lock() |
| res := s.Restarting |
| s.Unlock() |
| return res |
| } |
| |
| // SetRemovalInProgress sets the container state as being removed. |
| // It returns true if the container was already in that state. |
| func (s *State) SetRemovalInProgress() bool { |
| s.Lock() |
| defer s.Unlock() |
| if s.RemovalInProgress { |
| return true |
| } |
| s.RemovalInProgress = true |
| return false |
| } |
| |
| // ResetRemovalInProgress makes the RemovalInProgress state to false. |
| func (s *State) ResetRemovalInProgress() { |
| s.Lock() |
| s.RemovalInProgress = false |
| s.Unlock() |
| } |
| |
| // SetDead sets the container state to "dead" |
| func (s *State) SetDead() { |
| s.Lock() |
| s.Dead = true |
| s.Unlock() |
| } |
| |
| // Error returns current error for the state. |
| func (s *State) Error() string { |
| return s.ErrorMsg |
| } |