runTestService.cpp

/*
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/>.
*/




// Autogenerated by MermaidLoaderGenerator

//system includes
#include <iostream>
#include <vector>

#include <signal.h>
#include <argp.h>

//MeRMaID includes
#include <ActiveObject.hpp>
#include <ActiveObjectAce.hpp>
#include <ActiveObjectManager.hpp>
#include <ActiveObjectManagerAce.hpp>
#include <CommunicationGateway.hpp>


#include <DataFactory.hpp>
#include <EntityDescriptionFactory.hpp>
#include <EntityDescriptionRepository.hpp>
#include <EntityRepository.hpp>
#include <FilePathSearch.hpp>
#include <Service.hpp>
#include <ServiceBuildTask.hpp>
#include <ServiceConfiguration.hpp>
#include <ServiceTypeDescriptionFactory.hpp>
#include <ServiceTypeDescriptionRepository.hpp>
#include <Time.hpp>
#include <XmlDocument.hpp>
#include <XmlElement.hpp>

// Service Includes
#include "TestService.hpp"

//system using directives
using std::cout;
using std::endl;

//mermaid using directives
using mermaid::support::activeobject::ActiveObject;
using mermaid::support::activeobject::ActiveObjectAce;
using mermaid::support::activeobject::ActiveObjectManager;
using mermaid::support::activeobject::ActiveObjectManagerAce;
using mermaid::support::activeobject::Task;
using mermaid::support::communication::CommunicationGateway;
using mermaid::support::data::DataFactory;
using boost::shared_ptr;

using mermaid::support::service::EntityDescriptionFactory;
using mermaid::support::service::EntityDescriptionRepository;
using mermaid::support::service::EntityRepository;
using mermaid::support::service::Service;
using mermaid::support::service::ServiceBuildTask;
using mermaid::support::service::ServiceConfiguration;
using mermaid::support::service::ServiceTypeDescriptionFactory;
using mermaid::support::service::ServiceTypeDescriptionRepository;
using mermaid::support::service::ServiceRequest;
using mermaid::support::system::Time;
using mermaid::support::system::FilePathSearch;
using mermaid::support::xml::XmlDocument;
using mermaid::support::xml::XmlElement;

// Service uses


std::vector<std::string> dataDescriptionVector;
std::vector<std::string> entityDescriptionVector;
std::vector<std::string> pathVector;
std::vector<std::string> serviceDescriptionVector;

shared_ptr<ActiveObject> ioActiveObject;

void exit_program (int sig)
{
  //disable signal
  //signal(SIGINT, SIG_IGN);
  
  std::cerr << "Catched SIGINT..." << std::endl;
  std::cerr << "\tnumber of running Active Objects: " << ActiveObjectManagerAce::getInstance()->getNumberOfActiveObjects() << std::endl;
  std::cerr << "\tshutting down ActiveObjects..." << std::endl;
  ActiveObjectManagerAce::getInstance()->stopAllActiveObjects();
  std::cerr << "\tnumber of running Active Objects: " << ActiveObjectManagerAce::getInstance()->getNumberOfActiveObjects() << std::endl;
  std::cerr << "\tShutdown procedure finished." << std::endl;
}

static error_t parse_opt (int key, char *arg, struct argp_state *state)
{
  //struct arguments *arguments = state->input;
  
  switch (key) {
    case 'd': {
      /*std::cout << "Loading data type description file specified in command-line: " << arg << std::endl;
      shared_ptr<XmlDocument>  dataDoc = shared_ptr<XmlDocument>(new XmlDocument());
      dataDoc->parseFile(std::string(arg));
      DataFactory::loadDataDescription(dataDoc);*/
      dataDescriptionVector.push_back (std::string (arg));
      break;
    }
    case 'e': {
      /*std::cout << "Loading entity description file specified in command-line: " << arg << std::endl;
      shared_ptr<XmlDocument> entDoc = shared_ptr<XmlDocument>(new XmlDocument());
      entDoc->parseFile(std::string(arg));
      shared_ptr<XmlElement> entityDescriptionList = entDoc->getRootElement();
      shared_ptr<ServiceTypeDescriptionRepository> serviceTypeDescriptionRepository = ServiceTypeDescriptionRepository::getInstance();
      shared_ptr<EntityDescriptionRepository> entityDescriptionRepository = EntityDescriptionRepository::getInstance();
      EntityDescriptionFactory::populateEntityDescriptionRepository(entityDescriptionRepository, entityDescriptionList, serviceTypeDescriptionRepository);*/
      entityDescriptionVector.push_back (std::string (arg));
      break;
    }
    case 'p': {
      /*std::cout << "Adding search path: " << arg << std::endl;
      FilePathSearch::addSearchPath(std::string(arg));*/
      pathVector.push_back (std::string (arg));
      break;
    }
    case 's': {
      /*std::cout << "Loading service type description file specified in command-line: " << arg << std::endl;
      shared_ptr<XmlDocument> docServiceType = shared_ptr<XmlDocument>(new XmlDocument());
        docServiceType->parseFile(std::string(arg));
        shared_ptr<XmlElement> serviceTypeDescriptionList = docServiceType->getRootElement();
        shared_ptr<ServiceTypeDescriptionRepository> serviceTypeDescriptionRepository = ServiceTypeDescriptionRepository::getInstance();
        ServiceTypeDescriptionFactory::populateServiceTypeDescriptionRepository(serviceTypeDescriptionRepository, serviceTypeDescriptionList);*/
      serviceDescriptionVector.push_back (std::string (arg));
      break;
    }
    default:
      //std::cout << "parse_opt : default" << std::endl;
      return ARGP_ERR_UNKNOWN;
  }
  return 0;
}; // parse_opt()

const char *argp_program_version = "Built with mlgen (MeRMaID Loader Generator)";
const char *argp_program_bug_address = "<mafb@isr.ist.utl.pt>";

int main (int argc, char *argv[])
{
  signal (SIGINT, &exit_program);
  
  static struct argp_option options[] = {
    {"entity-description", 'e', "file", 0, "Define Entity Description file to load"},
    {"service-type-description", 's', "file", 0, "Define Service Type Description file to load"},
    {"data-type-description", 'd', "file", 0, "Define Data Type Description file to load"},
    {"search-path", 'p', "path", 0, "Define search path where to look for files"},
    {0}
  };
  
  //static char args_doc[] = 0;
  
  static char doc[] = "Deploys MeRMaID services";
  
  static struct argp argp = {options, parse_opt, 0, doc};
  
  
  // parse command line arguments/options
  argp_parse (&argp, argc, argv, 0, 0, 0);
  
  //Setting file search paths
  pathVector.push_back ("/opt/mermaid/config");
  pathVector.push_back ("./");
  pathVector.push_back ("./"); //Default file search path
  
  // Create ActiveObjects
  ioActiveObject = ActiveObjectManagerAce::getInstance()->createActiveObject();
  
  // ActiveObjects start
  ioActiveObject->start();
  
  
  // Wait for ActiveObjects to stop
  ActiveObjectManagerAce::getInstance()->waitForActiveObjectsToStop();
  
  return 0;
}; // main

void setupServiceA (char dataDescFile[], char serviceTypeDescFile[], char entityDescFile[], char configFile[], char serviceName[])
{
  //Load data description files
  //Loading default data description files
  dataDescriptionVector.push_back ("ping-tool-data-description-file.xml");
  //loading io-test-read-data-description-file.xml
  dataDescriptionVector.push_back (dataDescFile);
  
  //Load service type description files
  
  //Loading default service type description files
  serviceDescriptionVector.push_back ("ping-tool-service-type-description-file.xml");
  //loading io-test-read-service-type-description-file.xml
  serviceDescriptionVector.push_back (serviceTypeDescFile);
  
  //Load entity description files
  //loading io-test-read-entity-description-file.xml
  entityDescriptionVector.push_back (entityDescFile);   //setup search paths
  std::vector<std::string>::iterator pathIterator;
  for (pathIterator = pathVector.begin(); pathIterator != pathVector.end(); ++pathIterator) {
    std::string path = *pathIterator;
    std::cerr << "Loading path: " << path << std::endl;
    FilePathSearch::addSearchPath (path);
  }
  //load data descriptions
  std::vector<std::string>::iterator dataDescriptionIterator;
  for (dataDescriptionIterator = dataDescriptionVector.begin(); dataDescriptionIterator != dataDescriptionVector.end(); ++dataDescriptionIterator) {
    std::string dataDescriptionFile = *dataDescriptionIterator;
    std::cerr << "Loading data type description file: " << dataDescriptionFile << std::endl;
    shared_ptr<XmlDocument>  dataDoc = shared_ptr<XmlDocument> (new XmlDocument());
    dataDoc->parseFile (dataDescriptionFile);
    DataFactory::loadDataDescription (dataDoc);
  }
  //load service type descriptions
  std::vector<std::string>::iterator serviceDescriptionIterator;
  for (serviceDescriptionIterator = serviceDescriptionVector.begin(); serviceDescriptionIterator != serviceDescriptionVector.end(); ++serviceDescriptionIterator) {
    std::string serviceDescriptionFile = *serviceDescriptionIterator;
    std::cerr << "Loading service type description file: " << serviceDescriptionFile << std::endl;
    shared_ptr<XmlDocument> docServiceType = shared_ptr<XmlDocument> (new XmlDocument());
    docServiceType->parseFile (serviceDescriptionFile);
    shared_ptr<XmlElement> serviceTypeDescriptionList = docServiceType->getRootElement();
    shared_ptr<ServiceTypeDescriptionRepository> serviceTypeDescriptionRepository = ServiceTypeDescriptionRepository::getInstance();
    ServiceTypeDescriptionFactory::populateServiceTypeDescriptionRepository (serviceTypeDescriptionRepository, serviceTypeDescriptionList);
  }
  //load entity descriptions
  std::vector<std::string>::iterator entityDescriptionIterator;
  for (entityDescriptionIterator = entityDescriptionVector.begin(); entityDescriptionIterator != entityDescriptionVector.end(); ++entityDescriptionIterator) {
    std::string entityDescriptionFile = *entityDescriptionIterator;
    std::cerr << "Loading entity type description file: " << entityDescriptionFile << std::endl;
    shared_ptr<XmlDocument> docEntityDescription = shared_ptr<XmlDocument> (new XmlDocument());
    docEntityDescription->parseFile (entityDescriptionFile);
    shared_ptr<XmlElement> entityDescriptionList = docEntityDescription->getRootElement();
    shared_ptr<EntityDescriptionRepository> entityDescriptionRepository = EntityDescriptionRepository::getInstance();
    shared_ptr<ServiceTypeDescriptionRepository> serviceTypeDescriptionRepository = ServiceTypeDescriptionRepository::getInstance();
    EntityDescriptionFactory::populateEntityDescriptionRepository (entityDescriptionRepository, entityDescriptionList, serviceTypeDescriptionRepository);
  }
  
  // Create entity repository
  shared_ptr<EntityRepository> aoEntityRepository (new EntityRepository());
  
  // Create Services
  {
    shared_ptr<XmlDocument> serviceConfigurationDocument (new XmlDocument());
    serviceConfigurationDocument->parseFile (configFile);
    shared_ptr<ServiceConfiguration> serviceConfiguration (new ServiceConfiguration (serviceConfigurationDocument));
    shared_ptr<Task> buildTestService ( (Task*) new ServiceBuildTask<TestService> (ioActiveObject, aoEntityRepository, "MyComputer", serviceName, serviceConfiguration));
    ioActiveObject->addTask (buildTestService);
  }
}
// EOF