void terrama2::services::view::core::makeView(ViewId viewId, std::shared_ptr< terrama2::services::view::core::ViewLogger > logger, std::weak_ptr<DataManager> weakDataManager)
{
auto dataManager = weakDataManager.lock();
if(!dataManager.get())
{
TERRAMA2_LOG_ERROR() << QObject::tr("Unable to access DataManager");
return;
}
try
{
RegisterId logId = 0;
if(logger.get())
logId = logger->start(viewId);
TERRAMA2_LOG_DEBUG() << QObject::tr("Starting view %1 generation.").arg(viewId);
auto lock = dataManager->getLock();
auto viewPtr = dataManager->findView(viewId);
if(viewPtr->dataSeriesList.size() != viewPtr->filtersPerDataSeries.size())
{
QString message = QObject::tr("View %1 do not have the right number of filters for data.").arg(viewId);
if(logger.get())
logger->error(message.toStdString(), viewId);
TERRAMA2_LOG_ERROR() << message;
throw Exception() << ErrorDescription(message);
}
std::vector<std::unordered_map<terrama2::core::DataSetPtr, terrama2::core::DataSetSeries>> seriesList;
for(auto dataSeriesId : viewPtr->dataSeriesList)
{
terrama2::core::DataSeriesPtr inputDataSeries = dataManager->findDataSeries(dataSeriesId);
terrama2::core::DataProviderPtr inputDataProvider = dataManager->findDataProvider(inputDataSeries->dataProviderId);
auto dataAccessor = terrama2::core::DataAccessorFactory::getInstance().make(inputDataProvider, inputDataSeries);
terrama2::core::Filter filter(viewPtr->filtersPerDataSeries.at(dataSeriesId));
std::unordered_map<terrama2::core::DataSetPtr, terrama2::core::DataSetSeries > series = dataAccessor->getSeries(filter);
seriesList.push_back(series);
}
lock.unlock();
if(seriesList.size() > 0)
{
drawSeriesList(viewId, logger, seriesList, viewPtr->resolutionWidth, viewPtr->resolutionHeight, viewPtr->srid);
TERRAMA2_LOG_INFO() << QObject::tr("View %1 generated successfully.").arg(viewId);
}
else
{
QString message = QObject::tr("View %1 has no associated data to be generated.").arg(viewId);
if(logger.get())
logger->info(message.toStdString(), viewId);
TERRAMA2_LOG_INFO() << message;
}
if(logger.get())
logger->done(terrama2::core::TimeUtils::nowUTC(), logId);
}
catch(const terrama2::Exception& e)
{
TERRAMA2_LOG_ERROR() << boost::get_error_info<terrama2::ErrorDescription>(e) << std::endl;
TERRAMA2_LOG_INFO() << QObject::tr("Build of view %1 finished with error(s).").arg(viewId);
}
catch(const boost::exception& e)
{
TERRAMA2_LOG_ERROR() << boost::get_error_info<terrama2::ErrorDescription>(e);
TERRAMA2_LOG_INFO() << QObject::tr("Build of view %1 finished with error(s).").arg(viewId);
}
catch(const std::exception& e)
{
TERRAMA2_LOG_ERROR() << e.what();
TERRAMA2_LOG_INFO() << QObject::tr("Build of view %1 finished with error(s).").arg(viewId);
}
catch(...)
{
TERRAMA2_LOG_ERROR() << QObject::tr("Unkown error.");
TERRAMA2_LOG_INFO() << QObject::tr("Build of view %1 finished with error(s).").arg(viewId);
}
}
void terrama2::services::view::core::Service::removeCompleteView(const ViewPtr& viewPtr, DataSeriesId dataSeriesId, bool removeAll) noexcept
{
ViewId id = viewPtr->id;
try
{
std::lock_guard<std::mutex> lock(mutex_);
TERRAMA2_LOG_INFO() << tr("Trying to remove view %1.").arg(id);
auto it = timers_.find(id);
if(it != timers_.end())
{
auto timer = timers_.at(id);
timer->disconnect();
timers_.erase(id);
}
// remove from queue
processQueue_.erase(std::remove_if(processQueue_.begin(), processQueue_.end(),
[&id](const terrama2::core::ExecutionPackage& executionPackage)
{ return id == executionPackage.processId; }), processQueue_.end());
if (removeAll)
{
terrama2::core::DataProviderPtr inputDataProvider;
// Locking datamanager
{
auto dataManager = dataManager_.lock();
auto lock = dataManager->getLock();
terrama2::core::DataSeriesPtr inputDataSeries = dataManager->findDataSeries(dataSeriesId);
inputDataProvider = dataManager->findDataProvider(inputDataSeries->dataProviderId);
lock.unlock();
}
try
{
// Retrieving Maps server handler
MapsServerPtr mapsServer = MapsServerFactory::getInstance().make(mapsServerUri_, "GEOSERVER");
// removing from geoserver
mapsServer->cleanup(viewPtr, inputDataProvider, logger_);
}
catch(const terrama2::services::view::core::NotFoundGeoserverException& e)
{
// Nothing
TERRAMA2_LOG_DEBUG() << tr("There is no workspace in GeoServer");
}
catch(const terrama2::services::view::core::ViewGeoserverException&)
{
// TODO: Improve validation in order to notify WebApp
TERRAMA2_LOG_WARNING() << tr("Could not perform clean up in GeoServer and database. Please remove it manually");
}
}
waitQueue_.erase(id);
TERRAMA2_LOG_INFO() << tr("View %1 removed successfully.").arg(id);
}
catch(const boost::exception& e)
{
TERRAMA2_LOG_ERROR() << boost::get_error_info<terrama2::ErrorDescription>(e);
TERRAMA2_LOG_INFO() << tr("Could not remove view: %1.").arg(id);
}
catch(const std::exception& e)
{
TERRAMA2_LOG_ERROR() << e.what();
TERRAMA2_LOG_INFO() << tr("Could not remove view: %1.").arg(id);
}
catch(...)
{
TERRAMA2_LOG_ERROR() << tr("Unknown error");
TERRAMA2_LOG_INFO() << tr("Could not remove view: %1.").arg(id);
}
}
void terrama2::services::view::core::Service::viewJob(const terrama2::core::ExecutionPackage& executionPackage,
std::shared_ptr<ViewLogger> logger,
std::weak_ptr<DataManager> weakDataManager)
{
auto dataManager = weakDataManager.lock();
if(!dataManager.get())
{
TERRAMA2_LOG_ERROR() << QObject::tr("Unable to access DataManager");
notifyWaitQueue(executionPackage.processId);
sendProcessFinishedSignal(executionPackage.processId, executionPackage.executionDate, false);
return;
}
RegisterId logId = executionPackage.registerId;
ViewId viewId = executionPackage.processId;
std::string viewName = "";
QJsonObject jsonAnswer;
try
{
TERRAMA2_LOG_DEBUG() << QObject::tr("Starting view %1 generation.").arg(viewId);
auto mapsServer = MapsServerFactory::getInstance().make(mapsServerUri_, "GEOSERVER");
/////////////////////////////////////////////////////////////////////////
// aquiring metadata
auto lock = dataManager->getLock();
auto viewPtr = dataManager->findView(viewId);
viewName = viewPtr->viewName;
terrama2::core::DataSeriesPtr inputDataSeries = dataManager->findDataSeries(viewPtr->dataSeriesID);
terrama2::core::DataProviderPtr inputDataProvider = dataManager->findDataProvider(inputDataSeries->dataProviderId);
lock.unlock();
/////////////////////////////////////////////////////////////////////////
auto processingStartTime = terrama2::core::TimeUtils::nowUTC();
QJsonObject mapsServerAnswer = mapsServer->generateLayers(viewPtr,
inputDataSeries,
inputDataProvider,
dataManager,
logger,
logId);
TERRAMA2_LOG_INFO() << tr("View %1(%2) generated successfully.").arg(QString::fromStdString(viewName)).arg(viewId);
auto processingEndTime = terrama2::core::TimeUtils::nowUTC();
logger->setStartProcessingTime(processingStartTime, executionPackage.registerId);
logger->setEndProcessingTime(processingEndTime, executionPackage.registerId);
logger->result(ViewLogger::Status::DONE, terrama2::core::TimeUtils::nowUTC(), logId);
jsonAnswer = mapsServerAnswer;
jsonAnswer.insert("class", QString("RegisteredViews"));
jsonAnswer.insert("process_id",static_cast<int32_t>(viewPtr->id));
jsonAnswer.insert("maps_server", QString::fromStdString(mapsServerUri_.uri()));
sendProcessFinishedSignal(viewId, executionPackage.executionDate, true, jsonAnswer);
notifyWaitQueue(viewId);
return;
}
catch(const terrama2::core::LogException& e)
{
auto error = boost::get_error_info<terrama2::ErrorDescription>(e);
std::string errMsg;
if(error)
{
errMsg = error->toStdString();
TERRAMA2_LOG_ERROR() << errMsg;
}
else
{
TERRAMA2_LOG_ERROR() << QObject::tr("Error logging view build error.");
}
TERRAMA2_LOG_INFO() << QObject::tr("Build of view %1(%2) finished with error(s).").arg(QString::fromStdString(viewName)).arg(viewId);
}
catch(const terrama2::Exception& e)
{
auto error = boost::get_error_info<terrama2::ErrorDescription>(e);
std::string errMsg;
if(error)
{
errMsg = error->toStdString();
TERRAMA2_LOG_ERROR() << errMsg;
}
else
{
TERRAMA2_LOG_ERROR() << QObject::tr("Error logging view build error.");
}
TERRAMA2_LOG_INFO() << QObject::tr("Build of view %1(%2) finished with error(s).").arg(QString::fromStdString(viewName)).arg(viewId);
if(logId != 0)
logger->log(ViewLogger::MessageType::ERROR_MESSAGE, errMsg, logId);
}
catch(const boost::exception& e)
{
auto error = boost::get_error_info<terrama2::ErrorDescription>(e);
std::string errMsg;
if(error)
{
errMsg = error->toStdString();
TERRAMA2_LOG_ERROR() << errMsg;
}
else
{
TERRAMA2_LOG_ERROR() << QObject::tr("Error logging view build error.");
}
TERRAMA2_LOG_INFO() << QObject::tr("Build of view %1(%2) finished with error(s).").arg(QString::fromStdString(viewName)).arg(viewId);
if(logId != 0)
logger->log(ViewLogger::MessageType::ERROR_MESSAGE, errMsg, logId);
}
catch(const std::exception& e)
{
std::string errMsg = e.what();
TERRAMA2_LOG_ERROR() << errMsg;
TERRAMA2_LOG_INFO() << QObject::tr("Build of view %1(%2) finished with error(s).").arg(QString::fromStdString(viewName)).arg(viewId);
if(logId != 0)
logger->log(ViewLogger::MessageType::ERROR_MESSAGE, errMsg, logId);
}
catch(...)
{
std::string errMsg = "Unknown error.";
TERRAMA2_LOG_ERROR() << QObject::tr("Unknown error.");
TERRAMA2_LOG_INFO() << QObject::tr("Build of view %1(%2) finished with error(s).").arg(QString::fromStdString(viewName)).arg(viewId);
if(logId != 0)
logger->log(ViewLogger::MessageType::ERROR_MESSAGE, errMsg, logId);
}
if(logId != 0)
logger->result(ViewLogger::Status::ERROR, terrama2::core::TimeUtils::nowUTC(), logId);
sendProcessFinishedSignal(viewId, executionPackage.executionDate, false);
notifyWaitQueue(viewId);
}
int main(int argc, char* argv[])
{
try
{
std::string appName = boost::filesystem::basename(argv[0]);
po::options_description desc("Allowed options");
desc.add_options()
("help,h", "show help message.")
("version,v", "Show TerraMA2 version.")
("service,s", po::value<std::string>()->required(), "Service to be started.\nValid options:\n\t- ANALYSIS\n\t- COLLECTOR\n\t- VIEW")
("port,p", po::value<int>()->required(), "Port the service will listen.")
;
po::positional_options_description positionalOptions;
positionalOptions.add("service", 1);
positionalOptions.add("port", 1);
po::variables_map vm;
po::store(po::command_line_parser(argc, argv).options(desc)
.positional(positionalOptions).run(),
vm);
if (vm.count("help")) {
std::cout << "usage: "+appName+" [--version] [--help] service port" << "\n";
std::cout << desc << std::endl;
return 0;
}
if (vm.count("version")) {
std::cout << "TerraMA2 " << TERRAMA2_VERSION_STRING << std::endl;
return 0;
}
po::notify(vm);
std::string serviceType(vm["service"].as<std::string>());
std::transform(serviceType.begin(), serviceType.end(), serviceType.begin(), ::tolower);
if(!checkServiceType(serviceType))
return UNKNOWN_SERVICE_TYPE;
int listeningPort = vm["port"].as<int>();
terrama2::core::TerraMA2Init terramaRaii(serviceType, listeningPort);
terrama2::core::registerFactories();
auto& serviceManager = terrama2::core::ServiceManager::getInstance();
serviceManager.setServiceType(serviceType);
serviceManager.setListeningPort(listeningPort);
// service context
// this is needed for calling the destructor of the service before finalizing terralib
{
TERRAMA2_LOG_INFO() << QObject::tr("Initializing TerraMA2 service...");
TERRAMA2_LOG_INFO() << QObject::tr("Starting %1 service.").arg(QString::fromStdString(serviceType));
// Must initialize the python interpreter before creating any thread.
terrama2::services::analysis::core::PythonInterpreterInit pythonInterpreterInit;
QCoreApplication app(argc, argv);
// Changes in the initialization order may cause locale problems
std::locale::global(std::locale::classic());
std::shared_ptr<terrama2::core::DataManager> dataManager;
std::shared_ptr<terrama2::core::Service> service;
std::shared_ptr<terrama2::core::ProcessLogger> logger;
std::tie(dataManager, service, logger) = createService(serviceType);
if(!service.get()
|| !dataManager.get()
|| !logger.get())
return SERVICE_LOAD_ERROR;
auto tcpManager = std::make_shared<terrama2::core::TcpManager>(dataManager, logger);
if(!tcpManager->listen(QHostAddress::Any, serviceManager.listeningPort()))
{
std::cerr << QObject::tr("\nUnable to listen to port: ").toStdString() << serviceManager.listeningPort() << "\n" << std::endl;
exit(TCP_SERVER_ERROR);
}
QObject::connect(&serviceManager, &terrama2::core::ServiceManager::listeningPortUpdated, tcpManager.get(), &terrama2::core::TcpManager::updateListeningPort);
QObject::connect(tcpManager.get(), &terrama2::core::TcpManager::startProcess, service.get(), &terrama2::core::Service::addToQueue);
QObject::connect(&serviceManager, &terrama2::core::ServiceManager::numberOfThreadsUpdated, service.get(), &terrama2::core::Service::updateNumberOfThreads);
QObject::connect(&serviceManager, &terrama2::core::ServiceManager::logConnectionInfoUpdated, logger.get(), &terrama2::core::ProcessLogger::setConnectionInfo);
QObject::connect(service.get(), &terrama2::core::Service::processFinishedSignal, tcpManager.get(), &terrama2::core::TcpManager::processFinishedSlot);
QObject::connect(tcpManager.get(), &terrama2::core::TcpManager::stopSignal, service.get(), &terrama2::core::Service::stopService);
QObject::connect(service.get(), &terrama2::core::Service::serviceFinishedSignal, &app, &QCoreApplication::quit);
app.exec();
}
try
{
//Service closed by load error
if(!serviceManager.serviceLoaded())
return SERVICE_LOAD_ERROR;
}
catch(...)
{
return TERRAMA2_FINALIZATION_ERROR;
}
}
catch(boost::program_options::error& e)
{
std::cout << "Invalid options.See 'terrama2_service --help'\n" << std::endl;
TERRAMA2_LOG_ERROR() << e.what();
}
catch(boost::exception& e)
{
TERRAMA2_LOG_ERROR() << boost::diagnostic_information(e);
}
catch(std::exception& e)
{
TERRAMA2_LOG_ERROR() << e.what();
}
catch(...)
{
TERRAMA2_LOG_ERROR() << QObject::tr("\n\nUnknown Exception...\n");
}
return 0;
}
