All Classes and Interfaces
Class
Description
Base class to facilitate implementing
Dispatcher.Handle of a task executed by
Dispatcher.Minimal component able to communicate on the buses.
An alert standing for CCS version incompatibilities detected on the buses.
An
AlertListener to handle the Agent Alert State.A service to manage the Command Dictionary of a given agent.
An event fired to
AgentCommandDictionaryListeners when an agent
command dictionary has changed.EventType enumeration describing the nature of the dictionary change.
A Listener to receive notifications of CommandDictionary changes.
A class wrapper class of a DictionaryCommand for an Agent.
Service for executing asynchronous tasks.
Implemented by classes that provide custom handling for uncaught exceptions thrown by
AgentExecutionService tasks.A Service to manage the HeartBeat for CCS Agents.
A class to encapsulate an agent's name and type.
Enumeration of known agent types.
Class that allows the serialization of the AgentLockInfo
We use the PersistenceService to make sure the locks are stored at any given
time.
Interface for being notified of lock update events.
Static utility methods for handling user settings.
Commands for agent lock service.
A Service to register MBeans for CCS Agents.
This interface provides messaging methods for a component (eg an agent) to be
able to communicate on the buses.
MBean to interact with the messaging layer.
An Interface to be implemented by all nodes that provide an insight in the
Agent's health and safety.
An Agent Service to monitor the status of the agent.
The MBean Interface for AgentMonitor to be registered with the JMX
AgentMonitorMBeanService.
An Agent managed PeriodicTask is a centrally managed periodic task that
will execute a Runnable.
A service to schedule periodic tasks.
Agents that implement this interface are notified when an agent is connecting
or has disconnected on the status bus
Tracks agent connection and disconnection on the buses.
A Service to add Properties CCS Agents.
A Predicate used to select agents based on the provided properties.
Interface to be implemented by any agent service.
An AgentService to add Signal handling to an Agent.
Marker interface to distinguish internal states of an
Agent.An AgentService to manage the internal state of an Agent.
A AgentStatusAggregatorService listens to the status bus and keeps track in
memory of selected status data.
Internal class, unmutable data structure with min, max, average and
stddev.
Internal class, unmutable data structure with name, timestamp and value.
An Agent Service to handle information related to the distribution.
Implements alarms.
While trying to return the subsystem to normal mode it appears that alarms have not been cleared.
Base class for all Alerts.
An interface to listen to Alert acknowledgments
An event fired by
AlertService to notify listeners of raised or cleared alerts.Enumeration of alert event types.
Raises an alert or logs a message when the input crosses thresholds, taking care
not to do so too often for the same reason.
Marker interface for Alert handlers
Interface to be implemented by listeners interested in
AlertEvents.Deprecated.
Agent AlertService.
The Alert State of an Agent reflects how the hardware measured quantities
compare to their operational limits.
A collection of static utilities linked to boot operations.
An exception occurring during the setting step of a bulk change.
An exception occurring during the validation step of a bulk change.
Enumeration of CCS Buses.
Calls a BusMessagingLayer and adds all that is necessary to handle messages
following application layer concerns.
Base class for messages sent on the buses.
A BusMessageForwarder receives a BusMessage from the transport layer
and passes it to registered MessageListener.
Interface to be implemented by Agent Services that wish to modify the
content of an incoming BusMessage.
Interface defining the access to the Transport Layer of Buses
An extension of DerivedChannel that supports basic operations among Channels.
A Class to chain together SingleCategoryTagData entries for a given category.
Class that describes a category tag, i.e.
Handles a category of parameters.
Main scripting entry point to CCS.
Address that contains integer rank.CCS specific GroovyComponentBuilder class.
Custom JGroups membership policy for CCS.
A class to restart a CCS Subsystem
Deprecated.
This class no longer needs to be in the buses package since it's no longer published.
Handles a monitoring channel.
A Predicate used to select agents based on the channel name.
A utility class to evaluate the checksum of an object.
Builds a Agent out of its class name.
Interface to be implemented by all classes that handle
Alert clearing.Enumeration of codes returned when the canClearAlert method is invoked.
Handler for messaging deserialization errors.
An interface to receive notifications when the cluster membership changes.
A utility class to split clusters.
Command ACK.
The Command executor receives a command and executes it.
This interface defines the behaviour of a class implementing a Command pattern.
A class to make it easier to execute commands while correctly handling ACKS,
NACKS, and exceptions.
Exception thrown if the target of the action method throws an exception.
An interface similar to Runnable but which allows exceptions to be generated and handled.
Superclass for all messages sent on the Command Bus.
Interface to be implemented by listeners that wish to be notified of messages
received on the command bus.
Command NACK.
Originator of a command.
Exception thrown by utility classes to indicate that a command has been
rejected.
Base class for a command reply.
Wrapper class to send a BasicCommand over the Command bus; the BasicCommand is either
provided as an object or created internally from a String representation: e.g.
The result of a CommandRequest.
Agent State with respect to command execution.
Utility class to provide access to the Configuration API for a given
component.
This class helps find component of the subsystem as they are defined in
the description "tree".
Abstract class for a node in the concrete implementation of a subsystem description.
A ComponentNode builder class.
Utility class to synchronously or asynchronously invoke or listen for events
on the buses.
An interface that gives a component more control on how to validate / set a
bulk change of configuration parameters.
DAO interface to configuration data.
A Class containing the current configuration data.
An object that describes an Agent's full configuration.
Encapsulates the logic of setting configurable parameters for a given
component.
Builder for ComponentConfigurationHandler objects.
A set of several ConfigurationHandlers.
A Class containing the Agent's configuration information.
A builder for a {
A Configuration listener interface.
The type of configuration operation that lead to the ConfigurationListener
notification.
A class containing the loaded configuration data.
Fields of a class annotated with this annotation will be tracked down by the
configuration service.
Marks a mutator ("setter") as being part of possible configuration change.
A class meant to process a stack of parameter values, as defined when
loading multiple tags, and return a single parameter value.
A configuration parameter description class.
Represents the state of a given parameter.
A class that matches the value of a configuration parameter with the
SingleCategoryTag from which it originated.
An enumeration that represent the type of a ConfigurationParameter.
Provides the Configuration API to the subsystem it stands for.
Exception standing for issues accessing the configuration service.
The Configuration state of a subsystem reflects the state of its set of
configurable parameters.
A view of the configuration parameters values, ordered by the component they
belong to.
JLine-based command shell.
Implements a control "channel".
A temporary main to convert configuration Limits category to using
warning limits.
Field annotation to define data attributes.
DataProviderDictionary implementation that splits entries by DataProviderInfo.Type, and stores each in its own dictionary.DataProviderDictionary implementation that minimizes memory footprint and serialized size at the expense of access speed.DataProviderDictionary implementation that minimizes memory footprint and serialized size at the expense of access speed.A dictionary of published data.
A service to manage a worker subsystem's dictionary of DataProviders.
An event fired to
DataProviderDictionaryListeners when an agent
data dictionary has changed.EventType enumeration describing the nature of the dictionary change.
A Listener to receive notifications of DataProviderDictionary changes.
A static description of published data.
The DataProviderState of a data provider reflects the current operating conditions of
the provider.
Custom JGroups membership policy for CCS.
A class to be extended by derived channels, i.e.
Handles hardware devices
Enumerated Alerts for Device (monitor package)
A Predicate used to select agents based on the channel name.
Creates a subsystem and dumps dictionary information.
Task dispatcher that connects messaging framework (currently, JGroups) to CCS framework.
Dispatcher event that triggers an alert.An event emitted by
Dispatcher.Interface to be implemented by classes that should be notified of
Dispatcher events.Enumeration of order of execution and capacity control policies.
Enumeration of task execution stages for which statistical data can be reported.
Handle of a runnable task executed by this
Dispatcher.Interface to be implemented by classes that should be notified whenever
any task processed by this
Dispatcher completes a stage.Deprecated.
This class doesn't need to be in the buses package anymore.
Annotation for classes or fields that are not to be trended.
Useful constants for drivers.
Connection type
A dummy lock used for preliminary implementation of the agent lock service.
Utility class to dump command dictionaries for the agents on the buses.
This exception is thrown when an agent tries to connect with a non unique name.
An exception occurring during the deserialization of the serialized embedded
object of a
BusMessage.An object that scans a given object's fields for the annotation of type
T.The GroovyComponentNodeFactory for Groovy.
A Predicate used to select agents based on their group.
Methods annotated with @Guarded will be instrumented by aspectJ and checked
for constraints.
Deprecated.
This exception is only used by doorman and motorplatform subsystems.
Interface to be implemented by a BusMessagingLayer that provides
cluster membership notifications natively.
Interface to be implemented by objects that have their own Command Line
Options so that they can be called back when started with SubsystemBoot.
Interface to be implemented by classes that wish to overwrite the configuration
parameter description as specified by the ConfigurationParameter annotation.
Interface to be implemented by all objects that provide access to one or
more
DataProviderInfos.Interface to implement for components that require to perform tasks at
specific times of the enclosing Subsystem life cycle.
An AgentService to be used by Agents that need to interact with the Rest
Server on the buses.
Infrastructure level Alerts.
JGroups based implementation of
MessagingLayer.Supports running scripts in 3 modes:
By interactively reading scripts from stdin
By executing a script provided as a command line argument
By sending a script to a remote JythonInterpreterConsole
Utilities for executing jython scripts in the CCS environment
Executor that uses
String keys associated with submitted tasks to sequence their execution.Generic Data class for Key-Value pairs.
An object designed to group together KeyValueData objects before publication on the Status bus.
Dispatcher implementation that mimics previously existing system.Implements hardware output lines.
Client side locking service, for a given agent.
Local file based implementation of interface ConfigurationDAO.
A DAO for migrating from local files to remote files.
Interface for finding lock and level for an agent at the AgentMessagingLayer.
A java util log Handler that forwards messages to the Log bus.
Log message to be sent on Log bus.
Interface to be implemented by listeners that wish to be notified of messages
received on the LOG bus.
This field annotation allows to access other components from a given
component that belongs to the component tree.
Defines the tree travel strategy.
Sets the annotated String field to the name of the component that
field belongs to.
Sets the annotated String field to the path of the component that
field belongs to as defined in the groovy file.
A class containing a CCSTimeStamp/double pair representing the timestamp
and the value of a hardware measurement.
Flags to be associated to messages.
Raises an alert or logs a message when the rate of message processing crosses
thresholds on size or number, taking care not to do so too often for the same
reason.
Marker interface to be implemented by bus message listeners.
Entry point for receiving messages from the buses.
Handler for processing received messages.
Interface providing methods to connect/disconnect MessagingAccessLayer objects to/from the CCS buses and to
send messages over the buses.
Manages the creation of the messaging layer implementations.
An AgentService that manages the underlying messaging service.
A temporary utility class for logging messages in the Monitor framework
A Monitoring Task to update a set of channels.
Dispatcher implementation that decouples message processing by CCS from message processing by JGroups.Class describing a muted alert request.
An Service to manage transitions to/from NORMAL mode
The Operational State of an Agent.
An interface for listening to outgoing messages.
Marker Interface for BusMessages that can be received out of order.
Constants for this package.
constants for the package
Deprecated.
Fields annotated by this annotation have their value persisted in a local
file.
This objects is responsible for keeping track of fields annotated with
Persist and to write them into a
local file at subsystem shutdown or at regular time intervals.The Phase State Diagram reflects the stages of an Agent's life cycle, from when it
starts to when it shuts down.
a PrintWriter dedicated to writing properties files.
Simple JVM freeze detector stub.
JMS Queue session factory
Thread-safe modifiable
RaisedAlertSummary.A history of alerts for a specific alert ID, since the last clear.
This class represents an instance when an Alert was raised.
A summary of the alerts that have been raised by a Subsystem.
An interface representing the object with regards to the parameterized
annotation
TClient side locking service, for a given agent.
A Class to write/fetch dictionaries from the remote file system.
A wrapper class to grant access to a remote FileSystem.
An implementation of the ConfigurationDAQ using the CCS rest file server This
implementation uses the following bootstrap properties
org.lsst.ccs.config.remote.uri -- the file server to connect to.
An enumeration to distinguish between a NORMAL and SIMULATED subsystem.
A Class to capture the Health of the running process.
A Service to provide jmx access to the Agetn's runtime.
An application to scan groovy files to see if they work properly.
An object encapsulating the original BusMessage received on the Status bus
This class defines how a script interacts with a CCS Subsystem.
This exception is returned or thrown when the timeout for synchronous commands
has been reached.
Extension of
HasLifecycle.Conveys a signal to an SignalHandler component.
A component that can receive a Signal.
A list of signals that can be sent to "SignalHandler" components.
While trying to return to normal (ready) mode it appears that some SIGNAL (signal) command is still running.
A class describing a single category tag.
A Class containing data for a single Configuration Category Tag.
Annotation for classes or fields that are not to be encoded.
Contains a set of subsystem states, each represented by
Enum.An internal listener to state changes.
A status message containing an AgentInfo object.
Base class for Alert raising and clearing status.
Status message sent when Alerts are cleared.
StatusMessage dedicated to command dictionary publication.
A StatusMessage for the publication of ConfigurationData.
A status message containing a ConfigurationInfo object.
Base class for all status messages containing data that is meant to be
stored in the trending database.
A status message containing a DataProviderDictionary object.
Status message containing an Enum, encoded as a String..
Heartbeat status message.
Class to send a Lock status update
Class to send a set of lock updates
Base class for all messages sent on the Status Bus.
Interface to be implemented by listeners that wish to be notified of messages
received on the status bus.
Base class for all status messages containing an RaisedAlert.
A Status message containing the current RaisedAlertSummary for the Agent.
A StatusMessage containing a full StateBundle.
A StatusChangeNotification for State changes.
Base class for all status messages containing data that is private
to the sender Subsystem.
The base class for a CCS subsystem.
Base class for reporting subsystem state anomalies.
JGroups tester.
Rate limiter for outgoing messages.
Factory for
BusMessagingLayer instances.Some methods are executed during "treewalking" (that is from parent to children nodes).
A Utility class for navigating the Components Tree Structure.
Exception thrown by the AgentLockService when a level cannot be acquired
on a given subsystem.
Exception thrown by the AgentLockService when a lock cannot be acquired
either because a subsystem is already locked or because the user does not
have the privileges to obtain a lock.
A version of the StateBundle that cannot be modified.
Generic interface for writing, reading and finding properties files against
a pattern.