/Desktop/MGS-MultithreadedGameServer/Server.cc

Vai alla documentazione di questo file.

//
// File: Server.cc
// Created by: <Detro /> aka Ivan De Marino 
// <detro@mandolinux.org, demarino@studenti.unina.it, demarino@na.astro.it>
// Created on: Sun Oct 24 13:14:11 2004
//
#include "Server.h"

/**
 * Costruttore della Classe Server.
 *
 * @param iAddress Indirizzo su cui il Server deve mettersi in ascolto
 * @param port Porta su cui il Server deve mettersi in ascolto */
Server::Server(const InetAddress &iAddress, 
   const tpport_t port, 
   const string path) : 
TCPSocket(iAddress, port), pluginGameDirPath(path) {
   cout << ">>> MGS - Multithreaded Game Server <<<" << endl
      << "---------------------------------------" << endl << endl;
   cout << "<Server msg> Server UP and Running on " 
      << iAddress.getHostname() 
      << ":" << port << endl;
};

/**
 * Distruttore della Classe Server.
 * Si occupa di Eliminare tutti i @c ConnectionHandler
 * e tutti i @c Game istanziati. */
Server::~Server(void) {
   connHandPool.clear();
   activeGames.clear();
}

/**
 * Accettazione della Connessione.
 * Questo metodo protetto viene eseguito all'atto dell'accettazione
 * (chiamata ad @c accept()) di una connessione in ingresso.
 *
 * @param iAddress Indirizzo da cui proviene la Connessione in ingresso
 * @param port Porta da cui proviene la Connessione 
 * @return true quando il Server riceve una richiesta di Connessione */
bool Server::onAccept(const InetHostAddress &iAddress, const tpport_t port) {
   cout << "<Server msg> Server has Accepted Connection from: " 
      << iAddress.getHostname() << ":" << port << endl;;
   return true;
}

/**
 * Esecuzione del Server.
 * Questo metodo e' il corpo principale del Server.
 * Il Server si mette in ascolto per il tempo richiesto
 * e, come gia' detto, accetta connessioni in ingresso e le
 * gira ad un nuovo Handler.
 *
 * @param pendingTime Tempo di attesa del Server - 
 *    <code>TIMEOUT_INF</code> per attendere indeterminatamente */
void Server::run(const timeout_t pendingTime) {
   /* Carica i Plug-In Game */
   loadPlugInGames();

   /* Prova a rimanere in attesa di connessioni
    * per il tempo richiesto ("pendingTime") */
   try {
      while(isPendingConnection(pendingTime)) {
         ConnectionHandler *newConnHand;
         newConnHand = new ConnectionHandler(*this, 
            activeGames, 
            availableGames);
         connHandPool.push_back(newConnHand);
         newConnHand->start();
      }
   }
   catch(Socket *socket) {
      /* In caso di problemi, l'eccezione viene rilanciata a chi
       * a livello superiore */
      cout << "<Server msg> Socket Error. Throwed." << endl;
      throw;
   }
}

/**
 * Metodo per la selezione delle Shared Object Library da una Directory.
 * E' una funzione utilizzata da @c scandir (inclusa in @c dirent.h )
 * per trovare tutte le librerie @c ".so" di una directory data.
 * @param dir Prende in input un puntatore a @c struct @c dirent
 * @return Restituisce il numero di SO trovate */
int Server::SharedObjectLibrarySelector(const struct dirent *dir) {
   string fileName = dir->d_name;
   string extension;
   if( fileName.size() < 3 ) /* Esclude anche i file ".", ".." */ 
      return 0;
   extension = fileName.substr( fileName.size()-3, fileName.size() );
   if( extension != ".so" ) 
      return 0;
   else
      return 1;
}

/**
 * Caricamento delle Classi Plug-In per i Game.
 * Cerca e Carica le Shared Object Library dei Game disponibili.
 * La Directory in cui cercare i Plug-In sara' quella specificata
 * all'istanziazione del Server */
void Server::loadPlugInGames(void) {
   struct dirent **directory; // Struttura per la lettura della directory
   string fileName;
   int numFoundedFile;
   TFactory<Game *> *factoryPointer;
   Game *gamePointer;
   pair< string, TFactory<Game *> *> *pairPointer;
   
   cout << "<Server msg> Searching for SO Plug-In Game in \"" <<
      pluginGameDirPath << "\"" << endl;
   
   /* Ricerca ".so" */
   numFoundedFile = scandir(pluginGameDirPath.data(), &directory, 
      Server::SharedObjectLibrarySelector, alphasort);
   
   /* Per ogni ".so" trovata istanziamo la relativa TFactory */
   for( int i = 0; i < numFoundedFile; i++ ) {
      fileName = directory[i]->d_name;
      cout << "<Server msg> Founded SO Plug-In Game: " << fileName << endl;
      
      /* Creazione TFactory per il Plug-In */
      try {
         factoryPointer = new TFactory<Game *> (string(pluginGameDirPath + "/" + fileName));
      }
      catch ( TFactoryException &e ) {
         cout << "<Server msg> Error during Plug-In Loading: " << 
            e.getExceptionMessage() << endl;
         exit (1);
      }
   
      /* Creazione Oggetto Game per leggere il relativo Name */
      gamePointer = factoryPointer->build();
   
      /* Caricamento del Game tra quelli disponibili */
      pairPointer = new pair< string, TFactory<Game *> *> ( 
         gamePointer->getName(), 
         factoryPointer );
      availableGames.push_back( pairPointer );
      
      delete gamePointer;
   }
   cout << "<Server msg> Founded " << numFoundedFile 
      << " Plug-In Game(s)" << endl;
}

---