org.lsst.ccs.framework

Class Module

java.lang.Object

java.util.Observable

org.lsst.ccs.framework.Module

All Implemented Interfaces:

Observer, Configurable, SignalHandler

Direct Known Subclasses:

ConfigurationServerModule

public class Module
extends Observable
implements Observer, Configurable, SignalHandler

Building block for a ModularSubsystem. These are Configurable with additional facilities:

• Observable features
• a Timer to publish data at regular intervals
• SignalHandler capabilities (and corresponding commands)
• specific commands

Author:

aubourg

notes: module driver, sends to functionnal modules such as calibration iquestion: how are the module sindependants have a look at sampler ....

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
class	Module.ValueUpdate

Nested classes/interfaces inherited from interface org.lsst.ccs.framework.Configurable

Configurable.Environment

Field Summary

Fields

Modifier and Type	Field and Description
protected Configurable.Environment	environment
protected String	name
protected int	nObserverThreads
protected int	tickMillis

Constructor Summary

Constructors

Constructor and Description
Module()
Module(int tickMillis)
Module(String name)
Module(String name, int tickMillis)

Method Summary

Modifier and Type	Method and Description
TreeBranch<String>	getComponentTree() publishes a tree of subcomponents' names.
Configurable.Environment	getEnvironment()
String	getName()
int	getNObserverThreads()
List<Observable>	getObservables()
Subsystem	getSubsystem()
int	getTickMillis()
void	init() This method is called from the enclosing subsystem constructor.
void	initModule() To be overriden by individual modules.
void	listens(Observable... observs)
void	postStart() once all hardware components have been started this method is invoked.
void	processUpdate(Observable source, Module.ValueUpdate update) This method should be overriden to handle change to properties of watched modules
void	sendSignal(String signalString) command to send a signal.
void	sendSignalWithTimeLimit(String signalString, long expectedMaxDelay) command to send a signal with a delay for execution.
void	setEnvironment(Configurable.Environment environment) sets the current Environment Object for the Component.
void	setName(String name) Sets the module name.
void	setNObserverThreads(int observerThreads)
void	setObservables(List<Observable> l)
void	setTickMillis(int tickMillis) Changes the periodic wake up time.
void	shutdownNow() added for tying to unstuck ExcecutorService
TreeWalkerDiag	signal(Signal sig) this method is intended for overriding: the module receives an out of band signal.
void	startTicking() Deprecated. Does this really have to be public?
void	tick()
void	update(Observable o, Object arg) Synchronous update.

Methods inherited from class java.util.Observable

addObserver, clearChanged, countObservers, deleteObserver, deleteObservers, hasChanged, notifyObservers, notifyObservers, setChanged

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.framework.Configurable

change, dropSubmittedChanges, getCheckedValueFromConfiguration, getChildren, getComponentByName, getParent, getParentObject, getSubmittedChanges, isParameterConfigurable, notifyChange, notifyChangeWithoutPreliminaryChecks, printConfigurableParameters, setBulkParameter, start, submitChange, submitChanges, validateBulkChange

Field Detail

environment

protected Configurable.Environment environment

name

protected String name

nObserverThreads

protected int nObserverThreads

tickMillis

@ConfigurationParameter
protected int tickMillis

Constructor Detail

Module

public Module()

Module

public Module(int tickMillis)

Module

public Module(String name,
              int tickMillis)

Module

public Module(String name)

Method Detail

getName

public String getName()

Specified by:

getName in interface Configurable

Returns:

the module name

setName

public void setName(String name)

Sets the module name. Called upon module assembly from xml description file. The module name should be unique within a ModularSubsystem

Parameters:

name -

getEnvironment

public Configurable.Environment getEnvironment()

Specified by:

getEnvironment in interface Configurable

Returns:

the "virtual field" Environment.

setEnvironment

public void setEnvironment(Configurable.Environment environment)

Description copied from interface: Configurable

sets the current Environment Object for the Component. this method should be called once by the Subsystem initialization process just after the Component constructor has been called (a "PostConstruct" method).

Specified by:

setEnvironment in interface Configurable

setObservables

public void setObservables(List<Observable> l)

listens

public void listens(Observable... observs)

getObservables

public List<Observable> getObservables()

setTickMillis

@ConfigurationParameterChanger(propertyName="tickMillis")
public void setTickMillis(int tickMillis)

Changes the periodic wake up time. The tick method will be called every tickMillis ms.

if called before startup this method just fix the tick frequency (the module wil later "tick" at this rate) .

if called after startup then will change the ticking rate
in that case the ticking will change but new rate will be effective after a delay of "old rate"

Parameters:

tickMillis -

getTickMillis

public int getTickMillis()

setNObserverThreads

public void setNObserverThreads(int observerThreads)

getNObserverThreads

public int getNObserverThreads()

init

public final void init()

Description copied from interface: Configurable

This method is called from the enclosing subsystem constructor. if overriden it is highly recommended to invoke super.init().
the actual code performs resource injection: all fields declared in the current class and annotated as Resource are queried from the Environment and their reference initialize the field.

Specified by:

init in interface Configurable

initModule

public void initModule()

To be overriden by individual modules. Called after all parameters have been set from XML file.

getSubsystem

public Subsystem getSubsystem()

Specified by:

getSubsystem in interface Configurable

Returns:

the current Subsystem in which this object is deployed

postStart

public void postStart()
               throws HardwareException

Description copied from interface: Configurable

once all hardware components have been started this method is invoked. it notifies all component that now the subsystem is going to end initialization phase that could be the place to start ticks (module) or to "home" hardwares (that's the reason why this method throws a HardwareException)

Specified by:

postStart in interface Configurable

Throws:

HardwareException

startTicking

@Deprecated
public void startTicking()

Deprecated. Does this really have to be public?

If there is a scheduled wake up (that is if the tickMillis is more than zero) then the ticking starts. This method is called on every module after the subsystem is itself ready to listen to commands.

update

public void update(Observable o,
                   Object arg)

Synchronous update. Do not override, override processUpdate. Should we make it final?

Specified by:

update in interface Observer

processUpdate

public void processUpdate(Observable source,
                          Module.ValueUpdate update)

This method should be overriden to handle change to properties of watched modules

Parameters:

source - the module

update - the update message, containing property name and new value

tick

public void tick()

shutdownNow

public void shutdownNow()

added for tying to unstuck ExcecutorService

Specified by:

shutdownNow in interface Configurable

signal

public TreeWalkerDiag signal(Signal sig)

this method is intended for overriding: the module receives an out of band signal. Beware this code is executed in a different thread (take care of threading issued when overriding)

Specified by:

signal in interface SignalHandler

Parameters:

sig -

Returns:

one of the TreeWalkerDiag options to tell the subsystem to continue to call this on child components or not.

sendSignal

@Command(description="will propagate signal to Module and its children ",
         type=SIGNAL)
public void sendSignal(String signalString)

command to send a signal.

Parameters:

signalString - string representing a member of an enum of type SignalLevel

sendSignalWithTimeLimit

@Command(description="will propagate signal to Module and its children with  an expected maximum delay",
         type=SIGNAL)
public void sendSignalWithTimeLimit(String signalString,
                                                                                                                                                                   long expectedMaxDelay)

command to send a signal with a delay for execution.

Parameters:

signalString - string representing a member of an enum of type SignalLevel

expectedMaxDelay -

getComponentTree

@Command(description="publishes a tree of component names",
         type=QUERY,
         category=SYSTEM)
public TreeBranch<String> getComponentTree()

publishes a tree of subcomponents' names. REVIEW : should this be a command of the NodeModularSubsystem instead ?

Returns: