• Main
• Home
• Features
• Screenshots
• Downloads
• License
• Team profile
• Documentation
• Manual
• FAQ
• Reference

Search this page:

PCMNetServer.cpp

Go to the documentation of this file.

//
// This source file is a part of ParCompMark
// Parallel Compositing Benchmark Framework
//
// for latest info see http://parcompmark.sourceforge.net

//
// Copyright (C) 2006 IT2 ParCompMark Dev. Team
// 
// This program 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.
// 
// This program 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.

//
// Inner includes
//

#include "../include/PCMNetServer.h"

namespace ParCompMark
{

  //
  // Constructors & destructor
  //

  NetServer::NetServer(const std::string & name):
        // Parent initializer 
  Network(name          /* Name of the class */
        )
        // You have to initialize the following attributes:
        // - mBroadcastAddress
        // - mMaxConnection
        // - mHostNumber
        // - mRecievedNumber
        // - mStopFrameID
  {
        //mBroadcastAddress
        mMaxConnection = 30;
        //TODO: hack
        mHostNumber = 100000;

        mStopFrameID = IntPointer(new int);
         *mStopFrameID.getPtr() = 0;

        //TODO: initialize() should call this function ??
        getIP();

        initialize();
  }

 /*----------------------------------------------------------------------*/

  NetServer::~NetServer()
  {
        if(mInitialized)
        {
         finalize();
        }
  }

 /*----------------------------------------------------------------------*/

  //
  // Methods
  //

  void NetServer::initialize()
  {

        Assert(!mInitialized, INVALID_OPERATION_ERROR, "NetServer::initialize");

        //server accept client connection initialize

        struct sockaddr_in addr;

        if((mStreamSocket = socket(PF_INET, SOCK_STREAM, 0)) < 0)
        {
         Except(INTERNAL_ERROR, "NetServer::initialize", "Unable to create socket");
        }

        addr.sin_family = AF_INET;
        addr.sin_port = htons(mCommunicationPort);
        addr.sin_addr.s_addr = htonl(INADDR_ANY);
        memset(&(addr.sin_zero), '\0', 8);

        int yes = 1;

        if(setsockopt(mStreamSocket, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1)
        {
         Except(INTERNAL_ERROR, "NetServer::initialize", "Unable to change socket options");
        }

        if((bind(mStreamSocket, (struct sockaddr *) &addr, sizeof(struct sockaddr))) < 0)
        {
         Except(INTERNAL_ERROR, "NetServer::initialize", "Unable to bind socket");
        }

        if(listen(mStreamSocket, mMaxConnection) < 0)
        {
         Except(INTERNAL_ERROR, "NetServer::initialize", "Unable to listen socket");
        }
        //broadcast send initialize

        int broadcastPermission = 1;

        if((mBroadcastSocket = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
        {
         Except(INTERNAL_ERROR, "NetServer::initialize", "Unable to create socket");
        }

        if(setsockopt
         (mBroadcastSocket, SOL_SOCKET, SO_BROADCAST, (void *) &broadcastPermission, sizeof(broadcastPermission)) < 0)
        {
         Except(INTERNAL_ERROR, "NetServer::initialize", "Unable to change socket options");
        }

        mBroadcastAddress.sin_family = AF_INET;
        mBroadcastAddress.sin_addr.s_addr = inet_addr(mIfConfs->get("eth0")->BroadcastIP.c_str());
        mBroadcastAddress.sin_port = htons(mBroadcastPort);
        memset(&(mBroadcastAddress.sin_zero), '\0', 8);

        mRecievedNumber = new int;

        mRecievedNumber.lock();
        *mRecievedNumber.getPtr() = 0;
        mRecievedNumber.unlock();

        initThread(0, 0, true);

        mInitialized = true;

        Logger::getInstance()->log(Logger::NOTICE, "NetServer initalized.");
  }

 /*----------------------------------------------------------------------*/

  void NetServer::finalize()
  {
        Assert(mInitialized, INVALID_OPERATION_ERROR, "NetServer::finalize()");

        if(mBroadcastSocket != -1)
        {
         close(mBroadcastSocket);
         mBroadcastSocket = -1;
        }

        if(mStreamSocket != -1)
        {
         close(mStreamSocket);
         mStreamSocket = -1;
        }

        mInitialized = false;
  }

 /*----------------------------------------------------------------------*/

  void NetServer::sendBroadcastMessage(const std::string & type, const std::string & message)
  {

        mRecievedNumber.lock();

        *mRecievedNumber.getPtr() = 0;

        mRecievedNumber.unlock();

        std::string full;

        full = type + "|" + message;

        if(sendto
         (mBroadcastSocket, full.c_str(), full.length(), 0, (struct sockaddr *) &mBroadcastAddress,
         sizeof(struct sockaddr)) != full.length())
        {
         Except(INTERNAL_ERROR, "NetServer::sendBroadcastMessage", "Unable to send message");
        }

        Logger::getInstance()->log(Logger::NOTICE, "A broadcast message is sent: " + full);

        if(mHostNumber != 0)
        {
         //fprintf(stderr, "host num,ber: %d", mHostNumber);
         wait();
        }

  }

 /*----------------------------------------------------------------------*/

  void NetServer::buildCluster()
  {

        bool ok = false;

        int probeNumber,
        nodeNumber,
        maxProbe = 4;

        probeNumber = 0;
        nodeNumber = 0;

        mHostNumber = 0;

        //do while all host response
        while(probeNumber < maxProbe)
        {
         sendBroadcastMessage("LOGIN", "");

         Timer::sleep(0.01);

         Cluster::getInstance()->getHosts().lock();
         int n = Cluster::getInstance()->getHosts()->getSize();

         Cluster::getInstance()->getHosts().unlock();

         if(nodeNumber < n)
         {
                probeNumber = 0;
                nodeNumber = n;
         } else
         {
                probeNumber++;
         }

        }

        mHostNumber = Cluster::getInstance()->getHosts()->getSize();

  }

 /*----------------------------------------------------------------------*/

  void NetServer::task()
  {

        struct sockaddr_in addr;

        int clientSock = -1;
        unsigned int addrLen = sizeof(struct sockaddr);

        if((clientSock = accept(mStreamSocket, (struct sockaddr *) &addr, &addrLen)) < 0)
        {
         Except(INTERNAL_ERROR, "NetServer::task()", "Unable to accept");
        }

        Logger::getInstance()->log(Logger::DEBUG, "Client handling started.");

        HandleClient *handle;

        handle = new HandleClient(this);

        handle->setStreamSocket(clientSock);
        handle->setServerIP(mOwnIP);
        handle->initThread(1, 0);       //run one times
        //wait for ready ??
        handle->startThread();

  }

 /*----------------------------------------------------------------------*/

}

© Copyright - 2006 (IT)² ParCompMark Dev. Team