org.lsst.ccs.subsystem.mcm

Class MCMUtilities<MinionT extends Enum<MinionT>,GroupT extends Enum<GroupT>,EventT extends Enum<EventT>>

java.lang.Object

org.lsst.ccs.subsystem.mcm.MCMUtilities<MinionT,GroupT,EventT>

All Implemented Interfaces:

org.lsst.ccs.messaging.AgentPresenceListener

public final class MCMUtilities<MinionT extends Enum<MinionT>,GroupT extends Enum<GroupT>,EventT extends Enum<EventT>>
extends Object
implements org.lsst.ccs.messaging.AgentPresenceListener

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
class	MCMUtilities.ExpectedStateCombination<T extends Enum<T>>

Constructor Summary

Constructors

Constructor and Description
MCMUtilities(org.lsst.ccs.Agent agent)

Method Summary

Modifier and Type	Method and Description
void	activate()
void	addAlertObserver(AlertNotifier.Observer o)
<StateT extends Enum<StateT>> void	addDefaultStateChangeToEventRule(MinionT minion, Class<StateT> stateClass, EventT event)
<StateT extends Enum<StateT>> void	addSingleStateChangeOutToEventRule(MinionT minion, StateT state, EventT event)
<StateT extends Enum<StateT>> void	addSingleStateChangeToEventRule(MinionT minion, StateT state, EventT event)
void	addSubsystemToGroup(String subsystemName, String group)
void	checkEventRules(org.lsst.ccs.bus.states.StateBundle out, org.lsst.ccs.bus.states.StateBundle change)
<StateT extends Enum<StateT>> void	checkState(GroupT g, MinionT sys, StateT... state)
<StateT extends Enum<StateT>> void	checkState(GroupT g, MinionT sys, StateT state)
void	connecting(org.lsst.ccs.bus.data.AgentInfo agent)
void	deleteAlertObserver(AlertNotifier.Observer o)
void	disconnecting(org.lsst.ccs.bus.data.AgentInfo agent)
Future<?>	execute(Runnable r)
<StateT extends Enum<StateT>> MCMUtilities.ExpectedStateCombination<StateT>	expectingState(GroupT g, MinionT m, StateT state)
List<String>	getAvailableGroups()
String	getDestination(GroupT group, MinionT minion)
org.lsst.ccs.bus.states.StateBundle	getState(GroupT g, MinionT sys)
org.lsst.ccs.messaging.StatusAggregator	getStatusAggregator()
GroupT	getSubsystemGroup(String subsystemName)
List<String>	getSubsystemsInGroup(String group)
MinionT	getSubsystemType(String subsystemName)
<StateT extends Enum<StateT>> boolean	isInState(GroupT g, MinionT sys, StateT state)
void	minionStateChange(String source, org.lsst.ccs.bus.states.StateBundle out, org.lsst.ccs.bus.states.StateBundle change)
ScheduledFuture<?>	schedule(Runnable r, Duration delay)
Object	send(GroupT group, MinionT dst, String command, Object... parms)
Object	send(String dst, String command, Object... parms)
Future<Object>	sendAsync(GroupT group, MinionT dst, String command, Object... parms)
Future<Object>	sendAsync(String dst, String command, Object... parms)
Object	sendLongCommand(GroupT group, MinionT dst, long timeout, String command, Object... parms) To send a command which lasts more than defaultTimeout.
Object	sendLongCommand(String dst, long timeout, String command, Object... parms)
void	setAbortingOnAlarmMinions(GroupT group, MinionT... m)
void	setOptionalSubsystem(String subsystemName)
void	setOptionalSubsystemGroup(String groupName)
void	setRequiredSubsystem(String subsystemName)
void	setRequiredSubsystemGroup(String groupName)
<StateT extends Enum<StateT>> void	waitForState(GroupT g, MinionT sys, StateT state, long timeout)
void	waitMillis(long millis)
Future<org.lsst.ccs.bus.messages.StatusMessage>	watchForState(GroupT group, MinionT sys, Enum state)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.lsst.ccs.messaging.AgentPresenceListener

connecting

Constructor Detail

MCMUtilities

public MCMUtilities(org.lsst.ccs.Agent agent)

Method Detail

getStatusAggregator

public org.lsst.ccs.messaging.StatusAggregator getStatusAggregator()

getSubsystemGroup

public GroupT getSubsystemGroup(String subsystemName)

getSubsystemType

public MinionT getSubsystemType(String subsystemName)

getAvailableGroups

@Command(type=QUERY)
public List<String> getAvailableGroups()

getSubsystemsInGroup

@Command(type=QUERY)
public List<String> getSubsystemsInGroup(String group)

addSubsystemToGroup

@Command
public void addSubsystemToGroup(String subsystemName,
                                         String group)

setOptionalSubsystemGroup

@Command
public void setOptionalSubsystemGroup(String groupName)

setRequiredSubsystemGroup

@Command
public void setRequiredSubsystemGroup(String groupName)

setOptionalSubsystem

@Command
public void setOptionalSubsystem(String subsystemName)

setRequiredSubsystem

@Command
public void setRequiredSubsystem(String subsystemName)

activate

public void activate()

send

public Object send(GroupT group,
                   MinionT dst,
                   String command,
                   Object... parms)
            throws Exception

Throws:

Exception

send

public Object send(String dst,
                   String command,
                   Object... parms)
            throws Exception

Throws:

Exception

getDestination

public String getDestination(GroupT group,
                             MinionT minion)

sendLongCommand

public Object sendLongCommand(GroupT group,
                              MinionT dst,
                              long timeout,
                              String command,
                              Object... parms)
                       throws Exception

To send a command which lasts more than defaultTimeout. Used to send command to fcs subsystem (FILTER).

Parameters:

dst -

command -

timeout -

parms -

Returns:

Throws:

Exception

sendLongCommand

public Object sendLongCommand(String dst,
                              long timeout,
                              String command,
                              Object... parms)
                       throws Exception

Throws:

Exception

sendAsync

public Future<Object> sendAsync(GroupT group,
                                MinionT dst,
                                String command,
                                Object... parms)

sendAsync

public Future<Object> sendAsync(String dst,
                                String command,
                                Object... parms)

setAbortingOnAlarmMinions

@SafeVarargs
public final void setAbortingOnAlarmMinions(GroupT group,
                                                         MinionT... m)

schedule

public ScheduledFuture<?> schedule(Runnable r,
                                   Duration delay)

execute

public Future<?> execute(Runnable r)

watchForState

public Future<org.lsst.ccs.bus.messages.StatusMessage> watchForState(GroupT group,
                                                                     MinionT sys,
                                                                     Enum state)

checkState

public <StateT extends Enum<StateT>> void checkState(GroupT g,
                                                     MinionT sys,
                                                     StateT state)

checkState

@SafeVarargs
public final <StateT extends Enum<StateT>> void checkState(GroupT g,
                                                                        MinionT sys,
                                                                        StateT... state)

isInState

public <StateT extends Enum<StateT>> boolean isInState(GroupT g,
                                                       MinionT sys,
                                                       StateT state)

getState

public org.lsst.ccs.bus.states.StateBundle getState(GroupT g,
                                                    MinionT sys)

waitForState

public <StateT extends Enum<StateT>> void waitForState(GroupT g,
                                                       MinionT sys,
                                                       StateT state,
                                                       long timeout)

expectingState

public <StateT extends Enum<StateT>> MCMUtilities.ExpectedStateCombination<StateT> expectingState(GroupT g,
                                                                                                  MinionT m,
                                                                                                  StateT state)

waitMillis

public void waitMillis(long millis)

connecting

public void connecting(org.lsst.ccs.bus.data.AgentInfo agent)

Specified by:

connecting in interface org.lsst.ccs.messaging.AgentPresenceListener

disconnecting

public void disconnecting(org.lsst.ccs.bus.data.AgentInfo agent)

Specified by:

disconnecting in interface org.lsst.ccs.messaging.AgentPresenceListener

addSingleStateChangeToEventRule

public <StateT extends Enum<StateT>> void addSingleStateChangeToEventRule(MinionT minion,
                                                                          StateT state,
                                                                          EventT event)

addSingleStateChangeOutToEventRule

public <StateT extends Enum<StateT>> void addSingleStateChangeOutToEventRule(MinionT minion,
                                                                             StateT state,
                                                                             EventT event)

addDefaultStateChangeToEventRule

public <StateT extends Enum<StateT>> void addDefaultStateChangeToEventRule(MinionT minion,
                                                                           Class<StateT> stateClass,
                                                                           EventT event)

checkEventRules

public void checkEventRules(org.lsst.ccs.bus.states.StateBundle out,
                            org.lsst.ccs.bus.states.StateBundle change)

minionStateChange

public void minionStateChange(String source,
                              org.lsst.ccs.bus.states.StateBundle out,
                              org.lsst.ccs.bus.states.StateBundle change)

addAlertObserver

public void addAlertObserver(AlertNotifier.Observer o)

deleteAlertObserver

public void deleteAlertObserver(AlertNotifier.Observer o)