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



/**
 * @Filename LoaderGenerator.cpp
 * @Description Implementation of the UnitGenerator class for Ace-based mermaid implementation
 * @Status Implementing
 * @Version $Id: UnitGenerator.cpp 1 2011-03-04 18:13:18Z jreis $
 * @Maintainer Joao Carreira (joao.carreira@ist.utl.pt)
 */

#include "config.h"

#include "LoaderGenerator.hpp"

#include <fstream>
#include <iostream>
#include <string>
#include <sstream>
#include <algorithm>



#include <FilePathSearch.hpp>

#include <XmlDocument.hpp>
#include <XmlElement.hpp>
#include <XmlElementVector.hpp>
#include <UnitFlowConfiguration.hpp>

#include <DeploymentConfiguration.hpp>

using namespace mermaid::mermaidloader;

using std::cerr;
using std::cerr;
using std::endl;
using std::ofstream;
using std::string;
using std::stringstream;

using boost::shared_ptr;

using mermaid::support::system::FilePathSearch;

using mermaid::support::xml::XmlDocument;
using mermaid::support::xml::XmlElement;
using mermaid::support::xml::XmlElementVector;

using mermaid::support::unitgenerator::UnitFlowConfiguration;

#include <iostream>

int indent = 0;
std::string getIndent()
{
  stringstream s;
  for (int i = 0; i < indent; i++) {
    s << "    ";
  }
  return s.str();
}

int main (int argc, char **argv)
{

  if (argc < 3) {
    cerr << "MermaidLoader generator for ACE-based systems" << endl;
    cerr << "Usage:" << endl;
    cerr << argv[0] << " <configuration file> <flow-configuration-file> <output file> <search paths>" << endl;
    exit (1);
  }
  
  //add user-defined search paths
  for (int i = 4; i < (argc); i++) {
    FilePathSearch::addSearchPath (argv[i]);
  }
  
  //add default search paths
  FilePathSearch::addSearchPath ("./config");
  FilePathSearch::addSearchPath ("./build/config");
  FilePathSearch::addSearchPath ("./");
  char * mermaid_dir = getenv ("MERMAID_DIR");
  if (mermaid_dir != 0) {
    FilePathSearch::addSearchPath (string (mermaid_dir) + "/config");
  }
  
  FilePathSearch::addSearchPath ("/");
  
  //configuration variables
  string configFileName     = string (argv[1]);
  string flowConfigFileName = string (argv[2]);
  string outputFileName     = string (argv[3]);
  
  //open output file
  ofstream outputFile;
  outputFile.open (outputFileName.c_str());
  
  if (outputFile.is_open() == false) {
    cerr << "Failed to open file: \"" << outputFileName << "\"" << endl;
    exit (1);
  }
  
  shared_ptr<XmlDocument> configXmlDoc = shared_ptr<XmlDocument> (new XmlDocument());
  configXmlDoc->parseFile (configFileName);
  
  DeploymentConfiguration configuration;
  configuration.loadConfiguration (configXmlDoc);
  
  FileSearchPathList fspl = configuration.getFileSearchPathList();
  DataDescriptionFileList ddfl = configuration.getDataDescriptionFileList();
  ServiceTypeDescriptionFileList stdfl = configuration.getServiceTypeDescriptionFileList();
  EntityDescriptionFileList edfl = configuration.getEntityDescriptionFileList();
  ActiveObjectConfigurationNameMap aocnm = configuration.getActiveObjectConfigurationNameMap();
  ActiveObjectConfigurationServiceMap aocsm = configuration.getActiveObjectConfigurationServiceMap();
  ServiceDeploymentConfigurationNameMap scnm = configuration.getServiceDeploymentConfigurationNameMap();
  
  // build services flow configuration
  shared_ptr<XmlDocument> flowConfigXmlDoc = shared_ptr<XmlDocument> (new XmlDocument());
  flowConfigXmlDoc->parseFile (flowConfigFileName, false);
  UnitFlowConfiguration flowConfiguration;
  flowConfiguration.loadConfiguration (flowConfigXmlDoc);
  
  /*ActiveObjectConfigurationNameMap::iterator aocit;
  
  for (aocit = aocnm.begin(); aocit != aocnm.end(); aocit++)
  {
      std::string aoName = (*aocit).first;
      code << "ActiveObject name: " << aoName << endl;
  }*/
  
  
  // load XMl template file
  shared_ptr<XmlDocument> templateXmlDoc = shared_ptr<XmlDocument> (new XmlDocument());
  templateXmlDoc->parseFile ("unitgenerator-ace.xml", false);
  
  //build output file
  stringstream code;
  
  
  shared_ptr<XmlElement> templateRoot = templateXmlDoc->getRootElement();
  XmlElementVector templateChildren = templateRoot->getChildrenElements();
  shared_ptr<XmlElement> fileHeaderElement = templateChildren.getFirstElementWithName ("file-header");
  shared_ptr<XmlElement> includesElement = templateChildren.getFirstElementWithName ("includes");
  shared_ptr<XmlElement> serviceIncludeHeaderElement = templateChildren.getFirstElementWithName ("service-include-header");
  shared_ptr<XmlElement> serviceIncludeFooterElement = templateChildren.getFirstElementWithName ("service-include-footer");
  shared_ptr<XmlElement> usesElement = templateChildren.getFirstElementWithName ("uses");
  shared_ptr<XmlElement> serviceUsingHeaderElement = templateChildren.getFirstElementWithName ("service-using-header");
  shared_ptr<XmlElement> serviceUsingFooterElement = templateChildren.getFirstElementWithName ("service-using-footer");
  shared_ptr<XmlElement> mainHeaderElement = templateChildren.getFirstElementWithName ("main-header");
  shared_ptr<XmlElement> filePathHeaderElement = templateChildren.getFirstElementWithName ("file-path-header");
  shared_ptr<XmlElement> filePathFooterElement = templateChildren.getFirstElementWithName ("file-path-footer");
  shared_ptr<XmlElement> dataDescriptionLoadHeaderElement = templateChildren.getFirstElementWithName ("data-description-load-header");
  shared_ptr<XmlElement> dataDescriptionLoadFooterElement = templateChildren.getFirstElementWithName ("data-description-load-footer");
  shared_ptr<XmlElement> serviceTypeLoadHeaderElement = templateChildren.getFirstElementWithName ("service-type-load-header");
  shared_ptr<XmlElement> serviceTypeLoadFooterElement = templateChildren.getFirstElementWithName ("service-type-load-footer");
  shared_ptr<XmlElement> entityDescriptionLoadHeaderElement = templateChildren.getFirstElementWithName ("entity-description-load-header");
  shared_ptr<XmlElement> entityDescriptionLoadFooterElement = templateChildren.getFirstElementWithName ("entity-description-load-footer");
  shared_ptr<XmlElement> aoEntityRepositoryHeaderElement = templateChildren.getFirstElementWithName ("ao-entity-repository-header");
  shared_ptr<XmlElement> aoEntityRepositoryFooterElement = templateChildren.getFirstElementWithName ("ao-entity-repository-footer");
  shared_ptr<XmlElement> mainFooterElement = templateChildren.getFirstElementWithName ("main-footer");
  shared_ptr<XmlElement> fileFooterElement = templateChildren.getFirstElementWithName ("file-footer");
  
  //! @TODO All strings should be imported from the XML file.
  
  
  code << (string) (*fileHeaderElement->getFirstNonBlankCharData());
  code << (string) (*includesElement->getFirstNonBlankCharData());
  
  // Service includes
  {
    code << endl << getIndent() << "// Service Includes" << endl;
    
    ServiceDeploymentConfigurationNameMap::iterator siit;
    
    for (siit = scnm.begin(); siit != scnm.end(); siit++) {
      shared_ptr<ServiceDeploymentConfiguration> sc = (*siit).second;
      code << (string) (*serviceIncludeHeaderElement->getFirstNonBlankCharData());
      code << sc->getServiceHeaderFilename();
      code << (string) (*serviceIncludeFooterElement->getFirstNonBlankCharData());
    }
  }
  
  code << (string) (*usesElement->getFirstNonBlankCharData());
  
  // Services uses
  {
    code << endl << getIndent() << "// Service uses" << endl;
    
    ServiceDeploymentConfigurationNameMap::iterator siit;
    
    for (siit = scnm.begin(); siit != scnm.end(); siit++) {
      shared_ptr<ServiceDeploymentConfiguration> sc = (*siit).second;
      code << (string) (*serviceUsingHeaderElement->getFirstNonBlankCharData());
      code << sc->getServiceNamespace() << "::" << sc->getServiceClassName();
      code << (string) (*serviceUsingFooterElement->getFirstNonBlankCharData()) << std::endl;
    }
  }
  
  //main header
  code << (string) (*mainHeaderElement->getFirstNonBlankCharData());
  indent++;
  
  //set file search paths
  {
    FileSearchPathList::iterator fpit;
    
    code << endl << getIndent() << "//Setting file search paths" << endl;
    
    for (fpit = fspl.begin(); fpit != fspl.end(); fpit++) {
      std::string path = *fpit;
      code << getIndent() << (string) (*filePathHeaderElement->getFirstNonBlankCharData());
      code << path;
      code << (string) (*filePathFooterElement->getFirstNonBlankCharData()) << endl;
    }
    
    //set default path
    code << getIndent() << (string) (*filePathHeaderElement->getFirstNonBlankCharData());
    code << "./";
    code << (string) (*filePathFooterElement->getFirstNonBlankCharData()) << " //Default file search path" << endl;
  }
  
  //load data description files
  {
    DataDescriptionFileList::iterator ddit;
    vector<string> dddf;
    vector<string>::iterator sit;
    
    dddf.push_back ("ping-tool-data-description-file.xml");
#ifdef USE_COMM
    dddf.push_back ("comm-service-data-description-file.xml");
#endif
    
    code << endl << getIndent() << "//Load data description files" << endl;
    
    code << endl << getIndent() << "//Loading default data description files" << endl;
    for (sit = dddf.begin(); sit != dddf.end(); sit++) {
      code << getIndent() << (string) (*dataDescriptionLoadHeaderElement->getFirstNonBlankCharData());
      code << *sit;
      code << (string) (*dataDescriptionLoadFooterElement->getFirstNonBlankCharData()) << endl;
    }
    
    for (ddit = ddfl.begin(); ddit != ddfl.end(); ddit++) {
      std::string filename = *ddit;
      // only add a data description file if it hasn't been added yet
      if (std::find (dddf.begin(), dddf.end(), filename) == dddf.end()) {
        code << getIndent() << "//loading " << filename << endl;
        code << getIndent() << (string) (*dataDescriptionLoadHeaderElement->getFirstNonBlankCharData());
        code << filename;
        code << (string) (*dataDescriptionLoadFooterElement->getFirstNonBlankCharData()) << endl;
      }
    }
  }
  
  //load service type description files
  {
    ServiceTypeDescriptionFileList::iterator stit;
    vector<string> dsdf;
    vector<string>::iterator sit;
    
    dsdf.push_back ("ping-tool-service-type-description-file.xml");
#ifdef USE_COMM
    dsdf.push_back ("comm-service-type-description-file.xml");
#endif
    
    code << endl << getIndent() << "//Load service type description files" << endl;
    
    code << endl << getIndent() << "//Loading default service type description files" << endl;
    for (sit = dsdf.begin(); sit != dsdf.end(); sit++) {
      code << getIndent() << (string) (*serviceTypeLoadHeaderElement->getFirstNonBlankCharData());
      code << *sit;
      code << (string) (*serviceTypeLoadFooterElement->getFirstNonBlankCharData()) << endl;
    }
    
    for (stit = stdfl.begin(); stit != stdfl.end(); stit++) {
      std::string filename = *stit;
      // only add a service description file if it hasn't been added yet
      if (std::find (dsdf.begin(), dsdf.end(), filename) == dsdf.end()) {
        code << getIndent() << "//loading " << filename << endl;
        code << getIndent() << (string) (*serviceTypeLoadHeaderElement->getFirstNonBlankCharData());
        code << filename;
        code << (string) (*serviceTypeLoadFooterElement->getFirstNonBlankCharData()) << endl;
      }
    }
  }
  
  //load entity description files
  {
    EntityDescriptionFileList::iterator edit;
    
    code << endl << getIndent() << "//Load entity description files" << endl;
    
    for (edit = edfl.begin(); edit != edfl.end(); edit++) {
      std::string filename = *edit;
      code << getIndent() << "//loading " << filename << endl;
      code << getIndent() << (string) (*entityDescriptionLoadHeaderElement->getFirstNonBlankCharData());
      code << filename;
      code << (string) (*entityDescriptionLoadFooterElement->getFirstNonBlankCharData());
    }
  }
  
  //really load all description files
  //setup path
  
  code << getIndent() << "//setup search paths" << endl;
  code << getIndent() << "std::vector<std::string>::iterator pathIterator;" << endl;
  code << getIndent() << "for (pathIterator=pathVector.begin(); pathIterator!=pathVector.end(); pathIterator++)" << endl;
  code << getIndent() << "{" << endl;
  indent++;
  code << getIndent() << "std::string path = *pathIterator;" << endl;
  code << getIndent() << "std::cerr << \"Loading path: \" << path << std::endl;" << endl;
  code << getIndent() << "FilePathSearch::addSearchPath(path);" << endl;
  indent--;
  code << getIndent() << "}" << endl;
  
  //load data descriptions
  code << getIndent() << "//load data descriptions" << endl;
  code << getIndent() << "std::vector<std::string>::iterator dataDescriptionIterator;" << endl;
  code << getIndent() << "for (dataDescriptionIterator=dataDescriptionVector.begin(); dataDescriptionIterator!=dataDescriptionVector.end(); dataDescriptionIterator++)" << endl;
  code << getIndent() << "{" << endl;
  indent++;
  code << getIndent() << "std::string dataDescriptionFile = *dataDescriptionIterator;" << endl;
  code << getIndent() << "std::cerr << \"Loading data type description file: \" << dataDescriptionFile << std::endl;" << endl;
  code << getIndent() << "shared_ptr<XmlDocument>  dataDoc = shared_ptr<XmlDocument>(new XmlDocument());" << endl;
  code << getIndent() << "dataDoc->parseFile(dataDescriptionFile);" << endl;
  code << getIndent() << "DataFactory::loadDataDescription(dataDoc);" << endl;
  indent--;
  code << getIndent() << "}" << endl;
  
  //load service type descriptions
  code << getIndent() << "//load service type descriptions" << endl;
  code << getIndent() << "std::vector<std::string>::iterator serviceDescriptionIterator;" << endl;
  code << getIndent() << "for (serviceDescriptionIterator=serviceDescriptionVector.begin(); serviceDescriptionIterator!=serviceDescriptionVector.end(); serviceDescriptionIterator++)" << endl;
  code << getIndent() << "{" << endl;
  indent++;
  code << getIndent() << "std::string serviceDescriptionFile = *serviceDescriptionIterator;" << endl;
  code << getIndent() << "std::cerr << \"Loading service type description file: \" << serviceDescriptionFile << std::endl;" << endl;
  code << getIndent() << "shared_ptr<XmlDocument> docServiceType = shared_ptr<XmlDocument>(new XmlDocument());" << endl;
  code << getIndent() << "docServiceType->parseFile(serviceDescriptionFile);" << endl;
  code << getIndent() << "shared_ptr<XmlElement> serviceTypeDescriptionList = docServiceType->getRootElement();" << endl;
  code << getIndent() << "shared_ptr<ServiceTypeDescriptionRepository> serviceTypeDescriptionRepository = ServiceTypeDescriptionRepository::getInstance();" << endl;
  code << getIndent() << "ServiceTypeDescriptionFactory::populateServiceTypeDescriptionRepository(serviceTypeDescriptionRepository, serviceTypeDescriptionList);" << endl;
  indent--;
  code << getIndent() << "}" << endl;
  
  // load entity descriptions
  code << getIndent() << "//load entity descriptions" << endl;
  code << getIndent() << "std::vector<std::string>::iterator entityDescriptionIterator;" << endl;
  code << getIndent() << "for (entityDescriptionIterator=entityDescriptionVector.begin(); entityDescriptionIterator!=entityDescriptionVector.end(); entityDescriptionIterator++)" << endl;
  code << getIndent() << "{" << endl;
  indent++;
  code << getIndent() << "std::string entityDescriptionFile = *entityDescriptionIterator;" << endl;
  code << getIndent() << "std::cerr << \"Loading entity type description file: \" << entityDescriptionFile << std::endl;" << endl;
  code << getIndent() << "shared_ptr<XmlDocument> docEntityDescription = shared_ptr<XmlDocument>(new XmlDocument());" << endl;
  code << getIndent() << "docEntityDescription->parseFile(entityDescriptionFile);" << endl;
  code << getIndent() << "shared_ptr<XmlElement> entityDescriptionList = docEntityDescription->getRootElement();" << endl;
  code << getIndent() << "shared_ptr<EntityDescriptionRepository> entityDescriptionRepository = EntityDescriptionRepository::getInstance();" << endl;
  code << getIndent() << "shared_ptr<ServiceTypeDescriptionRepository> serviceTypeDescriptionRepository = ServiceTypeDescriptionRepository::getInstance();" << endl;
  code << getIndent() << "EntityDescriptionFactory::populateEntityDescriptionRepository(entityDescriptionRepository, entityDescriptionList, serviceTypeDescriptionRepository);" << endl;
  indent--;
  code << getIndent() << "}" << endl;
  
  // create ActiveObjects
  {
  
    ActiveObjectConfigurationNameMap::iterator aoit;
    
    code << endl << getIndent() << "// Create ActiveObjects" << endl;
    
    for (aoit = aocnm.begin(); aoit != aocnm.end(); aoit++) {
      shared_ptr<ActiveObjectConfiguration> aoc = (*aoit).second;
      code << getIndent() << "shared_ptr<ActiveObject> " << aoc->getName() << " = ActiveObjectManagerAce::getInstance()->createActiveObject();" << endl;
    }
    
  }
  
//     // Run startup procedures on ActiveObjects
//     {
//         code << endl << getIndent() << "// Run StartUp procedures on ActiveObjects" << endl;
//
//         ActiveObjectConfigurationNameMap::iterator aoi;
//
//         for (aoi = aocnm.begin(); aoi != aocnm.end(); aoi++)
//         {
//             string aoName = (*aoi).first;
//             code << getIndent() << aoName << "->doStartup();" << endl;
//         }
//     }

  // Do ActiveObjects start
  {
    code << endl << getIndent() << "// ActiveObjects start" << endl;
    
    ActiveObjectConfigurationNameMap::iterator aoi;
    
    for (aoi = aocnm.begin(); aoi != aocnm.end(); aoi++) {
      string aoName = (*aoi).first;
      code << getIndent() << aoName << "->start();" << endl;
    }
  }
  
  //create EntityRepository
  std::string entityRepositoryName = "aoEntityRepository";
  {
    code << endl << getIndent() << "// Create entity repository" << endl;
    code << getIndent() << (string) (*aoEntityRepositoryHeaderElement->getFirstNonBlankCharData());
    code << entityRepositoryName;
    code << (string) (*aoEntityRepositoryFooterElement->getFirstNonBlankCharData()) << endl;
    //! @TODO create one repository for each AO?
  }
  
  code << endl << getIndent() << "map<string, shared_ptr<Service> > nameToServiceMap_;" << endl;
  // create Services
  {
    ServiceDeploymentConfigurationNameMap::iterator sit;
    
    code << endl << getIndent() << "// Create Services" << endl;
    
    for (sit = scnm.begin(); sit != scnm.end(); sit++) {
      shared_ptr<ServiceDeploymentConfiguration> sc = (*sit).second;
      string serviceDescriptionXmlInstance = sc->getServiceInstanceName() + "Xml";
      
      code << getIndent() << "{" << endl;
      indent++;
      
      //create service configuration
      code << getIndent() << "shared_ptr<XmlDocument> serviceConfigurationDocument(new XmlDocument());" << endl;
      code << getIndent() << "serviceConfigurationDocument->parseFile(\"" << sc->getServiceConfigurationFilename() << "\");" << endl;
      code << getIndent() << "shared_ptr<ServiceConfiguration> serviceConfiguration(new ServiceConfiguration(serviceConfigurationDocument));" << endl;
      
      code << getIndent() << "shared_ptr<Task> build" << sc->getServiceClassName() << "((Task*)new UnitServiceBuildTask<" << sc->getServiceClassName() << ">(" << sc->getServiceActiveObjectName() << ", " << entityRepositoryName << ", \"" << sc->getServiceEntityName() << "\", \"" << sc->getServiceInstanceName() << "\", serviceConfiguration, nameToServiceMap_));" << endl;
      
      code << getIndent() << sc->getServiceActiveObjectName() << "->addTask(build" << sc->getServiceClassName() << ");" << endl;
      
      indent--;
      code << getIndent() << "}" << endl;
    }
    
  }
  
  code << endl << endl;
  
  code << getIndent() << "// busy wait" << endl;
  code << getIndent() << "while (nameToServiceMap_.size() != " << scnm.size() << ")" << endl;
  indent++;
  code << getIndent() << ";" << endl << endl;
  indent--;
  
  // now build ControlUnitService
  
  
  
  // Wait for ActiveObjects to stop
  {
    code << endl << getIndent() << "// Wait for ActiveObjects to stop" << endl;
    code << getIndent() << "ActiveObjectManagerAce::getInstance()->waitForActiveObjectsToStop();" << endl;
    //code << getIndent() << "sleep(5); exit_program(0);" << endl;
  }
  
  
//     //shutdown ActiveObjects
//     {
//         code << endl << getIndent() << "//Shutdown ActiveObjects" << endl;
//
//         ActiveObjectConfigurationNameMap::iterator aoi;
//
//         for (aoi = aocnm.begin(); aoi != aocnm.end(); aoi++)
//         {
//             string aoName = (*aoi).first;
//             code << getIndent() << aoName << "->doShutdown();" << endl;
//         }
//
//     }


  code << (string) (*mainFooterElement->getFirstNonBlankCharData());
  
  code << (string) (*fileFooterElement->getFirstNonBlankCharData());
  
  outputFile << code.str() << endl;
  outputFile.close();
  
}; // main