root/juggler/branches/2.2/modules/gadgeteer/cluster/Packets/Header.cpp

/*************** <auto-copyright.pl BEGIN do not edit this line> **************
 *
 * VR Juggler is (C) Copyright 1998-2007 by Iowa State University
 *
 * Original Authors:
 *   Allen Bierbaum, Christopher Just,
 *   Patrick Hartling, Kevin Meinert,
 *   Carolina Cruz-Neira, Albert Baker
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 *************** <auto-copyright.pl END do not edit this line> ***************/

//#include <gadget/gadgetConfig.h>
#include <cluster/Packets/Header.h>
#include <gadget/Util/Debug.h>

#include <vpr/IO/Socket/SocketStream.h>

namespace cluster
{

Header::Header()
{;}

Header::Header( const vpr::Uint16 code, const vpr::Uint16 type,
                const vpr::Uint32 length, const vpr::Uint32 frame )
   : mRIMCode(code)
   , mPacketType(type)
   , mPacketLength(length)
   , mFrame(frame)
{;}

void Header::readData(vpr::SocketStream* stream)
{
   vprASSERT( NULL != stream && "Can not create a Header using a NULL SocketStream" );

   // - Is stream is a valid SocketStream?
   //   - Read in the packet from the socket
   //   - Set the BufferObjectReader and BufferObjectWriter to use mData  <====We only need BufferObjectReader
   if (NULL == stream)
   {
      vprDEBUG( gadgetDBG_RIM, vprDBG_CONFIG_LVL )
         << clrOutBOLD( clrRED, "ERROR:" )
         << " SocketSteam is NULL"
         << std::endl << vprDEBUG_FLUSH;

      throw cluster::ClusterException("Header::Header() - SocketStream is NULL");
   }
   else
   {
      vpr::Uint32 bytes_read;   
      
      try
      {
         bytes_read = stream->readn(mData, Header::RIM_PACKET_HEAD_SIZE);
      }
      catch (vpr::IOException& ex)
      {
         stream->close();
         delete stream;
         stream = NULL;

         vprDEBUG( gadgetDBG_RIM, vprDBG_CRITICAL_LVL )
            << "Header::readData() - Could not read the header!\n"
            << ex.what()
            << std::endl << vprDEBUG_FLUSH;
         throw ex;
      }

      if (bytes_read != RIM_PACKET_HEAD_SIZE )
      {
         stream->close();
         delete stream;
         stream = NULL;
         
         throw cluster::ClusterException( "Header::Header() - Bytes Read was lower than RIM_PACKET_HEAD_SIZE" );
      }
      
      if ( bytes_read != RIM_PACKET_HEAD_SIZE )
      {
         vprDEBUG( gadgetDBG_RIM, vprDBG_CONFIG_LVL )
            << clrOutBOLD( clrRED, "ERROR:" )
            << "Header::Header Something is seriously wrong here!\n" 
            << "We only read: " << bytes_read << " bytes for the header\n"
            << "When we need " << RIM_PACKET_HEAD_SIZE << " bytes!" << std::endl
            << vprDEBUG_FLUSH;
            exit(0);
      }
      
      parseHeader();
   }
}

void Header::serializeHeader()
{  
   vpr::BufferObjectWriter writer(&mData);
   writer.getData()->clear();
   writer.setCurPos( 0 );

   // -Write all packet header information to the base Header class

//   std::cout << "Head Starting at Position: " << writer.getCurPos() << std::endl;
   writer.writeUint16( mRIMCode );
//   std::cout << "Write RIMCode: " << mRIMCode << std::endl;
//   std::cout << "Current Position: " << writer.getCurPos() << std::endl;

   writer.writeUint16( mPacketType );
//   std::cout << "Write PacketType: " << mPacketType << std::endl;
//   std::cout << "Current Position: " << writer.getCurPos() << std::endl;

   writer.writeUint32( mFrame );
//   std::cout << "Write Frame: " << mFrame << std::endl;
//   std::cout << "Current Position: " << writer.getCurPos() << std::endl;

   writer.writeUint32( mPacketLength );
//   std::cout << "Write Packet Length: " << mPacketLength << std::endl;
//   std::cout << "Current Position: " << writer.getCurPos() << std::endl;
}

void Header::parseHeader()
{
   // *Now that we have recieved the correct number 
   //  of bytes from the socket(RIM_PACKET_HEAD_SIZE)

   // -Parse the new data using a BufferObjectReader
   // -Is this a valid RIM packet?
   //  -If not exit immediately

   vpr::BufferObjectReader reader( &mData );
   //std::cout << "Head Starting at Position: " << reader.getCurPos() << std::endl;

   mRIMCode = reader.readUint16();
//   std::cout << "Read RIMCode: " << mRIMCode << std::endl;
//   std::cout << "Current Position: " << reader.getCurPos() << std::endl;
   mPacketType = reader.readUint16();
//   std::cout << "Read PacketType: " << mPacketType << std::endl;
//   std::cout << "Current Position: " << reader.getCurPos() << std::endl;
   mFrame = reader.readUint32();
//   std::cout << "Read Frame#: " << mFrame << std::endl;
//   std::cout << "Current Position: " << reader.getCurPos() << std::endl;
   mPacketLength = reader.readUint32();
//   std::cout << "Read Packet Length: " << mPacketLength << std::endl;
//   std::cout << "Current Position: " << reader.getCurPos() << std::endl;

   if ( RIM_PACKET != mRIMCode )
   {
      vprDEBUG( gadgetDBG_RIM, vprDBG_CONFIG_LVL )
         << clrOutBOLD( clrRED, "ERROR:" )
         << " This Packet is not a valid RIM Packet!!"
         << " RIMCode: " << mRIMCode << " is not valid!"
         << std::endl << vprDEBUG_FLUSH;
         
         throw cluster::ClusterException( "Header::parseHeader() - Invalid packet header!" );
   }
}

void Header::send(vpr::SocketStream* socket)
{
   vprASSERT( NULL != socket && "Socket is NULL" );

   // -Send the data in this packet
   try
   {
      socket->send(mData, RIM_PACKET_HEAD_SIZE);
   }
   catch (vpr::IOException&)
   {
      // TODO: setCause(ex)
      throw cluster::ClusterException( "Header::send() - failed to send header." );
   }
}

void Header::dump()
{
   std::cout << "Dumping Header(" << mData.size() << " bytes): ";
   for ( std::vector<vpr::Uint8>::iterator i = mData.begin();
        i!= mData.end(); i++ )
   {
      std::cout << (int)*i << " ";
   }
   std::cout << std::endl;
}

void Header::printData( const int debug_level )
{
   vprDEBUG_BEGIN( gadgetDBG_RIM, debug_level )
      << clrOutBOLD( clrYELLOW, "====== Packet Header ======" )
      << std::endl << vprDEBUG_FLUSH;
   
   vprDEBUG( gadgetDBG_RIM, debug_level )
      << clrOutBOLD( clrYELLOW, "RIMCode:    " ) << mRIMCode
      << std::endl << vprDEBUG_FLUSH;
   vprDEBUG( gadgetDBG_RIM, debug_level )
      << clrOutBOLD( clrYELLOW, "PacketType: " ) << mPacketType
      << std::endl << vprDEBUG_FLUSH;
   vprDEBUG( gadgetDBG_RIM, debug_level )
      << clrOutBOLD( clrYELLOW, "Frame #:    " ) << mFrame
      << std::endl << vprDEBUG_FLUSH;
   vprDEBUG( gadgetDBG_RIM, debug_level )
      << clrOutBOLD( clrYELLOW, "Length:     " ) << mPacketLength
      << std::endl << vprDEBUG_FLUSH;

   vprDEBUG_END( gadgetDBG_RIM, debug_level )
      << clrOutBOLD( clrYELLOW, "===========================" )
      << std::endl << vprDEBUG_FLUSH;
}

} // end cluster namespace