void Codec::setConfig(const Vocabulary& v, const xmlNodePtr config_ptr)
{
PlatformPlugin::setConfig(v, config_ptr);
// determine the type of event used by the codec
std::string codec_event_str;
if (! ConfigManager::getConfigOption(EVENT_ELEMENT_NAME, codec_event_str,
config_ptr))
throw EmptyEventException(getId());
// find the Term reference number for the event type
Vocabulary::TermRef event_type = v.findTerm(codec_event_str);
if (event_type == Vocabulary::UNDEFINED_TERM_REF)
throw UnknownTermException(codec_event_str);
m_event_term = v[event_type];
// make sure that it is an object type Term
if (m_event_term.term_type != Vocabulary::TYPE_OBJECT)
throw NotAnObjectException(codec_event_str);
}
void FissionReactor::setConfig(const Vocabulary& v, const xmlNodePtr config_ptr)
{
// first set config options for the Reactor base class
ConfigWriteLock cfg_lock(*this);
Reactor::setConfig(v, config_ptr);
// get the input event type
std::string config_str;
if (! ConfigManager::getConfigOption(INPUT_EVENT_TYPE_ELEMENT_NAME, config_str, config_ptr))
throw EmptyInputEventTypeException(getId());
// find vocabulary term for input event type
Vocabulary::TermRef term_ref = v.findTerm(config_str);
if (term_ref == Vocabulary::UNDEFINED_TERM_REF)
throw UnknownTermException(config_str);
m_input_event_type = v[term_ref];
// make sure that term is object/event type
if (m_input_event_type.term_type != Vocabulary::TYPE_OBJECT)
throw NotAnObjectException(config_str);
// get the input event term
if (! ConfigManager::getConfigOption(INPUT_EVENT_TERM_ELEMENT_NAME, config_str, config_ptr))
throw EmptyInputEventTermException(getId());
// find vocabulary term for input event term
term_ref = v.findTerm(config_str);
if (term_ref == Vocabulary::UNDEFINED_TERM_REF)
throw UnknownTermException(config_str);
m_input_event_term = v[term_ref];
// only string types are currently supported for input event term
switch (m_input_event_term.term_type) {
case Vocabulary::TYPE_NULL:
case Vocabulary::TYPE_OBJECT:
case Vocabulary::TYPE_INT8:
case Vocabulary::TYPE_INT16:
case Vocabulary::TYPE_INT32:
case Vocabulary::TYPE_UINT8:
case Vocabulary::TYPE_UINT16:
case Vocabulary::TYPE_UINT32:
case Vocabulary::TYPE_INT64:
case Vocabulary::TYPE_UINT64:
case Vocabulary::TYPE_FLOAT:
case Vocabulary::TYPE_DOUBLE:
case Vocabulary::TYPE_LONG_DOUBLE:
case Vocabulary::TYPE_DATE_TIME:
case Vocabulary::TYPE_DATE:
case Vocabulary::TYPE_TIME:
throw TermNotStringException(config_str);
break;
case Vocabulary::TYPE_SHORT_STRING:
case Vocabulary::TYPE_STRING:
case Vocabulary::TYPE_LONG_STRING:
case Vocabulary::TYPE_CHAR:
case Vocabulary::TYPE_BLOB:
case Vocabulary::TYPE_ZBLOB:
break; // these are all OK
}
// get the codec to use
boost::mutex::scoped_lock codec_lock(m_codec_mutex);
if (! ConfigManager::getConfigOption(CODEC_ELEMENT_NAME, m_codec_id, config_ptr))
throw EmptyCodecException(getId());
m_codec_ptr = getCodecFactory().getCodec(m_codec_id);
PION_ASSERT(m_codec_ptr);
codec_lock.unlock();
// check if we should copy all terms from original event
m_copy_all_terms = false;
std::string copy_all_terms_str;
if (ConfigManager::getConfigOption(COPY_ALL_TERMS_ELEMENT_NAME,
copy_all_terms_str, config_ptr))
{
if (copy_all_terms_str == "true")
m_copy_all_terms = true;
}
// get list of terms to copy from original event
m_copy_terms.clear();
xmlNodePtr copy_term_node = config_ptr;
while ((copy_term_node = ConfigManager::findConfigNodeByName(COPY_TERM_ELEMENT_NAME, copy_term_node)) != NULL) {
xmlChar *xml_char_ptr = xmlNodeGetContent(copy_term_node);
if (xml_char_ptr != NULL) {
const std::string copy_term_str(reinterpret_cast<char*>(xml_char_ptr));
xmlFree(xml_char_ptr);
if (! copy_term_str.empty()) {
// find the term in the Vocabulary
term_ref = v.findTerm(copy_term_str);
if (term_ref == Vocabulary::UNDEFINED_TERM_REF)
throw UnknownTermException(copy_term_str);
// add it to the copy terms collection
m_copy_terms.push_back(v[term_ref]);
}
}
// step to the next copy term
copy_term_node = copy_term_node->next;
}
}
void TransformReactor::setConfig(const Vocabulary& v, const xmlNodePtr config_ptr)
{
// first set config options for the Reactor base class
ConfigWriteLock cfg_lock(*this);
Reactor::setConfig(v, config_ptr);
// clear the current configuration
m_transforms.clear();
// Outgoing Event type -- i.e. what will the outgoing event be transformed into
// Default (UNDEFINED_TERM_REF) -- make it the same as incoming event type
// <OutgoingEvent>obj-term</OutgoingEvent>
m_event_type = Vocabulary::UNDEFINED_TERM_REF;
std::string event_type_str;
if (ConfigManager::getConfigOption(OUTGOING_EVENT_ELEMENT_NAME, event_type_str, config_ptr))
{
if (!event_type_str.empty())
m_event_type = v.findTerm(event_type_str);
}
// This really doesn't make much sense anymore -- you can wire the delivery of the original right through
// it would make sense, if it was possible to deliver "if-not-changed" but TR2 always changes...
// <DeliverOriginal>always|if-not-changed|never</DeliveryOriginal> -> DEFAULT: never
m_deliver_original = DO_NEVER;
std::string deliver_original_str;
if (ConfigManager::getConfigOption(DELIVER_ORIGINAL_NAME, deliver_original_str, config_ptr))
{
if (deliver_original_str == "true" || deliver_original_str == "always")
m_deliver_original = DO_ALWAYS;
else if (deliver_original_str == "if-not-changed")
m_deliver_original = DO_SOMETIMES;
// Could add code to throw if d_o_s is not "never"
}
// What fields/terms of the original event should be COPIED into the new event
// <CopyOriginal>all-terms|if-not-defined|none</CopyOriginal> -> DEFAULT: if-not-defined
m_copy_original = COPY_UNCHANGED;
std::string copy_original_str;
if (ConfigManager::getConfigOption(COPY_ORIGINAL_ELEMENT_NAME, copy_original_str, config_ptr))
{
if (copy_original_str == "all-terms")
m_copy_original = COPY_ALL;
else if (copy_original_str == "none")
m_copy_original = COPY_NONE;
// Could add code to throw if c_o_s is not "if-not-defined"
}
// now, parse transformation rules
// [rpt] <Transformation>
xmlNodePtr transformation_node = config_ptr;
while ( (transformation_node = ConfigManager::findConfigNodeByName(TRANSFORMATION_ELEMENT_NAME, transformation_node)) != NULL)
{
// parse new Transformation rule
// get the Term used for the Transformation rule
// <Term>src-term</Term>
std::string term_id;
if (! ConfigManager::getConfigOption(TERM_ELEMENT_NAME, term_id,
transformation_node->children))
throw EmptyTermException(getId());
// make sure that the Term is valid
const Vocabulary::TermRef term_ref = v.findTerm(term_id);
if (term_ref == Vocabulary::UNDEFINED_TERM_REF)
throw UnknownTermException(getId());
// get the Type of transformation
// <Type>AssignValue|AssignTerm|Lookup|Rules</Type>
std::string type_str;
if (! ConfigManager::getConfigOption(TYPE_ELEMENT_NAME, type_str,
transformation_node->children))
throw EmptyTypeException(getId()); // TODO: Improve the error message
// Add the transformation
const bool debug_mode = getReactionEngine().getDebugMode();
Transform *new_transform;
if (type_str == "AssignValue")
new_transform = new TransformAssignValue(v, v[term_ref], transformation_node->children, debug_mode);
else if (type_str == "AssignTerm")
new_transform = new TransformAssignTerm(v, v[term_ref], transformation_node->children, debug_mode);
else if (type_str == "Lookup")
new_transform = new TransformLookup(v, v[term_ref], transformation_node->children, debug_mode);
else if (type_str == "Rules")
new_transform = new TransformRules(v, v[term_ref], transformation_node->children, debug_mode);
else if (type_str == "Regex")
new_transform = new TransformRegex(v, v[term_ref], transformation_node->children, debug_mode);
else if (type_str == "SplitTerm")
new_transform = new TransformSplitTerm(v, v[term_ref], transformation_node->children, debug_mode);
else if (type_str == "JoinTerm")
new_transform = new TransformJoinTerm(v, v[term_ref], transformation_node->children, debug_mode);
else if (type_str == "URLEncode")
new_transform = new TransformURLEncode(v, v[term_ref], transformation_node->children, debug_mode);
else if (type_str == "URLDecode")
new_transform = new TransformURLDecode(v, v[term_ref], transformation_node->children, debug_mode);
else
throw InvalidTransformation(type_str);
m_transforms.push_back(new_transform);
// step to the next Comparison rule
transformation_node = transformation_node->next;
}
}