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); }