// getStatus computes the status of a service state
func getStatus(conn client.Connection, state *servicestate.ServiceState) (dao.Status, error) {
var status dao.Status
// Set the state based on the service state object
if !state.IsRunning() {
status = dao.Stopped
} else if state.IsPaused() {
status = dao.Paused
} else {
status = dao.Running
}
// Set the state based on the host state object
var hostState HostState
if err := conn.Get(hostpath(state.HostID, state.ID), &hostState); err != nil && err != client.ErrNoNode {
return dao.Status{}, err
}
if hostState.DesiredState == int(service.SVCStop) {
switch status {
case dao.Running, dao.Paused:
status = dao.Stopping
case dao.Stopped:
// pass
default:
return dao.Status{}, ErrUnknownState
}
} else if hostState.DesiredState == int(service.SVCRun) {
switch status {
case dao.Stopped:
status = dao.Starting
case dao.Paused:
status = dao.Resuming
case dao.Running:
// pass
default:
return dao.Status{}, ErrUnknownState
}
} else if hostState.DesiredState == int(service.SVCPause) {
switch status {
case dao.Running:
status = dao.Pausing
case dao.Paused, dao.Stopped:
// pass
default:
return dao.Status{}, ErrUnknownState
}
} else {
return dao.Status{}, ErrUnknownState
}
return status, nil
}
// Spawn listens for changes in the host state and manages running instances
func (l *HostStateListener) Spawn(shutdown <-chan interface{}, stateID string) {
var processDone <-chan struct{}
// Let's have exclusive access to this node
lock := newInstanceLock(l.conn, stateID)
if err := lock.Lock(); err != nil {
glog.Errorf("Could not lock service instance %s on host %s: %s", stateID, l.hostID, err)
return
}
// Get the HostState node
var hs HostState
if err := l.conn.Get(hostpath(l.hostID, stateID), &hs); err != nil {
glog.Errorf("Could not load host instance %s on host %s: %s", stateID, l.hostID, err)
l.conn.Delete(hostpath(l.hostID, stateID))
lock.Unlock()
return
}
defer removeInstance(l.conn, hs.ServiceID, hs.HostID, hs.ServiceStateID)
// Get the ServiceState node
var ss servicestate.ServiceState
if err := l.conn.Get(servicepath(hs.ServiceID, hs.ServiceStateID), &ServiceStateNode{ServiceState: &ss}); err != nil {
glog.Errorf("Could not load service instance %s for service %s on host %s: %s", hs.ServiceStateID, hs.ServiceID, hs.HostID, err)
lock.Unlock()
return
}
defer l.stopInstance(processDone, &ss)
lock.Unlock()
for {
// Get the HostState instance
hsEvt, err := l.conn.GetW(hostpath(l.hostID, stateID), &hs)
if err != nil {
glog.Errorf("Could not load host instance %s on host %s: %s", stateID, l.hostID, err)
return
}
// Get the ServiceState instance
ssEvt, err := l.conn.GetW(servicepath(hs.ServiceID, stateID), &ServiceStateNode{ServiceState: &ss})
if err != nil {
glog.Errorf("Could not load service state %s for service %s on host %s: %s", stateID, hs.ServiceID, l.hostID, err)
return
}
// Get the service
var svc service.Service
if err := l.conn.Get(servicepath(hs.ServiceID), &ServiceNode{Service: &svc}); err != nil {
glog.Errorf("Could not load service %s for service instance %s on host %s: %s", hs.ServiceID, stateID, l.hostID, err)
return
}
// Process the desired state
glog.V(2).Infof("Processing %s (%s); Desired State: %d", svc.Name, svc.ID, hs.DesiredState)
switch service.DesiredState(hs.DesiredState) {
case service.SVCRun:
var err error
if !ss.IsRunning() {
// process has stopped
glog.Infof("Starting a new instance for %s (%s): %s", svc.Name, svc.ID, stateID)
if processDone, err = l.startInstance(&svc, &ss); err != nil {
glog.Errorf("Could not start service instance %s for service %s on host %s: %s", hs.ServiceStateID, hs.ServiceID, hs.HostID, err)
return
}
} else if processDone == nil {
glog.Infof("Attaching to instance %s for %s (%s) via %s", stateID, svc.Name, svc.ID, ss.DockerID)
if processDone, err = l.attachInstance(&svc, &ss); err != nil {
glog.Errorf("Could not start service instance %s for service %s on host %s: %s", hs.ServiceStateID, hs.ServiceID, hs.HostID, err)
return
}
}
if ss.IsPaused() {
glog.Infof("Resuming paused instance %s for service %s (%s)", stateID, svc.Name, svc.ID)
if err := l.resumeInstance(&svc, &ss); err != nil {
glog.Errorf("Could not resume paused instance %s for service %s (%s): %s", stateID, svc.Name, svc.ID, err)
return
}
}
case service.SVCPause:
if !ss.IsPaused() {
if err := l.pauseInstance(&svc, &ss); err != nil {
glog.Errorf("Could not pause instance %s for service %s (%s): %s", stateID, svc.Name, svc.ID, err)
return
}
}
case service.SVCStop:
return
default:
glog.V(2).Infof("Unhandled state (%d) of instance %s for service %s (%s)", hs.DesiredState, stateID, svc.Name, svc.ID, err)
}
select {
case <-processDone:
glog.V(2).Infof("Process ended for instance %s for service %s (%s)", stateID, svc.Name, svc.ID)
case e := <-hsEvt:
glog.V(3).Infof("Host instance %s for service %s (%s) received an event: %+v", stateID, svc.Name, svc.ID, e)
if e.Type == client.EventNodeDeleted {
return
}
case e := <-ssEvt:
glog.V(3).Infof("Service instance %s for service %s (%s) received an event: %+v", stateID, svc.Name, svc.ID, e)
if e.Type == client.EventNodeDeleted {
return
}
case <-shutdown:
glog.V(2).Infof("Host instance %s for service %s (%s) received signal to shutdown", stateID, svc.Name, svc.ID)
return
}
}
}