rtig.cc

分布式仿真 开放源码

// ----------------------------------------------------------------------------
// CERTI - HLA RunTime Infrastructure
// Copyright (C) 2002, 2003, 2004  ONERA
//
// This file is part of CERTI
//
// CERTI is free software ; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation ; either version 2 of the License, or
// (at your option) any later version.
//
// CERTI 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program ; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// $Id: RTIG.cc,v 3.23 2004/03/14 00:24:55 breholee Exp $
// ----------------------------------------------------------------------------

#include <config.h>
#include "RTIG.hh"

#include "PrettyDebug.hh"

#include <iostream>
#include <csignal>
#include <unistd.h>
#include <errno.h>

using std::cout ;
using std::endl ;
using std::cerr ;

namespace certi {
namespace rtig {

static pdCDebug D("RTIG", __FILE__);

// ----------------------------------------------------------------------------
// Constructor

RTIG::RTIG()
    : terminate(false), federationHandles(1)
{
    // Start RTIG services
    const char *tcp_port_s = getenv("CERTI_TCP_PORT");
    const char *udp_port_s = getenv("CERTI_UDP_PORT");
    if (tcp_port_s==NULL) tcp_port_s = PORT_TCP_RTIG ;
    if (udp_port_s==NULL) udp_port_s = PORT_UDP_RTIG ;
    tcpPort = atoi(tcp_port_s);
    udpPort = atoi(udp_port_s);

    socketServer = new SocketServer(&tcpSocketServer,
				    &udpSocketServer,
				    udpPort);
    auditServer = new AuditFile(RTIG_AUDIT_FILENAME);
    federations = new FederationsList(socketServer, auditServer);
    federations->setVerbose(verbose);
}

// ----------------------------------------------------------------------------
// Destructor

RTIG::~RTIG()
{
    tcpSocketServer.close();
    udpSocketServer.close();

    delete socketServer ;
    delete federations ;
    delete auditServer ;

    cout << endl << "Stopping RTIG" << endl ;
}

// ----------------------------------------------------------------------------
//! Choose the right processing module to call.
/*! This module chooses the right processing module to call. This process is
  done by examinating the message type.
*/
Socket*
RTIG::chooseProcessingMethod(Socket *link, NetworkMessage *msg)
{

    // This may throw a security error.
    socketServer->checkMessage(link->returnSocket(), msg);

    switch(msg->type) {
      case NetworkMessage::MESSAGE_NULL:
        D.Out(pdDebug, "Message Null.");
        auditServer->setLevel(0);
        processMessageNull(msg);
        break ;

      case NetworkMessage::UPDATE_ATTRIBUTE_VALUES:
        D.Out(pdDebug, "UpdateAttributeValue.");
        auditServer->setLevel(1);
        processUpdateAttributeValues(link, msg);
        break ;

      case NetworkMessage::SEND_INTERACTION:
        D.Out(pdTrace, "send interaction.");
        auditServer->setLevel(2);
        processSendInteraction(link, msg);
        break ;

      case NetworkMessage::CLOSE_CONNEXION:
        D.Out(pdTrace, "Close connection %ld.", link->returnSocket());
        auditServer->setLevel(9);
        auditServer->addToLinef("Socket %ld", link->returnSocket());
        closeConnection(link, false);
        link = NULL ;
        break ;

      case NetworkMessage::CREATE_FEDERATION_EXECUTION:
        D.Out(pdTrace, "Create federation \"%s\".", msg->federationName);
        auditServer->setLevel(9);
        processCreateFederation(link, msg);
        break ;

      case NetworkMessage::DESTROY_FEDERATION_EXECUTION:
        D.Out(pdTrace, "Destroy federation \"%s\".", msg->federationName);
        auditServer->setLevel(9);
        processDestroyFederation(link, msg);
        break ;

      case NetworkMessage::JOIN_FEDERATION_EXECUTION:
        D.Out(pdTrace, "federate \"%s\" joins federation \"%s\".",
              msg->federateName, msg->federationName);
        auditServer->setLevel(9);
        processJoinFederation(link, msg);
        break ;

      case NetworkMessage::RESIGN_FEDERATION_EXECUTION:
        D.Out(pdTrace, "Federate no %u leaves federation no %u .",
              msg->federate, msg->federation);
        auditServer->setLevel(9);
        processResignFederation(msg->federation, msg->federate);
        break ;

      case NetworkMessage::REGISTER_FEDERATION_SYNCHRONIZATION_POINT:
        D.Out(pdTrace,
              "Federation %u: registerFedSyncPoint from federate %u.",
              msg->federation, msg->federate);
        auditServer->setLevel(8);
        processRegisterSynchronization(link, msg);
        break ;

      case NetworkMessage::SYNCHRONIZATION_POINT_ACHIEVED:
        D.Out(pdTrace,
              "Federation %u: synchronizationPointAchieved from federate %u.",
              msg->federation, msg->federate);
        auditServer->setLevel(8);
        processSynchronizationAchieved(link, msg);
        break ;

      case NetworkMessage::REQUEST_FEDERATION_SAVE:
        D.Out(pdTrace, "Request federation save from federate %u.",
              msg->federate);
        auditServer->setLevel(8);
        processRequestFederationSave(link, msg);
        break ;

      case NetworkMessage::FEDERATE_SAVE_BEGUN:
        D.Out(pdTrace, "Federate %u begun save.", msg->federate);
        auditServer->setLevel(8);
        processFederateSaveBegun(link, msg);
        break ;

      case NetworkMessage::FEDERATE_SAVE_COMPLETE:
      case NetworkMessage::FEDERATE_SAVE_NOT_COMPLETE:
        D.Out(pdTrace, "Federate %u save complete/not complete.",
              msg->federate);
        auditServer->setLevel(8);
        processFederateSaveStatus(link, msg);
        break ;

      case NetworkMessage::REQUEST_FEDERATION_RESTORE:
        D.Out(pdTrace, "Federate %u request a restoration.", msg->federate);
        auditServer->setLevel(8);
        processRequestFederationRestore(link, msg);
        break ;

      case NetworkMessage::FEDERATE_RESTORE_COMPLETE:
      case NetworkMessage::FEDERATE_RESTORE_NOT_COMPLETE:
        D.Out(pdTrace, "Federate %u restore complete/not complete.",
              msg->federate);
        auditServer->setLevel(8);
        processFederateRestoreStatus(link, msg);
        break ;

      case NetworkMessage::SET_TIME_REGULATING:
        D.Out(pdTrace, "SetTimeRegulating du federe %u(date=%f).",
              msg->federate, msg->date);
        auditServer->setLevel(8);
        processSetTimeRegulating(msg);
        break ;

      case NetworkMessage::SET_TIME_CONSTRAINED:
        D.Out(pdTrace, "SetTimeConstrained du federe %u.", msg->federate);
        auditServer->setLevel(8);
        processSetTimeConstrained(msg);
        break ;

      case NetworkMessage::PUBLISH_OBJECT_CLASS:
      case NetworkMessage::UNPUBLISH_OBJECT_CLASS:
        D.Out(pdTrace, "un/publishObjectClass.");
        auditServer->setLevel(7);
        processPublishObjectClass(link, msg);
        break ;

      case NetworkMessage::PUBLISH_INTERACTION_CLASS:
      case NetworkMessage::UNPUBLISH_INTERACTION_CLASS:
        D.Out(pdTrace, "un/publishInteractionClass.");
        auditServer->setLevel(7);
        processPublishInteractionClass(link, msg);
        break ;

      case NetworkMessage::SUBSCRIBE_OBJECT_CLASS:
      case NetworkMessage::UNSUBSCRIBE_OBJECT_CLASS:
        D.Out(pdTrace, "un/subscribeObjectClass.");
        auditServer->setLevel(7);
        processSubscribeObjectClass(link, msg);
        break ;

      case NetworkMessage::SUBSCRIBE_INTERACTION_CLASS:
      case NetworkMessage::UNSUBSCRIBE_INTERACTION_CLASS:
        D.Out(pdTrace, "un/subscribeInteractionClass.");
        auditServer->setLevel(7);
        processSubscribeInteractionClass(link, msg);
        break ;

      case NetworkMessage::REGISTER_OBJECT:
        D.Out(pdTrace, "registerObject.");
        auditServer->setLevel(6);
        processRegisterObject(link, msg);
        break ;

      case NetworkMessage::DELETE_OBJECT:
        D.Out(pdTrace, "DeleteObject..");
        auditServer->setLevel(6);
        processDeleteObject(link, msg);
        break ;

      case NetworkMessage::IS_ATTRIBUTE_OWNED_BY_FEDERATE:
        D.Out(pdTrace, "isAttributeOwnedByFederate..");
        auditServer->setLevel(2);
        processAttributeOwnedByFederate(link, msg);
        break ;

      case NetworkMessage::QUERY_ATTRIBUTE_OWNERSHIP:
        D.Out(pdTrace, "queryAttributeOwnership..");
        auditServer->setLevel(2);
        processQueryAttributeOwnership(link, msg);
        break ;

      case NetworkMessage::NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE:
        D.Out(pdTrace, "negotiatedAttributeOwnershipDivestiture..");
        auditServer->setLevel(6);
        processNegotiatedOwnershipDivestiture(link, msg);
        break ;

      case NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION_IF_AVAILABLE:
        D.Out(pdTrace, "attributeOwnershipAcquisitionIfAvailable..");
        auditServer->setLevel(6);
        processAcquisitionIfAvailable(link, msg);
        break ;

      case NetworkMessage::UNCONDITIONAL_ATTRIBUTE_OWNERSHIP_DIVESTITURE:
        D.Out(pdTrace, "unconditionalAttributeOwnershipDivestiture..");
        auditServer->setLevel(6);
        processUnconditionalDivestiture(link, msg);
        break ;

      case NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION:
        D.Out(pdTrace, "attributeOwnershipAcquisition..");
        auditServer->setLevel(6);
        processOwnershipAcquisition(link, msg);
        break ;

      case NetworkMessage::CANCEL_NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE:
        D.Out(pdTrace, "cancelNegociatedAttributeOwnershipDivestiture..");
        auditServer->setLevel(6);
        processCancelNegotiatedDivestiture(link, msg);
        break ;

      case NetworkMessage::ATTRIBUTE_OWNERSHIP_RELEASE_RESPONSE:
        D.Out(pdTrace, "attributeOwnershipReleaseResponse..");
        auditServer->setLevel(6);
        processReleaseResponse(link, msg);
        break ;

      case NetworkMessage::CANCEL_ATTRIBUTE_OWNERSHIP_ACQUISITION:
        D.Out(pdTrace, "cancelAttributeOwnershipAcquisition..");
        auditServer->setLevel(6);
        processCancelAcquisition(link, msg);
        break ;

      case NetworkMessage::DDM_CREATE_REGION:
        D[pdTrace] << "createRegion" << endl ;
        auditServer->setLevel(6);
        processCreateRegion(link, msg);
        break ;

      case NetworkMessage::DDM_MODIFY_REGION:
	D[pdTrace] << "modifyRegion" << endl ;
	auditServer->setLevel(6);
        processModifyRegion(link, msg);
        break ;

      case NetworkMessage::DDM_DELETE_REGION:
        D[pdTrace] << "deleteRegion" << endl ;
        auditServer->setLevel(6);
        processDeleteRegion(link, msg);