Coordinate publishing and receiving events. More...

#include <EventSystem.h>

Public Member Functions
	EventSystem ()
	EventSystem object. This object allows creation of the system's event transmitters and receivers, which can be specified at the beginning, and later used by specifying the topic to receive from or send on. More...

	~EventSystem ()
	destructor More...

void	createTransmitter (const pexPolicy::Policy &policy)
	create an EventTransmitter to send messages to the message broker More...

void	createTransmitter (const std::string &hostName, const std::string &topicName, int hostPort=EventBroker::DEFAULTHOSTPORT)
	create an EventTransmitter to send messages to the message broker More...

void	createReceiver (const pexPolicy::Policy &policy)
	create an EventReceiver to receive messages from the message broker More...

void	createReceiver (const std::string &hostName, const std::string &topicName, int hostPort=EventBroker::DEFAULTHOSTPORT)
	create an EventReceiver which will receive message More...

void	createReceiver (const std::string &hostName, const std::string &topicName, const std::string &selector, int hostPort=EventBroker::DEFAULTHOSTPORT)
	create an EventReceiver which will receive message More...

void	publishEvent (const std::string &topicName, Event &event)
	send an event on a topic More...

Event *	receiveEvent (const std::string &topicName)
	blocking receive for events. Waits until an event is received for the topic specified in the constructor More...

Event *	receiveEvent (const std::string &topicName, const long timeout)
	blocking receive for events, with timeout (in milliseconds). Waits until an event is received for the topic specified in the constructor, or until the timeout expires. More...

int64_t	createOriginatorId ()

int	extractIPId (int64_t identificationId)
	extract the 32-bit IPId embedded in this identificationId. This is the integer representation of the IPV4 network address of the host associated with this identificationId More...

int	extractProcessId (int64_t identificationId)
	extract the 17-bit processId embedded in this identificationId More...

short	extractLocalId (int64_t identificationId)
	extract the 15-bit localId embedded in this identificationId More...

StatusEvent *	castToStatusEvent (Event *event)

CommandEvent *	castToCommandEvent (Event *event)

Static Public Member Functions
static EventSystem &	getDefaultEventSystem ()
	return the default EventSystem object, which can access all previously created Transmitters and receivers More...

Protected Attributes
list< boost::shared_ptr < EventTransmitter > >	_transmitters

list< boost::shared_ptr < EventReceiver > >	_receivers

Static Protected Attributes
static EventSystem *	defaultEventSystem = 0

static short	_localId = 0

static int	_IPId = 0

Private Member Functions
boost::shared_ptr < EventTransmitter >	getTransmitter (const std::string &name)

boost::shared_ptr< EventReceiver >	getReceiver (const std::string &name)

Detailed Description

Coordinate publishing and receiving events.

Definition at line 65 of file EventSystem.h.

Constructor & Destructor Documentation

lsst.ctrl.events::EventSystem::EventSystem ( )

EventSystem object. This object allows creation of the system's event transmitters and receivers, which can be specified at the beginning, and later used by specifying the topic to receive from or send on.

Definition at line 67 of file EventSystem.cc.

                          {
     EventLibrary().initializeLibrary();
 }

lsst.ctrl.events::EventSystem::~EventSystem ( )

destructor

Definition at line 73 of file EventSystem.cc.

73 {

74 }

Member Function Documentation

CommandEvent * lsst.ctrl.events::EventSystem::castToCommandEvent ( Event * event )

Definition at line 283 of file EventSystem.cc.

                                                           {
     return (CommandEvent *)event;
 }

StatusEvent * lsst.ctrl.events::EventSystem::castToStatusEvent ( Event * event )

Definition at line 279 of file EventSystem.cc.

                                                         {
     return (StatusEvent *)event;
 }

int64_t lsst.ctrl.events::EventSystem::createOriginatorId ( )

Definition at line 244 of file EventSystem.cc.

                                         {
     int64_t pid = getpid();
     
     int64_t originatorId = _IPId & 0x0FFFFFFFF;
     int64_t locid = _localId & 0x7FFF;
 
     originatorId = (locid << 49) | (pid << 32) | originatorId;
 
     _localId++;
     return originatorId;
 }

void lsst.ctrl.events::EventSystem::createReceiver ( const pexPolicy::Policy & policy )

create an EventReceiver to receive messages from the message broker

Parameters

policy the Policy object to use to configure the EventReceiver

Definition at line 143 of file EventSystem.cc.

                                                               {
     boost::shared_ptr<EventReceiver> receiver(new EventReceiver(policy));
     boost::shared_ptr<EventReceiver> receiver2;
     if ((receiver2 = getReceiver(receiver->getTopicName())) == 0) {
         _receivers.push_back(receiver);
         return;
     }
     throw LSST_EXCEPT(pexExceptions::RuntimeError, "topic " + receiver->getTopicName() + " is already registered with EventSystem");
 }

void lsst.ctrl.events::EventSystem::createReceiver	(	const std::string &	hostName,
		const std::string &	topicName,
		int	hostPort = `EventBroker::DEFAULTHOSTPORT`
	)

create an EventReceiver which will receive message

Parameters

hostName	the location of the message broker to use
topicName	the topic to receive messages from
hostPort	the port where the broker can be reached

Definition at line 158 of file EventSystem.cc.

                                                                                                     {
     boost::shared_ptr<EventReceiver> receiver;
     if ((receiver = getReceiver(topicName)) == 0) {
         boost::shared_ptr<EventReceiver> receiver(new EventReceiver(hostName, topicName, hostPort));
         _receivers.push_back(receiver);
         return;
     }
     throw LSST_EXCEPT(pexExceptions::RuntimeError, "topic "+ topicName + " is already registered with EventSystem");
 }

void lsst.ctrl.events::EventSystem::createReceiver	(	const std::string &	hostName,
		const std::string &	topicName,
		const std::string &	selector,
		int	hostPort = `EventBroker::DEFAULTHOSTPORT`
	)

create an EventReceiver which will receive message

Parameters

hostName	the location of the message broker to use
topicName	the topic to receive messages from
selector	the message selector to specify which messages to receive
hostPort	the port where the broker can be reached

Definition at line 174 of file EventSystem.cc.

                                                                                                                                {
     boost::shared_ptr<EventReceiver> receiver(new EventReceiver(hostName, topicName, selector, hostPort));
     _receivers.push_back(receiver);
 }

void lsst.ctrl.events::EventSystem::createTransmitter ( const pexPolicy::Policy & policy )

create an EventTransmitter to send messages to the message broker

Parameters

policy the Policy object to use to configure the EventTransmitter

Definition at line 115 of file EventSystem.cc.

                                                                  {
     boost::shared_ptr<EventTransmitter> transmitter(new EventTransmitter(policy));
     boost::shared_ptr<EventTransmitter> transmitter2;
     if ((transmitter2 = getTransmitter(transmitter->getTopicName())) == 0) {
         _transmitters.push_back(transmitter);
         return;
     }
     throw LSST_EXCEPT(pexExceptions::RuntimeError, "topic "+ transmitter->getTopicName() + " is already registered with EventSystem");
 }

void lsst.ctrl.events::EventSystem::createTransmitter	(	const std::string &	hostName,
		const std::string &	topicName,
		int	hostPort = `EventBroker::DEFAULTHOSTPORT`
	)

create an EventTransmitter to send messages to the message broker

Parameters

hostName	the location of the message broker to use
topicName	the topic to transmit events to
hostPort	the port where the broker can be reached

Definition at line 130 of file EventSystem.cc.

                                                                                                        {
     boost::shared_ptr<EventTransmitter> transmitter;
     if ((transmitter = getTransmitter(topicName)) == 0) {
         boost::shared_ptr<EventTransmitter> transmitter(new EventTransmitter(hostName, topicName, hostPort));
         _transmitters.push_back(transmitter);
         return;
     }
     throw LSST_EXCEPT(pexExceptions::RuntimeError, "topic "+ topicName + " is already registered with EventSystem");
 }

int lsst.ctrl.events::EventSystem::extractIPId ( int64_t identificationId )

extract the 32-bit IPId embedded in this identificationId. This is the integer representation of the IPV4 network address of the host associated with this identificationId

Returns: the 32-bit IPId

Definition at line 261 of file EventSystem.cc.

                                                      {
     return identificationId & 0xFFFFFFFF;
 }

short lsst.ctrl.events::EventSystem::extractLocalId ( int64_t identificationId )

extract the 15-bit localId embedded in this identificationId

Returns: the 15-bit localId

Definition at line 275 of file EventSystem.cc.

                                                           {
     return (identificationId & 0xFFFE000000000000LL) >> 49;
 }

int lsst.ctrl.events::EventSystem::extractProcessId ( int64_t identificationId )

extract the 17-bit processId embedded in this identificationId

Returns: the 17-bit processId

Definition at line 268 of file EventSystem.cc.

                                                           {
     return (identificationId & 0x1FFFF00000000LL) >> 32;
 }

EventSystem & lsst.ctrl.events::EventSystem::getDefaultEventSystem ( )

static

return the default EventSystem object, which can access all previously created Transmitters and receivers

Returns: The EventSystem object

Definition at line 80 of file EventSystem.cc.

                                                 {
     if (defaultEventSystem == 0) {
 
         // create the _IPId here, rather than
         // reconstructing it every time we create an
         // identificationId
 
         char buf [255];
         struct hostent *ent;
         unsigned char a,b,c,d;
 
         gethostname(buf, 255) ;
         ent = (struct hostent *)gethostbyname(buf) ;
 
         a = ent->h_addr_list[0][0] & 0xFF;
         b = ent->h_addr_list[0][1] & 0xFF;
         c = ent->h_addr_list[0][2] & 0xFF;
         d = ent->h_addr_list[0][3] & 0xFF;
 
         _IPId = (a << 24) | (b << 16) | (c << 8) | d;
   
         // create the default EventSystem object
         defaultEventSystem = new EventSystem();
     }
     return *defaultEventSystem;
 
 }

boost::shared_ptr< EventReceiver > lsst.ctrl.events::EventSystem::getReceiver ( const std::string & name )

private

private method used to retrieve the named EventReceiver object

Definition at line 235 of file EventSystem.cc.

                                                                              {
     list<boost::shared_ptr<EventReceiver> >::iterator i;
     for (i = _receivers.begin(); i != _receivers.end(); i++) {
         if ((*i)->getTopicName() == name)
             return *i;
     }
     return boost::shared_ptr<EventReceiver>();
 }

boost::shared_ptr< EventTransmitter > lsst.ctrl.events::EventSystem::getTransmitter ( const std::string & name )

private

private method to retrieve a transmitter from the internal list

Definition at line 196 of file EventSystem.cc.

                                                                                    {
     list<boost::shared_ptr<EventTransmitter> >::iterator i;
     for (i = _transmitters.begin(); i != _transmitters.end(); i++) {
         if ((*i)->getTopicName() == name)
             return *i;
     }
     return boost::shared_ptr<EventTransmitter>();
 }

void lsst.ctrl.events::EventSystem::publishEvent	(	const std::string &	topicName,
		Event &	event
	)

send an event on a topic

Parameters

topicName	the topic to send messages to
event	the Event to send

Exceptions

Runtime exception if the topic wasn't already registered using the createTransmitter method

Definition at line 186 of file EventSystem.cc.

                                                                        {
     boost::shared_ptr<EventTransmitter> transmitter;
     if ((transmitter = getTransmitter(topicName)) == 0) {
         throw LSST_EXCEPT(pexExceptions::RuntimeError, "topic "+ topicName + " is not registered with EventSystem");
     }
     transmitter->publishEvent(event);
 }

Event * lsst.ctrl.events::EventSystem::receiveEvent ( const std::string & topicName )

blocking receive for events. Waits until an event is received for the topic specified in the constructor

Parameters

topicName the topic to listen on

Returns: a PropertySet::Ptr object

Definition at line 211 of file EventSystem.cc.

                                                            {
     return receiveEvent(topicName, EventReceiver::infiniteTimeout);
 }

Event * lsst.ctrl.events::EventSystem::receiveEvent	(	const std::string &	topicName,
		const long	timeout
	)

blocking receive for events, with timeout (in milliseconds). Waits until an event is received for the topic specified in the constructor, or until the timeout expires.

Parameters

topicName	the topic to listen on
timeout	the time in milliseconds to wait before returning

Returns: a Property::Ptr object on success, 0 on failure see note in receive()

Definition at line 223 of file EventSystem.cc.

                                                                                {
     boost::shared_ptr<EventReceiver> receiver;
     if ((receiver = getReceiver(topicName)) == 0) {
         throw LSST_EXCEPT(pexExceptions::RuntimeError, "Topic "+ topicName +" is not registered with EventSystem");
     }
 
     return receiver->receiveEvent(timeout);
 }

Member Data Documentation

int lsst.ctrl.events::EventSystem::_IPId = 0

staticprotected

Definition at line 103 of file EventSystem.h.

short lsst.ctrl.events::EventSystem::_localId = 0

staticprotected

Definition at line 102 of file EventSystem.h.

list<boost::shared_ptr<EventReceiver> > lsst.ctrl.events::EventSystem::_receivers

protected

Definition at line 106 of file EventSystem.h.

list<boost::shared_ptr<EventTransmitter> > lsst.ctrl.events::EventSystem::_transmitters

protected

Definition at line 105 of file EventSystem.h.

EventSystem * lsst.ctrl.events::EventSystem::defaultEventSystem = 0

staticprotected

Definition at line 100 of file EventSystem.h.

The documentation for this class was generated from the following files:

/lsst/home/lsstsw/stack/Linux64/ctrl_events/master-gcf15f11bcc/include/lsst/ctrl/events/EventSystem.h
/lsst/home/lsstsw/stack/Linux64/ctrl_events/master-gcf15f11bcc/src/EventSystem.cc

Public Member Functions

Static Public Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation