std::shared_ptr<core::Processor> ExecutionPlan::addProcessor(const std::shared_ptr<core::Processor> &processor, const std::string &name, core::Relationship relationship, bool linkToPrevious) {
if (finalized) {
return nullptr;
}
utils::Identifier uuid;
id_generator_->generate(uuid);
processor->setStreamFactory(stream_factory);
// initialize the processor
processor->initialize();
processor_mapping_[processor->getUUIDStr()] = processor;
if (!linkToPrevious) {
termination_ = relationship;
} else {
std::shared_ptr<core::Processor> last = processor_queue_.back();
if (last == nullptr) {
last = processor;
termination_ = relationship;
}
relationships_.push_back(connectProcessors(last, processor, relationship, true));
}
std::shared_ptr<core::ProcessorNode> node = std::make_shared<core::ProcessorNode>(processor);
processor_nodes_.push_back(node);
std::shared_ptr<core::ProcessContext> context = std::make_shared<core::ProcessContext>(node, controller_services_provider_, prov_repo_, flow_repo_, content_repo_);
processor_contexts_.push_back(context);
processor_queue_.push_back(processor);
return processor;
}
void ExecutionPlan::finalize() {
if (failure_handler_) {
auto failure_proc = createProcessor(CallbackProcessorName, CallbackProcessorName);
std::shared_ptr<processors::CallbackProcessor> callback_proc = std::static_pointer_cast<processors::CallbackProcessor>(failure_proc);
callback_proc->setCallback(nullptr, std::bind(&FailureHandler::operator(), failure_handler_, std::placeholders::_1));
for (const auto& proc : processor_queue_) {
for (const auto& rel : proc->getSupportedRelationships()) {
if (rel.getName() == "failure") {
relationships_.push_back(connectProcessors(proc, failure_proc, core::Relationship("failure", "failure collector"), true));
break;
}
}
}
std::shared_ptr<core::ProcessorNode> node = std::make_shared<core::ProcessorNode>(failure_proc);
processor_nodes_.push_back(node);
std::shared_ptr<core::ProcessContext> context = std::make_shared<core::ProcessContext>(node, controller_services_provider_, prov_repo_, flow_repo_, content_repo_);
processor_contexts_.push_back(context);
processor_queue_.push_back(failure_proc);
}
if (relationships_.size() > 0) {
relationships_.push_back(buildFinalConnection(processor_queue_.back()));
} else {
for (auto processor : processor_queue_) {
relationships_.push_back(buildFinalConnection(processor, true));
}
}
finalized = true;
}
bool ConfigReader::createConfig()
{
bool inProcessingMode = false;
while(!atEnd())
{
TokenType token = readNext();
// First, check if processing is possible
if(token == StartElement && name() == "olvisConfig")
{
inProcessingMode = true;
continue;
}
if(!inProcessingMode)
continue;
switch(token)
{
case StartElement:
if(name() == "makroFilter")
createMakroFilter();
else if(name() == "processor")
createProcessor();
else if(name() == "buffer")
createBuffer();
else if(name() == "join")
createJoin();
else if(name() == "filter")
{
createFilter();
// Filter could not be created, cancel loading
if(mCurrentFilter == -1){
return false;
}
}
else if(name() == "port")
setPort();
else if(name() == "makroInput")
addMakroInput();
else if(name() == "makroOutput")
addMakroOutput();
else if(name() == "processorOutput")
addProcessorOutput();
else if(name() == "source")
setSource();
else if(name() == "connection")
connectProcessors();
else if(name() == "inputConnection")
connectProcessorInput();
mCurrentData = "";
break;
case Characters:
mCurrentData += text();
break;
case EndElement:
if(name() == "processor")
mCurrentProcessor = 0;
else if(name() == "filter")
mCurrentFilter = 0;
else if(name() == "port")
mCurrentPort = "";
else if(name() == "value")
setValue();
else if(name() == "olvisConfig")
inProcessingMode = false;
break;
default:
break;
}
}
// Default: Return true, as config was loaded
return true;
}
void ProcessorGraph::updateConnections(Array<SignalChainTabButton*, CriticalSection> tabs)
{
clearConnections(); // clear processor graph
std::cout << "Updating connections:" << std::endl;
std::cout << std::endl;
std::cout << std::endl;
Array<GenericProcessor*> splitters;
// GenericProcessor* activeSplitter = nullptr;
for (int n = 0; n < tabs.size(); n++) // cycle through the tabs
{
std::cout << "Signal chain: " << n << std::endl;
std::cout << std::endl;
GenericEditor* sourceEditor = (GenericEditor*) tabs[n]->getEditor();
GenericProcessor* source = (GenericProcessor*) sourceEditor->getProcessor();
while (source != nullptr)// && destEditor->isEnabled())
{
std::cout << "Source node: " << source->getName() << "." << std::endl;
GenericProcessor* dest = (GenericProcessor*) source->getDestNode();
if (source->enabledState())
{
// add the connections to audio and record nodes if necessary
if (!(source->isSink() ||
source->isSplitter() ||
source->isMerger() ||
source->isUtility())
&& !(source->wasConnected))
{
std::cout << " Connecting to audio and record nodes." << std::endl;
connectProcessorToAudioAndRecordNodes(source);
}
else
{
std::cout << " NOT connecting to audio and record nodes." << std::endl;
}
if (dest != nullptr)
{
while (dest->isMerger()) // find the next dest that's not a merger
{
dest = dest->getDestNode();
if (dest == nullptr)
break;
}
if (dest != nullptr)
{
while (dest->isSplitter())
{
if (!dest->wasConnected)
{
if (!splitters.contains(dest))
{
splitters.add(dest);
dest->switchIO(0); // go down first path
}
else
{
int splitterIndex = splitters.indexOf(dest);
splitters.remove(splitterIndex);
dest->switchIO(1); // go down second path
dest->wasConnected = true; // make sure we don't re-use this splitter
}
}
dest = dest->getDestNode();
if (dest == nullptr)
break;
}
if (dest != nullptr)
{
if (dest->enabledState())
{
connectProcessors(source, dest);
}
}
}
else
{
std::cout << " No dest node." << std::endl;
}
}
else
{
std::cout << " No dest node." << std::endl;
}
}
std::cout << std::endl;
source->wasConnected = true;
source = dest; // switch source and dest
if (source == nullptr && splitters.size() > 0)
{
source = splitters.getLast();
GenericProcessor* newSource;// = source->getSourceNode();
while (source->isSplitter() || source->isMerger())
{
newSource = source->getSourceNode();
newSource->setPathToProcessor(source);
source = newSource;
}
}
} // end while source != 0
} // end "tabs" for loop
} // end method
std::shared_ptr<minifi::Connection> ExecutionPlan::buildFinalConnection(std::shared_ptr<core::Processor> processor, bool set_dst) {
return connectProcessors(processor, processor, termination_, set_dst);
}
