Service.cpp

Go to the documentation of this file.

/*
Copyright 2007, 2008, 2009, 2010, 2011 Instituto de Sistemas e Robotica, Instituto Superior Tecnico

This file is part of MeRMaID.

MeRMaID is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

MeRMaID is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with MeRMaID.  If not, see <http://www.gnu.org/licenses/>.
*/



/**
 * @Filename Service.cpp
 * @Description Support Service implementation
 * @Status Work in Progress
 * @Version $Id: Service.cpp 1 2011-03-04 18:13:18Z jreis $
 * @Maintainer Marco Barbosa
 */


#include "config.h"

#include "Service.hpp"
#include "DataFeed.hpp"
#include "DataFeedDescription.hpp"
#include "Entity.hpp"
#include "EntityDescription.hpp"
#include "ServiceInterface.hpp"
#include "ServiceInterfaceDescription.hpp"
#include "ServiceTypeDescriptionFactory.hpp"
#include "ServiceUpdateTask.hpp"
#include "Exceptions/ServiceRequestFailedException.hpp"

#include <CommunicationGateway.hpp>
#include <DataValueVector.hpp>
#include <Exception.hpp>
#include <DataFactory.hpp>
#include <YarpDataFeedSetupTask.hpp>

#include <sstream>

using namespace mermaid::support::service;

using mermaid::support::communication::CommunicationGateway;
using mermaid::support::data::DataFactory;
using mermaid::support::data::DataValueVector;
using mermaid::support::data::String;
using mermaid::support::errorhandling::Exception;

using mermaid::support::logging::FastLogger;

#ifdef USE_COMM
using mermaid::support::communication::YarpDataFeedSetupTask;
#endif

#include <iostream>

shared_ptr<ServiceTypeDescriptionRepository> Service::serviceTypeDescriptionRepository_ = shared_ptr<ServiceTypeDescriptionRepository>();

Service::Service (shared_ptr<ActiveObject> ao, shared_ptr<Entity> entity, shared_ptr<ServiceInstanceDescription> serviceInstanceDescription, shared_ptr<ServiceConfiguration> serviceConfiguration)
{
  activeObject_ = ao;
  entity_ = entity;
  serviceInstanceDescription_ = serviceInstanceDescription;
  serviceConfiguration_ = serviceConfiguration;
  
  float updateFreq = serviceConfiguration->getServiceUpdateFrequency();
  if (updateFreq != 0.0) {
    shared_ptr<Task> serviceUpdateTask (new ServiceUpdateTask (this));
    activeObject_->addTask (serviceUpdateTask);
  }
  
  lastRequestId_ = 0;
  
  logger_ = FastLogger::build (serviceInstanceDescription_->getServiceInstanceName());
  debugLogger_ = FastLogger::build (serviceInstanceDescription_->getServiceInstanceName() + " DEBUG");
}; // Service()


Service::~Service()
{
//  std::cerr << "Service::~Service()" << std::endl;
};


void Service::update()
{
  //std::cerr << "Service::update()" << std::endl;
}; // update()

void Service::processServiceRequest (shared_ptr<ServiceRequest> request)
{
  std::string requesterEntityName = request->getRequesterEntityName();
  std::string requesterServiceName = request->getRequesterServiceName();
  std::string targetEntityName = request->getTargetEntityName();
  std::string targetServiceName = request->getTargetServiceName();
  std::string targetServiceInterfaceName = request->getTargetServiceInterfaceName();
  //int requestId = request->getRequestId();
  shared_ptr<Service> targetService = entity_->getService (serviceInstanceDescription_->getServiceInstanceName());
  
  /*std::cerr << "Service::processServiceRequest" << std::endl;
  std::cerr << "\trequesterEntityName:\t" << requesterEntityName << std::endl;
  std::cerr << "\trequesterServiceName:\t" << requesterServiceName << std::endl;
  std::cerr << "\ttargetEntityName:\t" << targetEntityName << std::endl;
  std::cerr << "\ttargetServiceName:\t" << targetServiceName << std::endl;
  std::cerr << "\ttargetServiceInterfaceName:\t" << targetServiceInterfaceName << std::endl;
  std::cerr << "\trequestId:\t" << requestId << std::endl;*/
  
  
  // process the request
  try {
  
    //std::cerr << "\tgetServiceInterface" << std::endl;
    shared_ptr<ServiceInterface> si = getServiceInterface (targetServiceInterfaceName);
    
    if (si == false) {
      throw Exception ("Service::processServiceRequest : unknown Service Interface name: " + targetServiceInterfaceName);
    }
    
    //std::cerr << "\tprocessServiceRequest" << std::endl;
    shared_ptr<ServiceReply> reply = si->processServiceRequest (request);
    
    activeObject_->getCommunicationGateway()->sendServiceReply (targetService, requesterEntityName, requesterServiceName, reply);
    
  } // try
  catch (Exception &e) {
    std::cerr << "Service::processServiceRequest : caught an Exception while processing a Service Request : " << e.what() << std::endl;
    shared_ptr<ServiceReply> errorReply (new ServiceReply (request, e.what()));
    
    activeObject_->getCommunicationGateway()->sendServiceReply (targetService, requesterEntityName, requesterServiceName, errorReply);
    throw e;
  }
  catch (...) {
    std::cerr << "Service::processServiceRequest : caught an unknown exception while processing a Service Request " << std::endl;
    shared_ptr<ServiceReply> errorReply (new ServiceReply (request, "Unknown error."));
    
    activeObject_->getCommunicationGateway()->sendServiceReply (targetService, requesterEntityName, requesterServiceName, errorReply);
    throw Exception ("Service::processServiceRequest : caught an unknown exception");
  }
}; // processServiceRequest()


void Service::processServiceReply (shared_ptr<ServiceReply> reply)
{
  //std::cerr << "Service::processServiceReply" << std::endl;
  //std::cerr << "\trequestId:\t" << reply->getRequestId() << std::endl;
  
  int requestId = reply->getRequestId();
  
  if (replyHandlerMap_.count (requestId) == 0) {
    std::cerr << "Service::processServiceReply : no handler for request with id: " << requestId << std::endl;;
  }
  else {
    shared_ptr<ServiceReplyHandlerMethodBase> h = replyHandlerMap_[requestId];
    if (h) {
      h->callHandler (reply);
    }
    else {
      std::cerr << "Service::processServiceReply : no handler for request with id: " << requestId << std::endl;;
    }
  }
  
  //unregister the original request
  unregisterOutgoingServiceRequest (requestId);
}; // processServiceReply()


void Service::processDataFeedInput (std::string producerEntityName, std::string producerServiceName, std::string dataFeedName, shared_ptr<DataBox> dataBox)
{
//     std::cerr << "Service::processDataFeedInput()" << std::endl;
  shared_ptr<DataFeedInputHandlerMethodBase> method = getDataFeedInputHandlerMethod (producerEntityName, producerServiceName, dataFeedName);
  method->callHandler (dataBox);
}; // processDataFeedInput()

void Service::addServiceInterface (shared_ptr<ServiceInterface> serviceInterface)
{
  std::string serviceInterfaceName = serviceInterface->getServiceInterfaceDescription()->getServiceInterfaceName();
  
  //std::cerr << "Service::addServiceInterface : serviceName=\"" << serviceInstanceDescription_->getServiceInstanceName() << "\", interfaceName=\"" << serviceInterfaceName << "\"" << std::endl;
  
  if (serviceInterfaceMap_.find (serviceInterfaceName) != serviceInterfaceMap_.end()) {
    std::stringstream ss;
    ss << "Service::addServiceInterface : Service with serviceInstanceName=\"" << serviceInstanceDescription_->getServiceInstanceName() << "\" already has a ServiceInterface with serviceInterfaceName=\"" << serviceInterfaceName << "\"";
    throw Exception (ss.str());
  }
  
  serviceInterfaceMap_[serviceInterfaceName] = serviceInterface;
}; // addServiceInterface()

shared_ptr<ServiceInterface> Service::getServiceInterface (std::string serviceInterfaceName)
{
  shared_ptr<ServiceInterface> si = serviceInterfaceMap_[serviceInterfaceName];
  
  if (si == false) {
    std::stringstream ss;
    ss << "Service::getServiceInterface : Service with serviceInstanceName=\"" << serviceInstanceDescription_->getServiceInstanceName() << "\" does not have a ServiceInterface with serviceInterfaceName=\"" << serviceInterfaceName << "\"";
    throw Exception (ss.str());
  }
  
  return si;
}; // getServiceInterface()

void Service::registerServiceInterfaceHandlerMethod (std::string serviceInterfaceName, shared_ptr<ServiceInterfaceHandlerMethodBase> handlerMethod)
{
  //std::cerr << "Service::registerServiceRequestHandler(serviceName=" << serviceName << " handler=" << handler << ")" << std::endl;
  
  shared_ptr<ServiceInterface> si = getServiceInterface (serviceInterfaceName);
  
  if (si) {
    si->setHandlerMethod (handlerMethod);
  }
  else {
    throw Exception ("Service::registerServiceInterfaceHandler : no interface for name: " + serviceInterfaceName);
  }
}; // registerServiceInterfaceHandler()

std::vector<shared_ptr<ServiceTypeDescription> > Service::getServiceTypeDescriptions()
{
  return serviceInstanceDescription_->getServiceTypeDescriptions();
}; // getServiceDescription()

shared_ptr<ServiceInstanceDescription> Service::getServiceInstanceDescription()
{
  return serviceInstanceDescription_;
}; // getServiceInstanceDescription()

shared_ptr<ServiceConfiguration> Service::getServiceConfiguration()
{
  return serviceConfiguration_;
}; // getServiceConfiguration()

shared_ptr<Entity> Service::getEntity()
{
  return entity_;
}; // getEntity()

shared_ptr<ActiveObject> Service::getActiveObject()
{
  return activeObject_;
}; // getActiveObject()


shared_ptr<ServiceRequest> Service::makeNewServiceRequest (std::string targetEntitytName, std::string targetServiceName, std::string targetServiceInterfaceName)
{
  //std::cerr << "Service::makeNewServiceRequest(entitytName=" << targetEntitytName << ", servicName=" << targetServiceName << ", interfaceName=" << targetServiceInterfaceName << ")" << std::endl;
  
  
  //throw Exception("Service::makeNewServiceRequest : not implemented");
  
  shared_ptr<ServiceRequest> sr (new ServiceRequest (entity_->getEntityDescription()->getEntityName(), serviceInstanceDescription_->getServiceInstanceName(), targetEntitytName, targetServiceName, targetServiceInterfaceName, ++lastRequestId_));
  
  return sr;
  
}; // makeNewServiceRequest()

void Service::sendServiceRequest (shared_ptr<ServiceRequest> sr, shared_ptr<ServiceReplyHandlerMethodBase> replyHandlerMethod)
{
  //std::cerr << "Service::sendServiceRequest(ServiceRequest=" << sr.get() << ")" << std::endl;
  
  if (!replyHandlerMethod) {
    replyHandlerMethod = shared_ptr<ServiceReplyHandlerMethodBase> (new ServiceReplyHandlerMethod<Service> (this, &Service::dummyHandler));
  }
  
  try {
    int requestId = sr->getRequestId();
    
    replyHandlerMap_[requestId] = replyHandlerMethod;
    
    shared_ptr<CommunicationGateway> commGateWay = activeObject_->getCommunicationGateway();
    
    std::string requesterServiceName = sr->getRequesterServiceName();
    
    shared_ptr<Service> requesterService = entity_->getService (serviceInstanceDescription_->getServiceInstanceName());
    registerOutgoingServiceRequest (sr);
    commGateWay->sendServiceRequest (requesterService, sr);
  }
  catch (Exception &e) {
    std::stringstream ss;
    ss << "Service Request Failed : ";
    ss << e.what();
    throw exceptions::ServiceRequestFailedException (ss.str());
  }
  
}; // sendServiceRequest()

void Service::addDataFeed (shared_ptr<DataFeed> dataFeed)
{
  std::string dataFeedName = dataFeed->getDataFeedDescription()->getDataFeedName();
  
  std::cerr << "Service::addDataFeed : dataFeedName=\"" << serviceInstanceDescription_->getServiceInstanceName() << "\", dataFeedName=\"" << dataFeedName << "\"" << std::endl;
  
  if (dataFeedMap_.find (dataFeedName) != dataFeedMap_.end()) {
    std::stringstream ss;
    ss << "Service::addDataFeed : Service with serviceInstanceName=\"" << serviceInstanceDescription_->getServiceInstanceName() << "\" already has a DataFeed with dataFeedName=\"" << dataFeedName << "\"";
    throw Exception (ss.str());
  }
  
  dataFeedMap_[dataFeedName] = dataFeed;
}; // addDataFeed()

shared_ptr<DataFeed> Service::getDataFeed (std::string dataFeedName)
{
  std::map<std::string, shared_ptr<DataFeed> >::iterator it = dataFeedMap_.find (dataFeedName);
  
  if (it == dataFeedMap_.end()) {
    std::stringstream ss;
    ss << "Service::getDataFeed : Service with serviceInstanceName=\"" << serviceInstanceDescription_->getServiceInstanceName() << "\" does not have a registered DataFeed with dataFeedName=\"" << dataFeedName << "\"";
    throw Exception (ss.str());
  };
  
  return (*it).second;
}; // getDataFeed()

shared_ptr<DataBox> Service::getDataBoxForDataFeed (std::string dataFeedName)
{
  shared_ptr<DataFeed> df = dataFeedMap_[dataFeedName];
  
  if (df == false) {
    std::stringstream ss;
    ss << "Service::getDataBoxForDataFeed : DataFeed with dataFeedName=\"" << dataFeedName << "\" is not registered.";
    throw Exception (ss.str());
  }
  
  return DataFactory::buildDataBox (df->getDataFeedDescription()->getDataFeedOutputDataName());
}; // getDataBoxForDataFeed()

void Service::sendToDataFeed (std::string dataFeedName, shared_ptr<DataBox> dataBox)
{
  shared_ptr<CommunicationGateway> commGateWay = activeObject_->getCommunicationGateway();
  std::string entityName = serviceInstanceDescription_->getEntityDescription()->getEntityName();
  std::string serviceName = serviceInstanceDescription_->getServiceInstanceName();
  commGateWay->sendToDataFeed (entityName, serviceName, dataFeedName, dataBox);
}; // sendToDataFeed()

void Service::registerDataFeedInputHandler (std::string producerEntityName, std::string producerServiceName, std::string dataFeedName, shared_ptr<DataFeedInputHandlerMethodBase> handlerMethod)
{
  std::cerr << "Service::registerDataFeedInputHandler(producerEntityName=\"" << producerEntityName << "\", producerServiceName=\"" << producerServiceName << "\", dataFeedName=\"" << dataFeedName << "\"" << std::endl;
  
  if (dataFeedInputHandlerMap_[producerEntityName][producerServiceName][dataFeedName]) {
    std::stringstream ss;
    ss << "Service::registerDataFeedInputHandler : Service with serviceInstanceName=\"" << serviceInstanceDescription_->getServiceInstanceName() << "\" already has a handler for the data feed with producerEntityName=\"" << producerEntityName << "\", producerServiceName=\"" << producerServiceName << "\", dataFeedName=\"" << dataFeedName << "\"";
    throw Exception (ss.str());
  }
  
  std::map<std::string, std::map<std::string, shared_ptr<DataFeedInputHandlerMethodBase> > > entityMap = dataFeedInputHandlerMap_[producerEntityName];
  std::map<std::string, shared_ptr<DataFeedInputHandlerMethodBase> > serviceMap = entityMap[producerServiceName];
  serviceMap[dataFeedName] = handlerMethod;
  entityMap[producerServiceName] = serviceMap;
  dataFeedInputHandlerMap_[producerEntityName] = entityMap;
  
  std::string consumerEntityName = entity_->getEntityDescription()->getEntityName();
  std::string consumerServiceName = serviceInstanceDescription_->getServiceInstanceName();
  
  shared_ptr<CommunicationGateway> commGateWay = getActiveObject()->getCommunicationGateway();
#ifdef USE_COMM
  shared_ptr<Task> setupTask (new YarpDataFeedSetupTask (entity_->getService (serviceInstanceDescription_->getServiceInstanceName()),
                              producerEntityName, producerServiceName, dataFeedName, getActiveObject()));
                              
//      activeObject_->addTask(setupTask);
  commGateWay->addDataFeedSetupTask (setupTask);
  
  if (commGateWay->isNewDataFeedSetupTaskAvailable()) {
    activeObject_->addTask (commGateWay->getDataFeedSetupTask());
  }
#endif
  commGateWay->connectToDataFeed (producerEntityName, producerServiceName, dataFeedName,
                                  entity_->getService (serviceInstanceDescription_->getServiceInstanceName()));
};

shared_ptr<DataFeedInputHandlerMethodBase> Service::getDataFeedInputHandlerMethod (std::string producerEntityName, std::string producerServiceName, std::string dataFeedName)
{
  std::map<std::string, shared_ptr<DataFeedInputHandlerMethodBase> > dataFeedMap = dataFeedInputHandlerMap_[producerEntityName][producerServiceName];
  
  if (dataFeedMap.find (dataFeedName) == dataFeedMap.end()) {
    std::stringstream ss;
    ss << "Service::getDataFeedName : Service with serviceInstanceName=\"" << serviceInstanceDescription_->getServiceInstanceName() << "\" already has a handler for the data feed with producerEntityName=\"" << producerEntityName << "\", producerServiceName=\"" << producerServiceName << "\", dataFeedName=\"" << dataFeedName << "\"";
    throw Exception (ss.str());
  }
  
  return dataFeedMap[dataFeedName];
}; // registerDataFeedInputHandler()

void Service::registerOutgoingServiceRequest (shared_ptr<ServiceRequest> sr)
{
  int reqId = sr->getRequestId();
  std::cerr << "Service::registerOutgoingServiceRequest : requestId=" << reqId << std::endl;
  if (outgoingRequestMap_.find (reqId) != (outgoingRequestMap_.end())) {
    std::stringstream ss;
    ss << "Service::registerOutgoingServiceRequest : ServiceRequest with id=" << reqId << " already registered";
    throw Exception (ss.str());
  }
  else {
    outgoingRequestMap_[reqId] = sr;
  }
};

void Service::unregisterOutgoingServiceRequest (int requestId)
{
  std::cerr << "Service::unregisterOutgoingServiceRequest : requestId=" << requestId << std::endl;
  
  if (outgoingRequestMap_.find (requestId) != (outgoingRequestMap_.end())) {
    outgoingRequestMap_.erase (requestId);
  }
  else {
    std::stringstream ss;
    ss << "Service::unregisterOutgoingServiceRequest : requestId=" << requestId << " not registered";
    throw Exception (ss.str());
    
  }
};