AlarmSystemContainerServices (ACS-2016.6)

java.lang.Object
- alma.alarmsystem.corbaservice.AlarmSystemContainerServices

All Implemented Interfaces:: ContainerServicesBase

public class AlarmSystemContainerServices
extends java.lang.Object
implements ContainerServicesBase

Constructor Summary

Constructors
Constructor and Description

AlarmSystemContainerServices(AlarmSystemCorbaServer alSysCorbaServer, AcsLogger theLogger)
Constructor

Constructors
Constructor and Description
`AlarmSystemContainerServices(AlarmSystemCorbaServer alSysCorbaServer, AcsLogger theLogger)` Constructor

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<T extends org.omg.PortableServer.Servant & OffShootOperations> OffShoot`	`activateOffShoot(T cbServant)` Activates a CORBA servant that implements alma.ACS.OffShoot.
`<T> AcsEventPublisher<T>`	`createNotificationChannelPublisher(java.lang.String channelName, java.lang.Class<T> eventType)` Creates a new `AcsEventPublisher` object for a given channel.
`<T> AcsEventPublisher<T>`	`createNotificationChannelPublisher(java.lang.String channelName, java.lang.String channelNotifyServiceDomainName, java.lang.Class<T> eventType)` Similar to `ContainerServicesBase.createNotificationChannelPublisher(String, Class)`, but with additional NC domain specification.
`<T> AcsEventSubscriber<T>`	`createNotificationChannelSubscriber(java.lang.String channelName, java.lang.Class<T> eventType)` Creates a new `AcsEventSubscriber` object, which is the abstraction of a Notification Channel subscriber (consumer), for the given channel name.
`<T> AcsEventSubscriber<T>`	`createNotificationChannelSubscriber(java.lang.String channelName, java.lang.String channelNotifyServiceDomainName, java.lang.Class<T> eventType)` Creates a new `AcsEventSubscriber` object, which is the abstraction of a Notification Channel subscriber (consumer), for the given channel name and notify service domain name.
`void`	`deactivateOffShoot(java.lang.Object offshootImpl)` Deactivates the offshoot object previously activated through the `#activateOffShoot(Object, Class)` method.
`AdvancedContainerServices`	`getAdvancedContainerServices()` More specialized methods are available from the `AdvancedContainerServices`.
`DAL`	`getCDB()` Convenience method for accessing the Configuration Database.
`AcsLogger`	`getLogger()` Gets a `Logger` object that the component should use for logging.
`java.lang.String`	`getName()` Delivers the unique instance name for the component.
`org.omg.CORBA.ORB`	`getOrb()`
`org.omg.PortableServer.POA`	`getPOAForOffshoots(org.omg.PortableServer.POA componentPOA)`
`java.util.concurrent.ThreadFactory`	`getThreadFactory()` Gets a `ThreadFactory`, to be used as input for other classes from the concurrent library (such as `ThreadPoolExecutor`), or simply to create new `Thread`s.

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

- Constructor Detail
  - AlarmSystemContainerServices
```
public AlarmSystemContainerServices(AlarmSystemCorbaServer alSysCorbaServer,
                                    AcsLogger theLogger)
```
    Constructor
    
    Parameters:
    
    theOrb - The ORB
    
    theLogger - The logger
- Method Detail
  - activateOffShoot
```
public <T extends org.omg.PortableServer.Servant & OffShootOperations> OffShoot activateOffShoot(T cbServant)
                                                                                          throws AcsJContainerServicesEx
```
    Description copied from interface: ContainerServicesBase
    
    Activates a CORBA servant that implements alma.ACS.OffShoot. The purpose of the OffShoot marker interface is to crack down on uncontrolled activation of just any CORBA services by Java components, while allowing this for selected subtypes of OffShoot, like alma.ACS.Callback.
    The OffShoot servant can be either a subclass of the xyzPOA skeleton, or a xyzPOATie instance (delegation model). Since ACS 4.1.2, a tie servant is detected, and interception code gets inserted between the POATie skeleton and the offshoot implementation class. This way, the container can intercept (and log) calls to offshoots in the same way as it does for calls to components. It is therefore recommended to use the tie approach for all offshoot servants, unless there is a reason to avoid container interception.
    Note that since ACS 9.0 we are using generics to express that the offshoot impl object must be both a corba servant and implement OffShootOperations.
    
    Specified by:
    
    activateOffShoot in interface ContainerServicesBase
    
    Parameters:
    
    cbServant - the CORBA-generated servant, e.g. CBdoublePOA; must implement alma.ACS.OffShootOperations.
    
    Returns:
    
    The corba-activated offshoot object, which needs a narrow-cast to the subtype, like CBdouble myCBdouble = alma.ACS.CBdoubleHelper.narrow(...).
    
    Throws:
    
    AcsJContainerServicesEx
  - createNotificationChannelPublisher
```
public <T> AcsEventPublisher<T> createNotificationChannelPublisher(java.lang.String channelName,
                                                                   java.lang.Class<T> eventType)
                                                            throws AcsJContainerServicesEx
```
    Description copied from interface: ContainerServicesBase
    
    Creates a new AcsEventPublisher object for a given channel. It is the abstraction of a Corba Notification Channel supplier, a DDS publisher, or a publisher for some other supported pub/sub technology.
    The user is expected to call AcsEventPublisher.disconnect() when the publisher is no longer needed. To avoid resource problems, the ContainerServices object calls this method during its own deactivation, just in case the user forgot to do so.
    
    Specified by:
    
    createNotificationChannelPublisher in interface ContainerServicesBase
    
    Parameters:
    
    channelName - The Notification Channel name where events will be published.
    
    eventType - The type of event that can be sent using the AcsEventPublisher, e.g. "MySchedulingEvent.class". Specifying the type offers additional compile time checking. It should generally be used unless more than one event type must be sent through this publisher, in which case you can specify a common base type (e.g. "IDLEntity" in case of different IDL-generated structs), or just "Object" for total type freedom (though the underlying pub-sub framework may later throw runtime exceptions if unsupported event types get used).
    
    Returns:
    
    a Notification Channel publisher, that will get automatically stopped and disconnected when the component is unloaded, or the client disconnected, depending on the case, if the user doesn't do so.
    
    Throws:
    
    AcsJContainerServicesEx - if anything goes wrong while creating the publisher
  - createNotificationChannelPublisher
```
public <T> AcsEventPublisher<T> createNotificationChannelPublisher(java.lang.String channelName,
                                                                   java.lang.String channelNotifyServiceDomainName,
                                                                   java.lang.Class<T> eventType)
                                                            throws AcsJContainerServicesEx
```
    Description copied from interface: ContainerServicesBase
    Similar to ContainerServicesBase.createNotificationChannelPublisher(String, Class), but with additional NC domain specification.
    Details of this NC domain concept:
    - All publishers and subscribers that access an NC must consistently use the same NC domain name.
    - The CDB may specify a mapping of NC domain to a notify service, which then decides where the NC is hosted.
    - Specifying the NC domain through the API as opposed to doing it in the NC's CDB description allows mapping of "dynamic" NCs to notify services, whose names are not known at deployment time. This may be the case for NCs created by 3rd party software such as the alarm system.
    Specified by:
    
    createNotificationChannelPublisher in interface ContainerServicesBase
    
    channelNotifyServiceDomainName - The Notification Channel Service Domain name.
    
    Throws:
    
    AcsJContainerServicesEx
    
    See Also:
    
    #createNotificationChannelSubscriber(String, String)
  - createNotificationChannelSubscriber
```
public <T> AcsEventSubscriber<T> createNotificationChannelSubscriber(java.lang.String channelName,
                                                                     java.lang.Class<T> eventType)
                                                              throws AcsJContainerServicesEx
```
    Description copied from interface: ContainerServicesBase
    
    Creates a new AcsEventSubscriber object, which is the abstraction of a Notification Channel subscriber (consumer), for the given channel name. The created subscriber will be automatically disconnected when the component or client that created it through this method is finished, in case the user doesn't explicitly do it before.
    
    Specified by:
    
    createNotificationChannelSubscriber in interface ContainerServicesBase
    
    Parameters:
    
    channelName - The Notification Channel name to listen to
    
    eventType - The type of event that can be sent using the AcsEventSubscriber, e.g. "MySchedulingEvent.class". The specific event type should be used unless more than one event types must be received by this subscriber, in which case you can specify a common base type (e.g. "IDLEntity.class" in case of different IDL-generated structs), or just "Object" for total type freedom (though the underlying pub-sub framework may later throw runtime exceptions if unsupported event types are received).
    
    Returns:
    
    a Notification Channel subscriber, to which the user can attach one or more handlers for each data type, and that will be automatically disconnected if the user doesn't do so.
    
    Throws:
    
    AcsJContainerServicesEx - if anything goes wrong while creating the subscriber
  - createNotificationChannelSubscriber
```
public <T> AcsEventSubscriber<T> createNotificationChannelSubscriber(java.lang.String channelName,
                                                                     java.lang.String channelNotifyServiceDomainName,
                                                                     java.lang.Class<T> eventType)
                                                              throws AcsJContainerServicesEx
```
    Description copied from interface: ContainerServicesBase
    Creates a new AcsEventSubscriber object, which is the abstraction of a Notification Channel subscriber (consumer), for the given channel name and notify service domain name. The created subscriber will be automatically disconnected when the component or client that created it through this method is finished, in case the user doesn't explicitly do it before.
    Details of the NC domain concept:
    - All publishers and subscribers that access an NC must consistently use the same NC domain name.
    - The CDB may specify a mapping of NC domain to a notify service, which then decides where the NC is hosted.
    - Specifying the NC domain through the API as opposed to doing it in the NC's CDB description allows mapping of "dynamic" NCs to notify services, whose names are not known at deployment time. This may be the case for NCs created by 3rd party software such as the alarm system.
    Specified by:
    
    createNotificationChannelSubscriber in interface ContainerServicesBase
    
    Parameters:
    
    channelName - The Notification Channel name to listen to
    
    channelNotifyServiceDomainName - The Notification Channel Service Domain name.
    
    eventType - See ContainerServicesBase.createNotificationChannelPublisher(String, Class).
    
    Returns:
    
    a Notification Channel subscriber, to which the user can attach one or more handlers for each data type, and that will be automatically disconnected if the user doesn't do so.
    
    Throws:
    
    AcsJContainerServicesEx - if anything goes wrong while creating the subscriber
  - getPOAForOffshoots
```
public org.omg.PortableServer.POA getPOAForOffshoots(org.omg.PortableServer.POA componentPOA)
                                              throws AcsJContainerEx,
                                                     AcsJUnexpectedExceptionEx
```
    Throws:
    
    AcsJContainerEx
    
    AcsJUnexpectedExceptionEx
  - getAdvancedContainerServices
```
public AdvancedContainerServices getAdvancedContainerServices()
```
    Description copied from interface: ContainerServicesBase
    
    More specialized methods are available from the AdvancedContainerServices.
    
    Specified by:
    
    getAdvancedContainerServices in interface ContainerServicesBase
  - getLogger
```
public AcsLogger getLogger()
```
    Description copied from interface: ContainerServicesBase
    
    Gets a Logger object that the component should use for logging.
    The Logger will be set up with a namespace specific to the component that uses this ContainerServices instance.
    Specific logger extensions that only apply to certain subsystems can be used by wrapping this logger with a class such as AntennaContextLogger.
    
    Specified by:
    
    getLogger in interface ContainerServicesBase
    
    Returns:
    
    Logger
  - getName
```
public java.lang.String getName()
```
    Description copied from interface: ContainerServicesBase
    
    Delivers the unique instance name for the component. The name must have been specified at deployment time in the CDB (for static components like the famous "LAMP1" example), or must have been given to the manager at runtime by the client who creates a dynamic component (or was invented by the manager if none was given).
    
    Specified by:
    
    getName in interface ContainerServicesBase
    
    Returns:
    
    the unique component instance name
  - getThreadFactory
```
public java.util.concurrent.ThreadFactory getThreadFactory()
```
    Description copied from interface: ContainerServicesBase
    Gets a ThreadFactory, to be used as input for other classes from the concurrent library (such as ThreadPoolExecutor), or simply to create new Threads.
    All user-created threads should come from the factory returned here, so "new Thread(...)" should not appear anywhere in component code.
    The returned thread factory creates new threads configured to run well in the container environment, e.g.
    - all threads are daeemon threads so that they can't interfere with container shutdown.
    - the priority is the same as that of the calling component thread (which is created by the ORB)
    - uncaught user exceptions are logged as WARNING before the thread terminates.
    - when a component is removed from the container, surviving user threads created by that component are killed using Thread.stop() (which even though deprecated, seems like the perfect choice in this particular situation). Otherwise a faulty components could permanently take away resources from a running container and from the other components.
    Specified by:
    
    getThreadFactory in interface ContainerServicesBase
    
    Returns:
    
    the thread factory to be used by the component to create new threads.
  - getCDB
```
public DAL getCDB()
           throws AcsJContainerServicesEx
```
    Description copied from interface: ContainerServicesBase
    
    Convenience method for accessing the Configuration Database.
    Currently more than a convenience, given that the CDB is not yet a Java component, but a separate service...
    
    Specified by:
    
    getCDB in interface ContainerServicesBase
    
    Returns:
    
    the CDB interface
    
    Throws:
    
    AcsJContainerServicesEx
  - getOrb
```
public org.omg.CORBA.ORB getOrb()
```
    Returns:
    
    The Orb
  - deactivateOffShoot
```
public void deactivateOffShoot(java.lang.Object offshootImpl)
                        throws AcsJContainerServicesEx
```
    Description copied from interface: ContainerServicesBase
    
    Deactivates the offshoot object previously activated through the #activateOffShoot(Object, Class) method. Caution: this method returns immediately, while the underlying POAOperations.deactivate_object(byte[]) still works on the deactivation. If ContainerServicesBase.activateOffShoot(Servant) is called too shortly after deactivation, an exception will be thrown. TODO: find a remedy
    
    Specified by:
    
    deactivateOffShoot in interface ContainerServicesBase
    
    Parameters:
    
    offshootImpl - the offshoot object implementation
    
    Throws:
    
    AcsJContainerServicesEx - if something goes wrong, e.g., if the corresponding offshoot servant was not active.

Class AlarmSystemContainerServices

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

AlarmSystemContainerServices

Method Detail

activateOffShoot

createNotificationChannelPublisher

createNotificationChannelPublisher

createNotificationChannelSubscriber

createNotificationChannelSubscriber

getPOAForOffshoots

getAdvancedContainerServices

getLogger

getName

getThreadFactory

getCDB

getOrb

deactivateOffShoot