void XMLConfiguration::save(const std::string& path) const
{
Poco::XML::DOMWriter writer;
writer.setNewLine("\n");
writer.setOptions(Poco::XML::XMLWriter::PRETTY_PRINT);
writer.writeNode(path, _pDocument);
}
void XMLConfiguration::save(std::ostream& ostr) const
{
Poco::XML::DOMWriter writer;
writer.setNewLine("\n");
writer.setOptions(Poco::XML::XMLWriter::PRETTY_PRINT);
writer.writeNode(ostr, _pDocument);
}
/* Validate all of the pipelines in the given config file.
* This method does some basic parsing of the config file to learn
* about the various pipelines that exist in the file.
*/
bool ValidatePipeline::isValid(const char *a_configPath) const
{
bool failed = false;
std::ifstream in(a_configPath);
if (!in) {
fprintf(stdout, "Error opening pipeline config file: %s\n", a_configPath);
} else {
try {
Poco::XML::InputSource src(in);
Poco::XML::DOMParser parser;
// basic parsing
Poco::AutoPtr<Poco::XML::Document> xmlDoc = parser.parse(&src);
// must have at least one pipeline element
Poco::AutoPtr<Poco::XML::NodeList> pipelines =
xmlDoc->getElementsByTagName(TskPipelineManager::PIPELINE_ELEMENT);
if (pipelines->length() == 0) {
fprintf(stdout, "No pipelines found in config file.\n");
} else {
// parse all pipelines in the config file
for (unsigned long i = 0; i < pipelines->length(); i++)
{
Poco::XML::Node * pNode = pipelines->item(i);
Poco::XML::Element* pElem = dynamic_cast<Poco::XML::Element*>(pNode);
Poco::XML::DOMWriter writer;
std::ostringstream pipelineXml;
writer.writeNode(pipelineXml, pNode);
std::string pipelineType = pElem->getAttribute(TskPipelineManager::PIPELINE_TYPE_ATTRIBUTE);
TskPipeline * pipeline = 0;
if (pipelineType == TskPipelineManager::FILE_ANALYSIS_PIPELINE_STR)
pipeline = new TskFileAnalysisPipeline();
else if (pipelineType == TskPipelineManager::REPORTING_PIPELINE_STR)
pipeline = new TskReportPipeline();
else {
fprintf(stdout, "Unsupported pipeline type: %s\n", pipelineType.c_str());
failed = true;
continue;
}
try {
pipeline->validate(pipelineXml.str());
} catch (...) {
fprintf(stdout, "Error parsing pipeline: %s\n", pElem->getAttribute(TskPipelineManager::PIPELINE_TYPE_ATTRIBUTE).c_str());
failed = true;
}
delete pipeline;
}
}
} catch (Poco::XML::SAXParseException& ex) {
fprintf(stderr, "Error parsing pipeline config file: %s (%s)\n", a_configPath, ex.what());
}
}
// If any of the pipelines failed validation we return false
return failed ? false : true;
}
string ofXml::toString() const
{
ostringstream stream;
Poco::XML::DOMWriter writer;
writer.setOptions(Poco::XML::XMLWriter::PRETTY_PRINT);
if(document) {
try {
writer.writeNode( stream, getPocoDocument() );
} catch( exception & e ) {
ofLogError("ofXml") << "toString(): " << e.what();
}
} else if(element){
element->normalize();
writer.writeNode( stream, element );
}
string tmp = stream.str();
// don't know how else to get rid of the hidden <#text></#text> nodes :/
ofStringReplace(tmp, "<#text>", "");
ofStringReplace(tmp, "</#text>", "");
return tmp;
}
void DebugBreakpointManager::SaveState(const Poco::Path& path) const
{
Poco::XML::Document* doc = new Poco::XML::Document();
Poco::XML::Element* breakpoints = doc->createElement(BREAKPOINTS_TAG);
doc->appendChild(breakpoints)->release();
for (std::set<unsigned long>::const_iterator i = m_ObjectBreakpoints.begin(); i
!= m_ObjectBreakpoints.end(); ++i)
{
Poco::XML::Element* objectBreakpoint = doc->createElement(OBJECT_TAG);
breakpoints->appendChild(objectBreakpoint)->release();
std::stringstream ss;
ss << *i;
objectBreakpoint->setAttribute(ID_ATTR, ss.str());
const Object* obj = DebugUtil::GetObject(*i);
if (obj)
{
objectBreakpoint->setAttribute(CLASSNAME_ATTR, obj->GetClassName());
}
}
for (Poco::HashMap<int, const Object*>::ConstIterator i =
m_SmartPointerBreakpoints.begin(); i != m_SmartPointerBreakpoints.end(); ++i)
{
Poco::XML::Element* spBreakpoint = doc->createElement(SMARTPOINTER_TAG);
breakpoints->appendChild(spBreakpoint)->release();
std::stringstream ss;
ss << i->first;
spBreakpoint->setAttribute(ID_ATTR, ss.str());
const Object* obj = i->second;
if (i->second)
{
spBreakpoint->setAttribute(CLASSNAME_ATTR, obj->GetClassName());
ss.clear();
ss << obj->GetTraceId();
spBreakpoint->setAttribute(OBJECTID_ATTR, ss.str());
}
}
Poco::FileOutputStream writer(path.toString());
Poco::XML::DOMWriter out;
out.setOptions(3); //write declaration and pretty print
out.writeNode(writer, doc);
doc->release();
}
void DebugUtil::SaveState()
{
Poco::Path path;
if (!GetPersistencePath(path)) return;
path.setFileName(DEBUG_UTIL_XML);
Poco::XML::Document* doc = new Poco::XML::Document();
Poco::XML::Element* debugutil = doc->createElement(DEBUGUTIL_TAG);
doc->appendChild(debugutil)->release();
for (std::set<unsigned int>::const_iterator i = m_TracedObjects.begin();
i != m_TracedObjects.end(); ++i)
{
Poco::XML::Element* traceObject = doc->createElement(TRACEOBJECT_TAG);
debugutil->appendChild(traceObject)->release();
std::stringstream ss;
ss << *i;
traceObject->setAttribute(ID_ATTR, ss.str());
}
for (std::set<std::string>::const_iterator i = m_TracedClasses.begin();
i != m_TracedClasses.end(); ++i)
{
Poco::XML::Element* traceClass = doc->createElement(TRACECLASS_TAG);
debugutil->appendChild(traceClass)->release();
traceClass->setAttribute(NAME_ATTR, *i);
}
try
{
Poco::FileOutputStream writer(path.toString());
Poco::XML::DOMWriter out;
out.setOptions(3); //write declaration and pretty print
out.writeNode(writer, doc);
doc->release();
// save BreakpointManager
path.setFileName(DebugBreakpointManager::BREAKPOINTS_XML);
GetBreakpointManager()->SaveState(path);
}
catch (Poco::FileException& e)
{
BERRY_WARN << e.displayText();
}
}
void XMLConfiguration::save(Poco::XML::DOMWriter& writer, std::ostream& ostr) const
{
writer.writeNode(ostr, _pDocument);
}
void XMLConfiguration::save(Poco::XML::DOMWriter& writer, const std::string& path) const
{
writer.writeNode(path, _pDocument);
}
std::string Pothos::Topology::toDotMarkup(const std::string &request)
{
//parse request arguments
const auto result = Poco::JSON::Parser().parse(request.empty()?"{}":request);
auto configObj = result.extract<Poco::JSON::Object::Ptr>();
const auto portConfig = configObj->optValue<std::string>("port", "connected");
//get a JSON dump of the topology
const auto dumpResult = Poco::JSON::Parser().parse(this->dumpJSON(request));
const auto topObj = dumpResult.extract<Poco::JSON::Object::Ptr>();
const auto connsArray = topObj->getArray("connections");
const auto blocksObj = topObj->getObject("blocks");
std::vector<std::string> blockIds; blocksObj->getNames(blockIds);
std::ostringstream os;
os << "digraph flat_flows {" << std::endl;
os << " rankdir=LR;" << std::endl;
os << " node [shape=record, fontsize=10];" << std::endl;
for (const auto &blockId : blockIds)
{
const auto blockObj = blocksObj->getObject(blockId);
//form xml
Poco::AutoPtr<Poco::XML::Document> xmlDoc(new Poco::XML::Document());
auto nodeTable = xmlDoc->createElement("table");
xmlDoc->appendChild(nodeTable);
nodeTable->setAttribute("border", "0");
nodeTable->setAttribute("cellpadding", "0");
nodeTable->setAttribute("cellspacing", "0");
auto nodeTr = xmlDoc->createElement("tr");
nodeTable->appendChild(nodeTr);
const bool enbFilter = portConfig == "connected";
const auto inputPorts = getConnectedPortInfos(topObj, blockId, enbFilter, true);
const auto outputPorts = getConnectedPortInfos(topObj, blockId, enbFilter, false);
if (inputPorts->size() > 0)
{
nodeTr->appendChild(portInfoToElem(xmlDoc, inputPorts, "in"));
}
{
auto nodeTd = xmlDoc->createElement("td");
nodeTd->setAttribute("border", "0");
nodeTr->appendChild(nodeTd);
auto table = xmlDoc->createElement("table");
nodeTd->appendChild(table);
table->setAttribute("border", "0");
table->setAttribute("cellspacing", "0");
auto tr = xmlDoc->createElement("tr");
table->appendChild(tr);
auto td = xmlDoc->createElement("td");
td->setAttribute("border", "1");
td->setAttribute("bgcolor", "azure");
tr->appendChild(td);
auto name = blockObj->getValue<std::string>("name");
if (name.empty()) name = "Empty Name";
td->appendChild(xmlDoc->createTextNode(name));
}
if (outputPorts->size() > 0)
{
nodeTr->appendChild(portInfoToElem(xmlDoc, outputPorts, "out"));
}
//dot node entry
os << " ";
os << std::hash<std::string>()(blockId);
os << "[" << std::endl;
os << " shape=none," << std::endl;
os << " label=<" << std::endl;
Poco::XML::DOMWriter write;
write.setOptions(Poco::XML::XMLWriter::PRETTY_PRINT);
write.writeNode(os, xmlDoc);
os << " >" << std::endl;
os << "];" << std::endl;
}
for (size_t c_i = 0; c_i < connsArray->size(); c_i++)
{
const auto conn = connsArray->getObject(c_i);
os << " ";
os << std::hash<std::string>()(conn->getValue<std::string>("srcId"));
os << ":__out__" << conn->getValue<std::string>("srcName");
os << " -> ";
os << std::hash<std::string>()(conn->getValue<std::string>("dstId"));
os << ":__in__" << conn->getValue<std::string>("dstName");
os << ";" << std::endl;
}
os << "}" << std::endl;
return os.str();
}