81 lines
2.9 KiB
Go
81 lines
2.9 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"github.com/pkg/errors"
|
|
"golang.org/x/sync/semaphore"
|
|
"os"
|
|
"time"
|
|
)
|
|
|
|
type PowerAction string
|
|
|
|
// The power actions that can be performed for a given server. This taps into the given server
|
|
// environment and performs them in a way that prevents a race condition from occurring. For
|
|
// example, sending two "start" actions back to back will not process the second action until
|
|
// the first action has been completed.
|
|
//
|
|
// This utilizes a workerpool with a limit of one worker so that all of the actions execute
|
|
// in a sync manner.
|
|
const (
|
|
PowerActionStart = "start"
|
|
PowerActionStop = "stop"
|
|
PowerActionRestart = "restart"
|
|
PowerActionTerminate = "kill"
|
|
)
|
|
|
|
// Checks if the power action being received is valid.
|
|
func (pa PowerAction) IsValid() bool {
|
|
return pa == PowerActionStart ||
|
|
pa == PowerActionStop ||
|
|
pa == PowerActionTerminate ||
|
|
pa == PowerActionRestart
|
|
}
|
|
|
|
// Helper function that can receive a power action and then process the actions that need
|
|
// to occur for it. This guards against someone calling Start() twice at the same time, or
|
|
// trying to restart while another restart process is currently running.
|
|
//
|
|
// However, the code design for the daemon does depend on the user correctly calling this
|
|
// function rather than making direct calls to the start/stop/restart functions on the
|
|
// environment struct.
|
|
func (s *Server) HandlePowerAction(action PowerAction, waitSeconds ...int) error {
|
|
if s.powerLock == nil {
|
|
s.powerLock = semaphore.NewWeighted(1)
|
|
}
|
|
|
|
// Determines if we should wait for the lock or not. If a value greater than 0 is passed
|
|
// into this function we will wait that long for a lock to be acquired.
|
|
if len(waitSeconds) > 0 && waitSeconds[0] != 0 {
|
|
ctx, _ := context.WithTimeout(context.Background(), time.Second*time.Duration(waitSeconds[0]))
|
|
// Attempt to acquire a lock on the power action lock for up to 30 seconds. If more
|
|
// time than that passes an error will be propagated back up the chain and this
|
|
// request will be aborted.
|
|
if err := s.powerLock.Acquire(ctx, 1); err != nil {
|
|
return errors.WithMessage(err, "could not acquire lock on power state")
|
|
}
|
|
} else {
|
|
// If no wait duration was provided we will attempt to immediately acquire the lock
|
|
// and bail out with a context deadline error if it is not acquired immediately.
|
|
if ok := s.powerLock.TryAcquire(1); !ok {
|
|
return errors.WithMessage(context.DeadlineExceeded, "could not acquire lock on power state")
|
|
}
|
|
}
|
|
|
|
// Release the lock once the process being requested has finished executing.
|
|
defer s.powerLock.Release(1)
|
|
|
|
switch action {
|
|
case PowerActionStart:
|
|
return s.Environment.Start()
|
|
case PowerActionStop:
|
|
return s.Environment.Stop()
|
|
case PowerActionRestart:
|
|
return s.Environment.Restart()
|
|
case PowerActionTerminate:
|
|
return s.Environment.Terminate(os.Kill)
|
|
}
|
|
|
|
return errors.New("attempting to handle unknown power action")
|
|
}
|