Subsystem (LSST Camera Control Software - CCS Toolkit (Pom) 1.6.4 API)

java.lang.Object
- org.lsst.ccs.Subsystem

All Implemented Interfaces:

CommandExecutor, CommandListener, StatusListener, StatusListens

Direct Known Subclasses:

BasicModularSubSystem, BusMaster, NodeModularSubsystem
```
public class Subsystem
extends Object
implements CommandListener, StatusListener, CommandExecutor
```
The base class for a CCS subsystem.
This object will register itself on the three buses (control, status, log). It broadcasts its status, and can receive Commands.

Author:

Eric Aubourg, Bernard AMADE

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected class`	`Subsystem.DictionarySearchResult` an internal data object for describing the result of a dictionary search.
`static class`	`Subsystem.SignalThread` threads that run "signals" are peculiar because they know about a time deadline.
`static class`	`Subsystem.State` this class represents a composite state ofr a Subsystem.
`protected class`	`Subsystem.StatusBroadcaster` the Runnable in charge of broadcasting status

Field Summary

Fields
Modifier and Type	Field and Description
`protected Object`	`actionMonitor` monitor used by actions
`protected ThreadGroup`	`ancillaryGroup` This group should be used by Thread created by programmers (for instance Threads reading data ).
`protected boolean`	`closing` are we closing ?
`protected LocalCommandDictionary`	`commandBuilder` we know about the subsystem available commands
`protected String`	`commandBusSelector`
`protected ThreadGroup`	`commandGroup` all commands are executed in separate threads that belong to this threadGroup.
`protected Object`	`commandMonitor` used mostly for test that wait for execution of a command
`protected ConfigurationProxy`	`configurationProxy` the proxy for configuration (useful only for passive subsystem)
`protected static ThreadLocal<Subsystem>`	`currentSubsystem` Deprecated.
`protected MessagingFactory`	`fac` access to messaging layer.
`protected boolean`	`forceShutdown` used to force shutdown.
`protected boolean`	`initializing` are we initializing ?
`protected Thread`	`initThread` the Thread that performs initialisation
`protected Subsystem.State`	`innerState` Subsystem inner state read/modification of this should be synchronized on "this"
`protected boolean`	`inTestContext` used to know if the usbsystem is in test context: this is important since parameter changes in testcontext will not be registered by the configuration database
`static ThreadLocal<CurrentCommandContext>`	`LOCAL_EXECUTION_INFO` ThreadLocal variable: what is the current thread doing?
`protected Map<String,LockArbitrator.LockOwnerInfo>`	`locks` locks management.
`protected static Logger`	`log` logger
`protected LogBusHandler`	`logBusHandler` the logging bushandler: it logs to the lob bus.
`protected Object`	`signalsMonitor` monitor used by "signal" threads
`protected boolean`	`startInEngineeringMode` to be set if we want the subsystem to be started in engineering mode but works only if the subsystem is already in test context.
`protected Object`	`statusBroadcasterLock` monitor for status broadcasting operations
`protected Thread`	`statusBroadcasterThread` the Thread in charge of status broadcasting
`protected String`	`statusBusSelector`
`protected boolean`	`waitingForCommandTermination` might be used for tests that want to test the result of a command.

Constructor Summary

Constructors
Constructor and Description

Subsystem()
Deprecated.

Subsystem(String name, Agent.AgentType type)

Constructors
Constructor and Description
`Subsystem()` Deprecated.
`Subsystem(String name, Agent.AgentType type)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`abort()` to be overriden : semantics of an urgent halt
`void`	`abort(long expectedMaxDelay)` to be overriden : semantics of an urgent halt with a time limit
`void`	`addLock(String target, LockArbitrator.LockOwnerInfo info)` adds a lock (TODO: DOCUMENT)
`void`	`broadcastAlarm()` Deprecated.
`void`	`broadcastAlarm(String message)` Deprecated.
`void`	`broadcastAlarmClear(String message)` Deprecated.
`void`	`broadcastStatus(int statusBroadcastPeriod)` broadcast the current status
`void`	`broadcastStatus(Status s)` broadcast a status object
`void`	`checkAllHardwareStarted()` checks if all hardwares have been correctly started.
`void`	`checkAllHardwareStopped()` checks if all hardwares have been correctly stopped..
`void`	`checkHardware()` to be called before activating anything and to be called again once problems are supposed to have been addressed.
`void`	`clearAlarms(String message)` clear alarms, publishes an AlarmClear message and returns to Alarm state NOMINAL
`void`	`completeInitialization()` command to complete initialisation (if commands were issued to heal hardware problems)
`static Subsystem.State`	`createState(Phase phase, Mode mode, CommandState activity, AlarmState alarm)` this is for testing purposes only (when in need to compare states)
`void`	`doShutdown()` to be overriden by subclasses.
`void`	`doStart()` Called upon subsystem start.
`protected Object`	`executeCommandSingleThread(Command cmd)` Deprecated.
`protected Status`	`fillStatus(Status s)` Store current state and status information in a Status object.
`void`	`forceShutdown()` to be called before a shutdown, when previous shutdowns faild
`AgentPresenceManager`	`getAgentPresenceManager()`
`ThreadGroup`	`getAncillaryGroup()`
`CCSVersions`	`getCCSVersions()` Command to get the CCSVersions object for the current CCS Environment.
`protected LocalCommandDictionary`	`getCommandBuilder(Object obj)` utility method to get a `LocalCommandDictionary`
`String`	`getCommandBusSelector()` Deprecated.
`String`	`getConfiguration()`
`ConfigurationProxy`	`getConfigurationProxy()`
`Thread`	`getCurrentActionThread()` gets the current action thread which is alive (and kills it if zombie)
`static String`	`getCurrentSubsystemName()` Deprecated.
`String`	`getDefaultSelector()` Deprecated.
`static String`	`getEthHardAddress()` MAC address of the main ethernet card
`Subsystem.State`	`getInnerState()` use for tests only
`Logger`	`getLogger()`
`MessagingFactory`	`getMessagingAccess()`
`String`	`getName()`
`int`	`getNumberCommandThreads()`
`static String`	`getSoftwareRevision()` Software revision
`PublishedState`	`getStateForPublication()` create a Published state containing a clone of the innerstate
`Status`	`getStatus(int statusBroadcastPeriod)` returns our current status, including State can be overriden to return a Status subclass if needed when not using ModularSubsystem
`int`	`getStatusBroadcastPeriod()`
`String`	`getStatusBusSelector()` Deprecated.
`Dictionary`	`getSystemDictionary()` command to get the subsystem disctionary
`String`	`getTag()`
`void`	`initialisationEndPhase(boolean checkHardwareOK)` runs the last phase of initialisation.
`protected void`	`initLogBusHandler()` connects a LogBusHandler to the Log bus.
`void`	`interruptActionThread()` command to send an interrupt to the only action command thread.
`void`	`interruptAllRunningCommands()` command to send an interrupt to all running commands (expected behaviour of commands is implementation dependant).
`void`	`interruptAllSignalThreads()` command to send an interrupt all "signal" threads
`void`	`interruptAncillaryThreads(String expReg)` a sends a software interrupt to all 'ancillary' Threads whose name matches the regular expression
`void`	`interruptInitThread()` sends an interrupt to the initialisation thread.
`boolean`	`isInEngineeringMode()` tells if the subystem is in Engineering mode
`boolean`	`isInTestContext()` is this subsystem in test context?
`boolean`	`isListenToStatus()` does this subsystem listen to the status bus
`boolean`	`isMaster()` to be overriden : tells if the subsystem invokes command
`boolean`	`isMultithreaded()` Deprecated.
`boolean`	`isSlave()` to be overriden : tells if the subsystem execute command (they all do: but these are commands that go further than the standard list of subsystem commands).
`boolean`	`isStartedInEngineeringMode()` is this subsystem started in engineering mode?
`void`	`lockUpdate(String target, LockArbitrator.LockOwnerInfo info, boolean isAdd)` TODO: document
`void`	`onAck(CommandAck a)` reveived an ack: to be overriden
`void`	`onCommand(Command cmd)` what happens if a command is received? (see internal comments)
`void`	`onReply(CommandReply r)` Received reply message on the command bus.
`void`	`onStatus(BusMessage s)` Received status message.
`void`	`ping()` broadcast on the status bus a message of presence
`void`	`postStart()` called after subsystem has been started
`String`	`printRunningCommands()` Command returning a String describing which commands are running
`void`	`publishData(DataValueNotification td)` Deprecated.
`void`	`publishData(List<? extends ValueNotification> tdl)` Deprecated.
`void`	`publishData(String name, Object value)` Deprecated.
`void`	`publishData(String name, Object value, long tStamp)` Deprecated.
`void`	`publishData(String name, Serializable value)` Deprecated.
`void`	`publishData(String name, Serializable value, long tStamp)` Deprecated.
`void`	`publishData(ValueNotification td)` Deprecated.
`void`	`publishMetaData(String dataname, String metadataname, String value)` Sends trending metadata on the status bus It allows to associate to some some data associated meta data like alarm limits.
`void`	`publishReply(CommandReply myReply)` Deprecated.
`protected void`	`publishStateChange(Subsystem.State before, Subsystem.State after)` internal service: publishes a state transition
`void`	`publishStatus(KVList kvlist)`
`void`	`publishStatus(List<ValueNotification> tdl)`
`void`	`publishStatus(long timestamp, KVList kvlist)`
`void`	`publishStatus(long timestamp, String key, Object value)`
`void`	`publishStatus(String key, long[] timestamps, Object[] objects)`
`void`	`publishStatus(String key, Object value)`
`protected void`	`publishStatusData(EncodedDataStatus dataStatus)`
`protected void`	`publishTrendingStatus(TrendingStatus ts)`
`void`	`raiseAlarm(String message)` raises an Alarm: state is switched to ENGINEERING_FAULT and ALARM , state change published.
`protected Object`	`rawCommandExecution(Command cmd, Object obj)` placeholder for future modification of command execution
`void`	`registerAsBusMaster()` todo: implement relevant code
`void`	`removeLock(String target)` removes a lock (TODO: document)
`void`	`removeLogPanicState()` tries to reset the panic state of a the Log Bus Handler (logging failed before)
`protected Subsystem.DictionarySearchResult`	`searchForDictionary(boolean fatal, Command command, Object goal, LocalCommandDictionary localDict)` utility method to produce a `DictionarySearchResultObject`.
`protected Subsystem.DictionarySearchResult`	`searchForDictionary(Command command)` searches for details of an incoming command
`void`	`sendRawStatus(Status status)` sends a status message which is not to be published as data for the trending database.
`void`	`setBusLogHandlerLevel(String levelName)` sets the level at which the Log Bus Hander will start logging.
`void`	`setCommandBusSelector(String selector)` Deprecated.
`protected void`	`setConfigurationProxy(ConfigurationProxy configurationProxy)` this method should not be used once the proxy is delegated to all components so it should not be public! TODO: this makes only sense for Modular subsystem (so move away)
`void`	`setListenToStatus(boolean listenToStatus)` Will this subsystem listen to the status bus?
`void`	`setLogFormat(String format)` command to set a format for the TextFormatter of LogBusHandler (see logging.properties doc)
`void`	`setLogHandlerLevel(String handler, String level)` Command to set a level for a given handler
`void`	`setLogLevel(String keyLogger, String levelName)` sets the Level of a named Logger
`void`	`setMultithreaded(boolean multithreaded)` Deprecated.
`void`	`setName(String name)` Deprecated. use subsystem(String name, AgentType type) constructor instead of empty constructor
`void`	`setStackTraceDepth(int depth)` Will modify the depth of stackTrace printing for ALL handlers (including the LogBusHandler)
`void`	`setStatusBroadcastPeriod(int statusBroadcastPeriod)` how often (in seconds) should our status be broadcasted?
`void`	`setStatusBusSelector(String selector)` Deprecated.
`Object`	`shutdown()` Clean shutdown of subsystem: call stop for hardware stopping before invoking this method.
`void`	`start()` Starts the subsystem.
`protected void`	`startStatusBroadcasting()` Starts broadcasting our status
`void`	`stayAlive()` Blocks the current thread that started the subsystem until the subsystem receives a shutdown.
`void`	`stop(long expectedMaxDelay)` to be overriden : semantics of "soft" stop
`protected void`	`stopStatusBroadcasting()` Stops broadcasting our status This can only be called when the subsystem is shutting down
`boolean`	`switchToEngineeringMode()` command to switch to ENGINEERING mode
`void`	`switchToErrorState(String message)` Deprecated.
`void`	`switchToNormalMode()` tries to get back to normal mode
`protected void`	`switchToShutdownState()` state modifications linked to a shutdown request
`void`	`tryReadyState(String message)` command to try to switch to READY state
`protected void`	`updateCurrentSubsystem()` Deprecated.
`org.lsst.ccs.SystemState`	`updateState(org.lsst.ccs.SystemState newState)` Deprecated.
`org.lsst.ccs.SystemState`	`updateState(org.lsst.ccs.SystemState newState, String extraInfo)` Deprecated.
`boolean`	`waitForCommandExecution(long timeOut)` mostly used for tests that need to test the result of single command execution
`boolean`	`waitForReadyState()` waits for all actions and signals to terminate before switching to READY.
`void`	`warning(String message)` publishes a warning -> Alarm state to WARNING

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- innerState
```
protected Subsystem.State innerState
```
  Subsystem inner state read/modification of this should be synchronized on "this"
- initializing
```
protected volatile boolean initializing
```
  are we initializing ?
- closing
```
protected volatile boolean closing
```
  are we closing ?
- commandGroup
```
protected ThreadGroup commandGroup
```
  all commands are executed in separate threads that belong to this threadGroup.
- ancillaryGroup
```
protected ThreadGroup ancillaryGroup
```
  This group should be used by Thread created by programmers (for instance Threads reading data ). Executors should use this group.
- actionMonitor
```
protected final Object actionMonitor
```
  monitor used by actions
- commandMonitor
```
protected final Object commandMonitor
```
  used mostly for test that wait for execution of a command
- waitingForCommandTermination
```
protected volatile boolean waitingForCommandTermination
```
  might be used for tests that want to test the result of a command.
- signalsMonitor
```
protected final Object signalsMonitor
```
  monitor used by "signal" threads
- initThread
```
protected Thread initThread
```
  the Thread that performs initialisation
- forceShutdown
```
protected volatile boolean forceShutdown
```
  used to force shutdown. TODO: no longer in use -> reconsider
- log
```
protected static Logger log
```
  logger
- fac
```
protected MessagingFactory fac
```
  access to messaging layer.
- commandBusSelector
```
protected String commandBusSelector
```
- statusBusSelector
```
protected String statusBusSelector
```
- inTestContext
```
protected boolean inTestContext
```
  used to know if the usbsystem is in test context: this is important since parameter changes in testcontext will not be registered by the configuration database
- startInEngineeringMode
```
protected boolean startInEngineeringMode
```
  to be set if we want the subsystem to be started in engineering mode but works only if the subsystem is already in test context.
- configurationProxy
```
protected ConfigurationProxy configurationProxy
```
  the proxy for configuration (useful only for passive subsystem)
- logBusHandler
```
protected LogBusHandler logBusHandler
```
  the logging bushandler: it logs to the lob bus.
- commandBuilder
```
protected LocalCommandDictionary commandBuilder
```
  we know about the subsystem available commands
- statusBroadcasterThread
```
protected volatile Thread statusBroadcasterThread
```
  the Thread in charge of status broadcasting
- statusBroadcasterLock
```
protected volatile Object statusBroadcasterLock
```
  monitor for status broadcasting operations
- locks
```
protected Map<String,LockArbitrator.LockOwnerInfo> locks
```
  locks management. TODO: implement
- currentSubsystem
```
@Deprecated
protected static ThreadLocal<Subsystem> currentSubsystem
```
  Deprecated.
- LOCAL_EXECUTION_INFO
```
public static final ThreadLocal<CurrentCommandContext> LOCAL_EXECUTION_INFO
```
  ThreadLocal variable: what is the current thread doing?

Constructor Detail

Subsystem
```
@Deprecated
public Subsystem()
```
Deprecated.

todo : deprecate and replace with constructor with name and all operations

Subsystem

public Subsystem(String name,
                 Agent.AgentType type)

Method Detail

createState

public static Subsystem.State createState(Phase phase,
                                          Mode mode,
                                          CommandState activity,
                                          AlarmState alarm)

this is for testing purposes only (when in need to compare states)

Parameters:: phase -; mode -; activity -; alarm -
Returns:

getSoftwareRevision
```
public static String getSoftwareRevision()
```
Software revision

Returns:

the svn revision

getMessagingAccess
```
public MessagingFactory getMessagingAccess()
```
Returns:

access to the messaging buses

getInnerState

public Subsystem.State getInnerState()

use for tests only

Returns:

isInEngineeringMode

@Command(description="is the system in engineering mode ?",
         type=QUERY,
         category=SYSTEM)
public boolean isInEngineeringMode()

tells if the subystem is in Engineering mode

Returns:

isMaster
```
public boolean isMaster()
```
to be overriden : tells if the subsystem invokes command

Returns:

isSlave
```
public boolean isSlave()
```
to be overriden : tells if the subsystem execute command (they all do: but these are commands that go further than the standard list of subsystem commands).

Returns:

getEthHardAddress
```
public static String getEthHardAddress()
```
MAC address of the main ethernet card

getLogger
```
public Logger getLogger()
```
Returns:

the current logger (use sparingly and prefer your own logger)

getCurrentActionThread
```
public Thread getCurrentActionThread()
```
gets the current action thread which is alive (and kills it if zombie)

Returns:

getAncillaryGroup
```
public ThreadGroup getAncillaryGroup()
```
Returns:

the "background group" where ancilarry

setListenToStatus
```
public void setListenToStatus(boolean listenToStatus)
```
Will this subsystem listen to the status bus?

isListenToStatus
```
public boolean isListenToStatus()
```
does this subsystem listen to the status bus

Returns:

isInTestContext

@Command(description="is the system in test context",
         type=QUERY,
         category=SYSTEM)
public boolean isInTestContext()

is this subsystem in test context?

Returns:

isStartedInEngineeringMode
```
public boolean isStartedInEngineeringMode()
```
is this subsystem started in engineering mode?

Returns:

setName
```
@Deprecated
public void setName(String name)
```
Deprecated. use subsystem(String name, AgentType type) constructor instead of empty constructor

Subsystem name. This method initialize important subsystem features and should be integrated in constructor.
BEWARE : you cannot start a subsystem if this method has'nt been invoked (hence it needs incorporation in constructor)

Parameters:

name -

initLogBusHandler
```
protected void initLogBusHandler()
```
connects a LogBusHandler to the Log bus. Should be called only when messaging is initialized properly.

getName
```
public String getName()
```
Returns:

name of subsysteù

getConfiguration
```
public String getConfiguration()
```
Returns:

configuration name (as known to the configuration proxy) TODO: this makes only sense for Modular subsystem (so move away)

getTag
```
public String getTag()
```
Returns:

tag name TODO: this makes only sense for Modular subsystem (so move away)

getConfigurationProxy
```
public ConfigurationProxy getConfigurationProxy()
```
Returns:

the configuration proxy TODO: this makes only sense for Modular subsystem (so move away)

setConfigurationProxy
```
protected void setConfigurationProxy(ConfigurationProxy configurationProxy)
```
this method should not be used once the proxy is delegated to all components so it should not be public! TODO: this makes only sense for Modular subsystem (so move away)

getDefaultSelector
```
@Deprecated
public String getDefaultSelector()
```
Deprecated.

Transport layer selector for messages we listen to *

getStatusBusSelector

@Deprecated
public String getStatusBusSelector()

Deprecated.

setStatusBusSelector

@Deprecated
public void setStatusBusSelector(String selector)

Deprecated.

getCommandBusSelector

@Deprecated
public String getCommandBusSelector()

Deprecated.

setCommandBusSelector

@Deprecated
public void setCommandBusSelector(String selector)

Deprecated.

start
```
public void start()
```
Starts the subsystem.
Not to be overriden, will call doStart

initialisationEndPhase
```
public void initialisationEndPhase(boolean checkHardwareOK)
                            throws HardwareException
```
runs the last phase of initialisation. If property "org.lsst.ccs.stayAlive" is true then this method blocks the initialisation thread and waits until a command to shutdown unblocks it.

Parameters:

checkHardwareOK - false if engineering fault was entered due to checkHardware errors

Throws:

HardwareException - if some hardware is still not started

stayAlive
```
public void stayAlive()
```
Blocks the current thread that started the subsystem until the subsystem receives a shutdown. use with care: it will block the current thread (then you cannot execute any code left behind this invocation).
If invoked from a different thread than the one that invoked the start() method this method does nothing! (same thing happens if invoked BEFORE start())

completeInitialization

@Command(description="completes initialization after hardware problems corrections",
         type=ACTION)
public void completeInitialization()
                                                                                                                                       throws SystemStateException,
                                                                                                                                              HardwareException

command to complete initialisation (if commands were issued to heal hardware problems)

Throws:: SystemStateException; HardwareException

doStart
```
public void doStart()
```
Called upon subsystem start.
To be overriden by derived classes if required

postStart
```
public void postStart()
               throws HardwareException
```
called after subsystem has been started
to be overriden.

Throws:

HardwareException - because some "homing" operations may be tried by the hardware

checkHardware
```
public void checkHardware()
                   throws HardwareException
```
to be called before activating anything and to be called again once problems are supposed to have been addressed. this method fires a "compound" exception

Throws:

HardwareException

checkAllHardwareStarted
```
public void checkAllHardwareStarted()
                             throws HardwareException
```
checks if all hardwares have been correctly started.

Throws:

HardwareException - a compound exception that list the exceptions fired by hardwares that are not started.

checkAllHardwareStopped
```
public void checkAllHardwareStopped()
                             throws HardwareException
```
checks if all hardwares have been correctly stopped..

Throws:

HardwareException - a compound exception that list the exceptions fired by hardwares that are not stopped.

getStatus
```
public Status getStatus(int statusBroadcastPeriod)
```
returns our current status, including State can be overriden to return a Status subclass if needed when not using ModularSubsystem

fillStatus
```
protected Status fillStatus(Status s)
```
Store current state and status information in a Status object.

Returns:

the status

setStatusBroadcastPeriod
```
public void setStatusBroadcastPeriod(int statusBroadcastPeriod)
```
how often (in seconds) should our status be broadcasted?

Parameters:

statusBroadcastPeriod - (seconds)

getStatusBroadcastPeriod
```
public int getStatusBroadcastPeriod()
```
Returns:

the period (in seconds) for status broadcasting

stopStatusBroadcasting
```
protected void stopStatusBroadcasting()
```
Stops broadcasting our status This can only be called when the subsystem is shutting down

startStatusBroadcasting
```
protected void startStatusBroadcasting()
```
Starts broadcasting our status

broadcastStatus

public void broadcastStatus(int statusBroadcastPeriod)

broadcast the current status

broadcastStatus
```
public void broadcastStatus(Status s)
```
broadcast a status object

Parameters:

s -

shutdown

@Command(description="shutdown",
         type=ACTION)
public Object shutdown()
                                                                       throws HardwareException

Clean shutdown of subsystem: call stop for hardware stopping before invoking this method.

Throws:: HardwareException - if some hardware is not stopped

doShutdown
```
public void doShutdown()
```
to be overriden by subclasses. this code is called by shutdown after all commands terminated it should notify components it's time to perform shutdown operation

forceShutdown

@Command(description="forces blocked shutdown (not implemented yet!)",
         type=ABORT)
public void forceShutdown()

to be called before a shutdown, when previous shutdowns faild

abort

@Command(description="halt hardware",
         type=ABORT)
public void abort()

to be overriden : semantics of an urgent halt

abort

@Command(description="halt hardware with expected max delay",
         type=ABORT)
public void abort(long expectedMaxDelay)

to be overriden : semantics of an urgent halt with a time limit

stop

@Command(description="stops hardware with expected max delay",
         type=ACTION)
public void stop(long expectedMaxDelay)
                                                                                               throws HardwareException

to be overriden : semantics of "soft" stop

Parameters:: expectedMaxDelay - time limit for execution
Throws:: HardwareException

updateState

@Deprecated
public org.lsst.ccs.SystemState updateState(org.lsst.ccs.SystemState newState,
                                                        String extraInfo)

Deprecated.

Subsystem state change Should not be used outside

Parameters:: newState -
Returns:

updateState

@Deprecated
public org.lsst.ccs.SystemState updateState(org.lsst.ccs.SystemState newState)

Deprecated.

publishStateChange

protected void publishStateChange(Subsystem.State before,
                                  Subsystem.State after)

internal service: publishes a state transition

Parameters:: before -; after -

switchToShutdownState
```
protected void switchToShutdownState()
```
state modifications linked to a shutdown request

switchToEngineeringMode

@Command(description="switch to ENGINEERING mode",
         type=ACTION)
public boolean switchToEngineeringMode()

command to switch to ENGINEERING mode

Returns:

switchToNormalMode

@Command(description="Tries to get back to NORMAL mode",
         type=ACTION)
public void switchToNormalMode()
                                                                                                       throws SystemStateException

tries to get back to normal mode

Throws:: SystemStateException - if alarms are not cleared or signals are still running

raiseAlarm
```
public void raiseAlarm(String message)
```
raises an Alarm: state is switched to ENGINEERING_FAULT and ALARM , state change published.

Parameters:

message -

switchToErrorState

@Deprecated
public void switchToErrorState(String message)

Deprecated.

warning
```
public void warning(String message)
```
publishes a warning -> Alarm state to WARNING

Parameters:

message -

clearAlarms

@Command(description="clear alarms",
         type=QUERY)
public void clearAlarms(String message)

clear alarms, publishes an AlarmClear message and returns to Alarm state NOMINAL

Parameters:: message -

tryReadyState

@Command(description="tries to switch to READY ",
         type=QUERY)
public void tryReadyState(String message)
                                                                                          throws SystemStateException

command to try to switch to READY state

Parameters:: message -
Throws:: SystemStateException - if acction commands or signals are still running or if the subsystem is closing

waitForReadyState

@Command(description="tries to wait until READY ",
         type=QUERY)
public boolean waitForReadyState()
                                                                                                  throws ClosingStateException

waits for all actions and signals to terminate before switching to READY.

Returns:: false if waits are interrupted (the switch is then not operated)
Throws:: ClosingStateException - if closing

getStateForPublication
```
public PublishedState getStateForPublication()
```
create a Published state containing a clone of the innerstate

Returns:

broadcastAlarm

@Deprecated
public void broadcastAlarm()

Deprecated.

broadcastAlarm

@Deprecated
public void broadcastAlarm(String message)

Deprecated.

broadcastAlarmClear

@Deprecated
public void broadcastAlarmClear(String message)

Deprecated.

isMultithreaded
```
@Deprecated
public boolean isMultithreaded()
```
Deprecated.

Specified by:

isMultithreaded in interface CommandExecutor

setMultithreaded
```
@Deprecated
public void setMultithreaded(boolean multithreaded)
```
Deprecated.

Is the current subsystem multithreaded (for command processing)

Parameters:

multithreaded -

getCurrentSubsystemName

@Deprecated
public static String getCurrentSubsystemName()

Deprecated.

updateCurrentSubsystem

@Deprecated
protected void updateCurrentSubsystem()

Deprecated.

addLock

public void addLock(String target,
                    LockArbitrator.LockOwnerInfo info)

adds a lock (TODO: DOCUMENT)

Parameters:: target -; info -

removeLock
```
public void removeLock(String target)
```
removes a lock (TODO: document)

Parameters:

target -

lockUpdate

public void lockUpdate(String target,
                       LockArbitrator.LockOwnerInfo info,
                       boolean isAdd)

TODO: document

Parameters:: target -; info -; isAdd -

onCommand
```
public void onCommand(Command cmd)
```
what happens if a command is received? (see internal comments)

Specified by:

onCommand in interface CommandListener

Parameters:

cmd -

waitForCommandExecution
```
public boolean waitForCommandExecution(long timeOut)
```
mostly used for tests that need to test the result of single command execution

Parameters:

timeOut -

Returns:

executeCommandSingleThread
```
@Deprecated
protected Object executeCommandSingleThread(Command cmd)
```
Deprecated.

Synchronized method to execute a command in a single thread. In effect it queues commands, but without any specific order. The execute method of the command object will be called.

Parameters:

cmd - The command to be executed

Returns:

the command result

searchForDictionary

protected Subsystem.DictionarySearchResult searchForDictionary(Command command)
                                                        throws CommandInvocationException

searches for details of an incoming command

This method is overriden to deal with Modular subsystem

Parameters:: command -
Returns:
Throws:: CommandInvocationException

searchForDictionary

protected Subsystem.DictionarySearchResult searchForDictionary(boolean fatal,
                                                               Command command,
                                                               Object goal,
                                                               LocalCommandDictionary localDict)
                                                        throws CommandInvocationException

utility method to produce a DictionarySearchResultObject.

Parameters:: fatal -; command -; goal -; localDict -
Returns:
Throws:: CommandInvocationException

getCommandBuilder
```
protected LocalCommandDictionary getCommandBuilder(Object obj)
```
utility method to get a LocalCommandDictionary

Parameters:

obj -

Returns:

getSystemDictionary

@Command(description="get the command dictionary for the subsystem",
         type=QUERY,
         category=SYSTEM)
public Dictionary getSystemDictionary()

command to get the subsystem disctionary

Returns:

getCCSVersions

@Command(description="Get the CCS Versions for the current CCS Environment",
         type=QUERY,
         category=SYSTEM)
public CCSVersions getCCSVersions()

Command to get the CCSVersions object for the current CCS Environment.

Returns:: The CCSVersions object for the current CCS Environment

rawCommandExecution

protected Object rawCommandExecution(Command cmd,
                                     Object obj)
                              throws NoSuchMethodException,
                                     IllegalAccessException,
                                     InvocationTargetException

placeholder for future modification of command execution

Parameters:: cmd -; obj -
Returns:
Throws:: NoSuchMethodException; IllegalAccessException; InvocationTargetException

onStatus
```
public void onStatus(BusMessage s)
```
Received status message. Default empty implementation, to be overriden

Specified by:

onStatus in interface StatusListener

onReply
```
public void onReply(CommandReply r)
```
Received reply message on the command bus. Default empty implementation, to be overriden. Reply will have same correlationid as original command

Specified by:

onReply in interface CommandListener

onAck
```
public void onAck(CommandAck a)
```
reveived an ack: to be overriden

Specified by:

onAck in interface CommandListener

Parameters:

a -

registerAsBusMaster
```
public void registerAsBusMaster()
```
todo: implement relevant code

publishData

@Deprecated
public void publishData(String name,
                                    Object value,
                                    long tStamp)

Deprecated.

Sends trending data on the status bus

publishData

@Deprecated
public void publishData(String name,
                                    Serializable value,
                                    long tStamp)

Deprecated.

publishData

@Deprecated
public void publishData(String name,
                                    Object value)

Deprecated.

publishData

@Deprecated
public void publishData(String name,
                                    Serializable value)

Deprecated.

publishData

@Deprecated
public void publishData(List<? extends ValueNotification> tdl)

Deprecated.

publishData

@Deprecated
public void publishData(ValueNotification td)

Deprecated.

publishData

@Deprecated
public void publishData(DataValueNotification td)

Deprecated.

publishTrendingStatus

protected void publishTrendingStatus(TrendingStatus ts)

publishMetaData

public void publishMetaData(String dataname,
                            String metadataname,
                            String value)

Sends trending metadata on the status bus It allows to associate to some some data associated meta data like alarm limits.

publishStatusData

protected void publishStatusData(EncodedDataStatus dataStatus)

publishStatus

public void publishStatus(long timestamp,
                          String key,
                          Object value)

publishStatus

public void publishStatus(String key,
                          Object value)

publishStatus

public void publishStatus(long timestamp,
                          KVList kvlist)

publishStatus

public void publishStatus(KVList kvlist)

publishStatus

public void publishStatus(String key,
                          long[] timestamps,
                          Object[] objects)

publishStatus

public void publishStatus(List<ValueNotification> tdl)

Parameters:: tdl -

publishReply

@Deprecated
public void publishReply(CommandReply myReply)

Deprecated.

sendRawStatus
```
public void sendRawStatus(Status status)
```
sends a status message which is not to be published as data for the trending database.

Parameters:

status -

setBusLogHandlerLevel

@Command(description="set the level of the BusLogHandler",
         type=QUERY)
public void setBusLogHandlerLevel(String levelName)

sets the level at which the Log Bus Hander will start logging.

Parameters:: levelName - the name of a JUL Level

setLogLevel

@Command(description="set the level of a Logger",
         type=QUERY)
public void setLogLevel(String keyLogger,
                                                                                               String levelName)

sets the Level of a named Logger

Parameters:: keyLogger - name of Logger (can be a package or a "concern" such as "INIT", "CONFIG"; levelName - the name of a JUL Level

setStackTraceDepth
```
@Command(description="sets the the depth of stacktraces in Logger messages",
         type=QUERY)
public void setStackTraceDepth(int depth)
```
Will modify the depth of stackTrace printing for ALL handlers (including the LogBusHandler)

Parameters:

depth - could be negative if we want all the stackTrace

setLogFormat

@Command(description="sets the format used by TextFormatter for LogEvent messages ",
         type=QUERY)
public void setLogFormat(String format)

command to set a format for the TextFormatter of LogBusHandler (see logging.properties doc)

Parameters:: format -

setLogHandlerLevel

@Command(description="sets the handler (ConsoleHandlerN, FileHandlerN, LogBusHandler) log level",
         type=QUERY)
public void setLogHandlerLevel(String handler,
                                                                                                                                                      String level)

Command to set a level for a given handler

Parameters:: handler - can be ConsoleHandlerN, FileHandlerN, LogBusHandler; level -

removeLogPanicState

@Command(description="tries to stop the panic state of logmanagement",
         type=QUERY)
public void removeLogPanicState()

tries to reset the panic state of a the Log Bus Handler (logging failed before)

getNumberCommandThreads

@Command(description="gets the number of commands which are currently running (except the current one!)",
         type=QUERY)
public int getNumberCommandThreads()

Returns:: the number of commands currently executing (except the current one)

printRunningCommands

@Command(description="gets the name of commands which are currently running",
         type=QUERY)
public String printRunningCommands()

Command returning a String describing which commands are running

Returns:

interruptAllRunningCommands

@Command(description="sends an interrupt for all command threads (behaviour of commands are implementation dependent)",
         type=ABORT)
public void interruptAllRunningCommands()

command to send an interrupt to all running commands (expected behaviour of commands is implementation dependant).

interruptActionThread

@Command(description="sends an interrupt to a running ACTION thread",
         type=ABORT)
public void interruptActionThread()

command to send an interrupt to the only action command thread.

interruptAllSignalThreads

@Command(description="sends an interrupt to all running SIGNAL  threads",
         type=ABORT)
public void interruptAllSignalThreads()

command to send an interrupt all "signal" threads

interruptAncillaryThreads

@Command(description="sends an interrupt to any \'ancillary\' thread whose name matches the regular expression passed as argument",
         type=ABORT)
public void interruptAncillaryThreads(String expReg)

a sends a software interrupt to all 'ancillary' Threads whose name matches the regular expression

Parameters:: expReg -

interruptInitThread
```
@Command(description="sends an interrupt to the initialization thread",
         type=ABORT)
public void interruptInitThread()
```
sends an interrupt to the initialisation thread. Could be useful to unstuck a hardware blocked during checkHardware operations

ping

@Command(description="broadcast on the status bus a message of presence",
         type=QUERY,
         category=SYSTEM)
public void ping()

broadcast on the status bus a message of presence

getAgentPresenceManager

public AgentPresenceManager getAgentPresenceManager()

Class Subsystem

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

innerState

initializing

closing

commandGroup

ancillaryGroup

actionMonitor

commandMonitor

waitingForCommandTermination

signalsMonitor

initThread

forceShutdown

log

fac

commandBusSelector

statusBusSelector

inTestContext

startInEngineeringMode

configurationProxy

logBusHandler

commandBuilder

statusBroadcasterThread

statusBroadcasterLock

locks

currentSubsystem

LOCAL_EXECUTION_INFO

Constructor Detail

Subsystem

Subsystem

Method Detail

createState

getSoftwareRevision

getMessagingAccess

getInnerState

isInEngineeringMode

isMaster

isSlave

getEthHardAddress

getLogger

getCurrentActionThread

getAncillaryGroup

setListenToStatus

isListenToStatus

isInTestContext

isStartedInEngineeringMode

setName

initLogBusHandler

getName

getConfiguration

getTag

getConfigurationProxy

setConfigurationProxy

getDefaultSelector

getStatusBusSelector

setStatusBusSelector

getCommandBusSelector

setCommandBusSelector

start

initialisationEndPhase

stayAlive

completeInitialization

doStart

postStart

checkHardware

checkAllHardwareStarted

checkAllHardwareStopped

getStatus

fillStatus

setStatusBroadcastPeriod

getStatusBroadcastPeriod

stopStatusBroadcasting

startStatusBroadcasting

broadcastStatus

broadcastStatus