lsst.ctrl.events::Event Class Reference

Representation of an LSST Event. More...

#include <Event.h>

Inheritance diagram for lsst.ctrl.events::Event:

Public Member Functions
	Event ()
	Event (const std::string &runid, const PropertySet::Ptr ps)
	Event (const std::string &runid, const PropertySet &ps)
	Event (cms::TextMessage *msg)
virtual	~Event ()
	destructor More...
PropertySet::Ptr	getPropertySet () const
std::string	getPubDate ()
	Get the publication date of this event. More...
long long	getPubTime ()
void	setPubTime (long long t)
long long	getEventTime ()
void	setEventTime (long long nsecs)
void	updateEventTime ()
std::string	getEventDate ()
	Get the creation date of this event. More...
std::string	getHostId ()
std::string	getRunId ()
std::string	getType ()
std::string	getStatus ()
void	setStatus (std::string status)
void	setTopic (std::string topic)
std::string	getTopic ()
vector< std::string >	getFilterablePropertyNames ()
vector< std::string >	getCustomPropertyNames ()
PropertySet::Ptr	getCustomPropertySet () const
virtual void	populateHeader (cms::TextMessage *msg) const
void	marshall (cms::TextMessage *msg)
	ExceptionEvent ()
	ExceptionEvent (const std::string &runid, const LSSTException ex)
	ExceptionEvent (cms::TextMessage *msg)
	~LogEvent ()
void	populateHeader (cms::TextMessage *msg)
std::string	getExceptionType ()
std::string	getStackTrace ()

Static Public Attributes
static const std::string	TYPE = "TYPE"
	Creates Event which contains a PropertySet. More...
static const std::string	EVENTTIME = "EVENTTIME"
static const std::string	HOSTID = "HOSTID"
static const std::string	RUNID = "RUNID"
static const std::string	STATUS = "STATUS"
static const std::string	TOPIC = "TOPIC"
static const std::string	PUBTIME = "PUBTIME"
static const std::string	UNINITIALIZED = "uninitialized"
static const std::string	EXCEPTIONTYPE
static const std::string	STACKTRACE

Protected Member Functions
void	_init ()
void	_constructor (const std::string &runid, const PropertySet &ps)
void	splitString (std::string str, std::string delim, std::vector< std::string > &results)
void	splitTuple (std::string str, std::string delim, std::vector< std::string > &results)

Protected Attributes
PropertySet::Ptr	_psp
set< std::string >	_keywords

Private Member Functions
std::string	marshall (const PropertySet &ps)
PropertySet::Ptr	processTextMessage (cms::TextMessage *textMessage)
PropertySet::Ptr	unmarshall (const std::string &text)
void	_init ()

Detailed Description

Representation of an LSST Event.

Representation of an LSST ExceptionEvent.

Definition at line 67 of file Event.h.

Constructor & Destructor Documentation

lsst.ctrl.events::Event::Event

(

)

Definition at line 90 of file Event.cc.

             {
    _init();
}

lsst.ctrl.events::Event::Event	(	const std::string &	runid,
		const PropertySet::Ptr	ps
	)

Definition at line 145 of file Event.cc.

                                                              {
    _constructor(runId, *psp);
}

lsst.ctrl.events::Event::Event	(	const std::string &	runid,
		const PropertySet &	ps
	)

Definition at line 149 of file Event.cc.

                                                           {
    _constructor(runId, ps);
}

lsst.ctrl.events::Event::Event

(

cms::TextMessage *

msg

)

Definition at line 104 of file Event.cc.

                                {
    _init();

    _psp = processTextMessage(msg);

    _psp->set(TYPE, msg->getStringProperty(TYPE));
    _psp->set(HOSTID, msg->getStringProperty(HOSTID));
    _psp->set(RUNID, msg->getStringProperty(RUNID));
    _psp->set(STATUS, msg->getStringProperty(STATUS));
    _psp->set(TOPIC, msg->getStringProperty(TOPIC));
    _psp->set(EVENTTIME, msg->getLongProperty(EVENTTIME));
    _psp->set(PUBTIME, msg->getLongProperty(PUBTIME));
/*
*/
}

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

virtual

destructor

Definition at line 493 of file Event.cc.

              {
}

lsst.ctrl.events::Event::~LogEvent

(

)

Member Function Documentation

void lsst.ctrl.events::Event::_constructor ( const std::string &  runid, const PropertySet &  ps  )

protected

Definition at line 153 of file Event.cc.

                                                                       {
    long int host_len = sysconf(_SC_HOST_NAME_MAX);

    boost::scoped_array<char> hostname(new char[host_len]);
    //time_t rawtime;

    _init();
    
    _psp = ps.deepCopy();


    // do NOT alter the property set we were given. Make a copy of it,
    // and modify that one.

    /*
    std::string foo = psp->toString();
    std::cout << "foo = " << foo << std::endl;
    */

    if (!_psp->exists(STATUS)) {
        _psp->set(STATUS, "unknown");
    }
    
    if (!_psp->exists(EVENTTIME)) {
        updateEventTime();
    }
   

    if (!_psp->exists(HOSTID)) {
        std::string name;
        gethostname(hostname.get(), host_len);
        name = hostname.get();
        _psp->set(HOSTID, name);
    }

    // _runId is filled in here and is ignored in the passed PropertySet
    _psp->set(RUNID, runId);

    // _type is filled in here and is ignored in the passed PropertySet
    _psp->set(TYPE, EventTypes::EVENT);

    // _topic is filled in on publish and is ignored in the passed PropertySet
    _psp->set(TOPIC, Event::UNINITIALIZED);

    // _pubTime is filled in on publish and is ignored in the passed PropertySet
    _psp->set(PUBTIME, (long long)0);
}

void lsst.ctrl.events::Event::_init ( )

private

void lsst.ctrl.events::Event::_init ( )

protected

Definition at line 94 of file Event.cc.

                  {
    _keywords.insert(TYPE);
    _keywords.insert(EVENTTIME);
    _keywords.insert(HOSTID);
    _keywords.insert(RUNID);
    _keywords.insert(STATUS);
    _keywords.insert(TOPIC);
    _keywords.insert(PUBTIME);
}

lsst.ctrl.events::Event::ExceptionEvent

(

)

lsst.ctrl.events::Event::ExceptionEvent	(	const std::string &	runid,
		const LSSTException	ex
	)

lsst.ctrl.events::Event::ExceptionEvent

(

cms::TextMessage *

msg

)

vector< std::string > lsst.ctrl.events::Event::getCustomPropertyNames

(

)

Definition at line 129 of file Event.cc.

                                                {
    vector<std::string> names = _psp->names();

    vector<std::string>::iterator nameIterator;
    set<std::string>::iterator keyIterator;

    for (nameIterator = names.begin(); nameIterator != names.end();) {
            keyIterator = _keywords.find(*nameIterator);
            if (keyIterator == _keywords.end())
                nameIterator++;
            else
                names.erase(nameIterator);
    }
    return names;
}

PropertySet::Ptr lsst.ctrl.events::Event::getCustomPropertySet

(

)

const

Definition at line 235 of file Event.cc.

                                                 {
    PropertySet::Ptr psp = _psp->deepCopy();

    set<std::string>::iterator keyIterator;
    for (keyIterator = _keywords.begin(); keyIterator != _keywords.end(); keyIterator++) 
        psp->remove(*keyIterator);
    return psp;
}

std::string lsst.ctrl.events::Event::getEventDate

(

)

Get the creation date of this event.

Returns

A formatted date string representing the event creation time

Definition at line 226 of file Event.cc.

                              {
    long long eventTime = _psp->get<long long>(EVENTTIME);
    dafBase::DateTime dateTime(eventTime);
    
    struct tm gmTime = dateTime.gmtime();
    return asctime(&gmTime);
}

long long lsst.ctrl.events::Event::getEventTime

(

)

Definition at line 211 of file Event.cc.

                              {
    return _psp->get<long long>(EVENTTIME);
}

std::string lsst.ctrl.events::Event::getExceptionType

(

)

vector< std::string > lsst.ctrl.events::Event::getFilterablePropertyNames

(

)

Definition at line 120 of file Event.cc.

                                                    {
    vector<std::string> _names;
    set<std::string>::iterator keyIterator;
    for (keyIterator = _keywords.begin(); keyIterator != _keywords.end(); keyIterator++) {
        _names.push_back(*keyIterator);
    }
    return _names;
}

std::string lsst.ctrl.events::Event::getHostId

(

)

Definition at line 276 of file Event.cc.

                           {
    return _psp->get<std::string>(HOSTID);
}

PropertySet::Ptr lsst.ctrl.events::Event::getPropertySet

(

)

const

Definition at line 244 of file Event.cc.

                                           {
    if (_psp != 0) {
            PropertySet::Ptr psp = _psp->deepCopy();
            return psp;
    }
    PropertySet::Ptr psp(new PropertySet);
    return psp;
}

std::string lsst.ctrl.events::Event::getPubDate

(

)

Get the publication date of this event.

Returns

A formatted date string represeting the publication time

Definition at line 264 of file Event.cc.

                            {
    long long _pubTime = _psp->get<long long>(PUBTIME);
    if (_pubTime == 0)
        return std::string();

    dafBase::DateTime dateTime(_pubTime);
    
    struct tm pubTime = dateTime.gmtime();
    return asctime(&pubTime);
}

long long lsst.ctrl.events::Event::getPubTime

(

)

Definition at line 257 of file Event.cc.

                            {
    return _psp->get<long long>(PUBTIME);
}

std::string lsst.ctrl.events::Event::getRunId

(

)

Definition at line 280 of file Event.cc.

                          {
    return _psp->get<std::string>(RUNID);
}

std::string lsst.ctrl.events::Event::getStackTrace

(

)

std::string lsst.ctrl.events::Event::getStatus

(

)

Definition at line 288 of file Event.cc.

                           {
    return _psp->get<std::string>(STATUS);
}

std::string lsst.ctrl.events::Event::getTopic

(

)

Definition at line 300 of file Event.cc.

                          {
    return _psp->get<std::string>(TOPIC);
}

std::string lsst.ctrl.events::Event::getType

(

void

)

Definition at line 284 of file Event.cc.

                         {
    return _psp->get<std::string>(TYPE);
}

void lsst.ctrl.events::Event::marshall

(

cms::TextMessage *

msg

)

Definition at line 304 of file Event.cc.

                                        {
    PropertySet::Ptr psp;

    populateHeader(msg);
    psp = getCustomPropertySet();
    std::string payload = marshall(*psp);
    msg->setText(payload);
}

std::string lsst.ctrl.events::Event::marshall ( const PropertySet &  ps )

private

Definition at line 314 of file Event.cc.

                                               {
    std::vector<std::string> v = ps.paramNames(false);

    // TODO: optimize this to get use getArray only when necessary
    std::ostringstream payload;
    unsigned int i;
    payload << "nodelist||nodelist||" << (v.size()) << "~~";
    for (i = 0; i < v.size(); i++) {
        std::string name = v[i];
        if (ps.typeOf(name) == typeid(bool)) {
            std::vector<bool> vec  = ps.getArray<bool>(name);
            std::vector<bool>::iterator iter;
            for (iter = vec.begin(); iter != vec.end(); iter++) {
                payload << "bool||"<< name << "||" << *iter << "~~";
            }
        } else if (ps.typeOf(name) == typeid(long)) {
            std::vector<long> vec  = ps.getArray<long>(name);
            std::vector<long>::iterator iter;
            for (iter = vec.begin(); iter != vec.end(); iter++) {
                payload << "long||" << name << "||"<< *iter << "~~";
            }
        } else if (ps.typeOf(name) == typeid(int)) {
            std::vector<int> vec  = ps.getArray<int>(name);
            std::vector<int>::iterator iter;
            for (iter = vec.begin(); iter != vec.end(); iter++) {
                payload << "int||" << name << "||"<< *iter << "~~";
            }
        } else if (ps.typeOf(name) == typeid(float)) {
            std::vector<float> vec  = ps.getArray<float>(name);
            std::vector<float>::iterator iter;
            payload.precision(numeric_limits<float>::digits10+1);
            for (iter = vec.begin(); iter != vec.end(); iter++) {
                payload << "float||"<< name << "||"<< *iter << "~~";
            }
        } else if (ps.typeOf(name) == typeid(double)) {
            std::vector<double> vec  = ps.getArray<double>(name);
            std::vector<double>::iterator iter;
            payload.precision(numeric_limits<double>::digits10+1);
            for (iter = vec.begin(); iter != vec.end(); iter++) {
                payload << "double||"<< name << "||"<< *iter << "~~";
            }
        } else if (ps.typeOf(name) == typeid(std::string)) {
            std::vector<std::string> vec  = ps.getArray<std::string>(name);
            std::vector<std::string>::iterator iter;
            for (iter = vec.begin(); iter != vec.end(); iter++) {
                payload << "string||" << name << "||"<< *iter << "~~";
            }
        } else if (ps.typeOf(name) == typeid(lsst::daf::base::DateTime)) {
            std::vector<lsst::daf::base::DateTime> vec  = ps.getArray<lsst::daf::base::DateTime>(name);
            std::vector<lsst::daf::base::DateTime>::iterator iter;
            for (iter = vec.begin(); iter != vec.end(); iter++) {
                payload << "datetime||" << name << "||"<< (*iter).nsecs() << "~~";
            }
        } else {
            std::cout << "Couldn't marshall "<< name << std::endl;
        }
    }
    return payload.str();
}

void lsst.ctrl.events::Event::populateHeader

(

cms::TextMessage *

msg

)

void lsst.ctrl.events::Event::populateHeader ( cms::TextMessage *  msg ) const

virtual

Reimplemented in lsst.ctrl.events::PipelineLogEvent, lsst.ctrl.events::CommandEvent, lsst.ctrl.events::LogEvent, and lsst.ctrl.events::StatusEvent.

Definition at line 201 of file Event.cc.

                                                     {
    msg->setStringProperty(TYPE, _psp->get<std::string>(TYPE));
    msg->setLongProperty(EVENTTIME, _psp->get<long long>(EVENTTIME));
    msg->setStringProperty(HOSTID, _psp->get<std::string>(HOSTID));
    msg->setStringProperty(RUNID, _psp->get<std::string>(RUNID));
    msg->setStringProperty(STATUS, _psp->get<std::string>(STATUS));
    msg->setStringProperty(TOPIC, _psp->get<std::string>(TOPIC));
    msg->setLongProperty(PUBTIME, _psp->get<long long>(PUBTIME));
}

PropertySet::Ptr lsst.ctrl.events::Event::processTextMessage ( cms::TextMessage *  textMessage )

private

private method unmarshall the DataProperty from the TextMessage

Definition at line 376 of file Event.cc.

                                                                    {
    if (textMessage == NULL)
        return PropertySet::Ptr();

    std::string text = textMessage->getText();

    return unmarshall(text);
}

void lsst.ctrl.events::Event::setEventTime

(

long long

nsecs

)

Definition at line 215 of file Event.cc.

                                        {
    _psp->set(EVENTTIME,  nsecs);
}

void lsst.ctrl.events::Event::setPubTime

(

long long

t

)

Definition at line 253 of file Event.cc.

                                  {
    _psp->set(PUBTIME, t);
}

void lsst.ctrl.events::Event::setStatus

(

std::string

status

)

Definition at line 292 of file Event.cc.

                                       {
    return _psp->set(STATUS, status);
}

void lsst.ctrl.events::Event::setTopic

(

std::string

topic

)

Definition at line 296 of file Event.cc.

                                    {
    _psp->set(TOPIC, topic);
}

void lsst.ctrl.events::Event::splitString ( std::string  str, std::string  delim, std::vector< std::string > &  results  )

protected

private method to split a string along it's delimiters and return the results in a vector

Definition at line 455 of file Event.cc.

                                                              {
    std::string::size_type cutAt;
    std::string::size_type delim_len = delim.length();

    while( (cutAt = str.find(delim)) != str.npos ) {
        if(cutAt > 0) {
            results.push_back(str.substr(0,cutAt));
        }
        str = str.substr(cutAt+delim_len);
    }
    if(str.length() > 0) {
        results.push_back(str);
    }
}

void lsst.ctrl.events::Event::splitTuple ( std::string  str, std::string  delim, std::vector< std::string > &  results  )

protected

private method to split a tuple string along it's delimiters and return the results in a vector; don't try and modify splitString to do this.

Definition at line 474 of file Event.cc.

                                                              {
    std::string::size_type cutAt;
    std::string::size_type delim_len = delim.length();

    cutAt = str.find(delim);
    results.push_back(str.substr(0,cutAt));
    str = str.substr(cutAt+delim_len);

    cutAt = str.find(delim);
    results.push_back(str.substr(0,cutAt));
    str = str.substr(cutAt+delim_len);

    cutAt = str.find(delim);
    results.push_back(str.substr(0,cutAt));
}

PropertySet::Ptr lsst.ctrl.events::Event::unmarshall ( const std::string &  text )

private

private method unmarshall the DataProperty from a text string

Definition at line 387 of file Event.cc.

                                                      {
    std::vector<string> tuples;

    // split the text into tuples
    splitString(text, "~~", tuples);


    PropertySet::Ptr psp(new PropertySet);

    unsigned int i;
    for (i = 0; i < tuples.size(); i++) {
        std::string line = tuples.at(i);
        std::vector<string> vec;
        splitTuple(line, "||", vec);

        std::string type = vec.at(0);
        std::string key = vec.at(1);
        std::string val = vec.at(2);

        std::istringstream iss(val);
        boost::any value;

        if (type == "int") {
            int int_value;
            iss >> int_value;
            value = boost::any(int_value);
            psp->add(key, int_value);
        } else if (type == "bool") {
            bool bool_value;
            iss >> bool_value;
            value = boost::any(bool_value);
            psp->add(key, bool_value);
        } else if (type == "long long") {
            long long longlong_value;
            iss >> longlong_value;
            value = boost::any(longlong_value);
            psp->add(key, longlong_value);
        } else if (type == "long") {
            long long_value;
            iss >> long_value;
            value = boost::any(long_value);
            psp->add(key, long_value);
        } else if (type == "float") {
            float float_value;
            iss >> float_value;
            value = boost::any(float_value);
            psp->add(key, float_value);
        } else if (type == "double") {
            double double_value;
            iss >> double_value;
            value = boost::any(double_value);
            psp->add(key, double_value);
        } else if (type == "string") {
            psp->add(key, val);
        } else if (type == "datetime") {
            long long longlong_value;
            iss >> longlong_value;
            psp->add(key, lsst::daf::base::DateTime(longlong_value, lsst::daf::base::DateTime::UTC));
        }
        // type == nodelist can be ignored
    }
        
    return psp;
}

void lsst.ctrl.events::Event::updateEventTime

(

)

Definition at line 219 of file Event.cc.

                            {
    _psp->set(EVENTTIME,  (long long)dafBase::DateTime::now().nsecs());
}

Member Data Documentation

set<std::string> lsst.ctrl.events::Event::_keywords

protected

Definition at line 118 of file Event.h.

PropertySet::Ptr lsst.ctrl.events::Event::_psp

protected

Definition at line 117 of file Event.h.

const std::string lsst.ctrl.events::Event::EVENTTIME = "EVENTTIME"

static

Definition at line 72 of file Event.h.

const std::string lsst.ctrl.events::Event::EXCEPTIONTYPE

static

Definition at line 57 of file ExceptionEvent.h.

const std::string lsst.ctrl.events::Event::HOSTID = "HOSTID"

static

Definition at line 73 of file Event.h.

const std::string lsst.ctrl.events::Event::PUBTIME = "PUBTIME"

static

Definition at line 77 of file Event.h.

const std::string lsst.ctrl.events::Event::RUNID = "RUNID"

static

Definition at line 74 of file Event.h.

const std::string lsst.ctrl.events::Event::STACKTRACE

static

Definition at line 58 of file ExceptionEvent.h.

const std::string lsst.ctrl.events::Event::STATUS = "STATUS"

static

Definition at line 75 of file Event.h.

const std::string lsst.ctrl.events::Event::TOPIC = "TOPIC"

static

Definition at line 76 of file Event.h.

const std::string lsst.ctrl.events::Event::TYPE = "TYPE"

static

Creates Event which contains a PropertySet.

Exceptions

throws

NotFoundError if expected keywords are missing a property set

Definition at line 71 of file Event.h.

const std::string lsst.ctrl.events::Event::UNINITIALIZED = "uninitialized"

static

Definition at line 78 of file Event.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/Event.h
• /lsst/home/lsstsw/stack/Linux64/ctrl_events/master-gcf15f11bcc/include/lsst/ctrl/events/ExceptionEvent.h
• /lsst/home/lsstsw/stack/Linux64/ctrl_events/master-gcf15f11bcc/src/Event.cc