RemoteServer.h

/*
 * Copyright 2003 Michael A. Marsh, Cornell University. All rights reserved.
 * This software is released under the modified BSD license.
 * See the file LICENSE in the top-level directory for details.
 */
//
// $Id: RemoteServer.h,v 1.4 2005/01/21 19:44:17 mmarsh Exp $
//
// $Log: RemoteServer.h,v $
// Revision 1.4  2005/01/21 19:44:17  mmarsh
// Updated for compatibility with Doxygen 1.4.1
//
// Revision 1.3  2004/05/19 15:56:56  mmarsh
// *** empty log message ***
//
// Revision 1.2  2003/11/04 22:17:23  mmarsh
// General code cleanup.
//
//

#ifndef __CODEX_QUORUM_REMOTESERVER_H__
#define __CODEX_QUORUM_REMOTESERVER_H__

#include <sys/time.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string>

#include "QSExceptions.h"
#include "Message.h"
#include "Socket.h"

namespace CODEX_Quorum
{
   class SocketBase;
   class SocketBuilder;

   class RemoteServerReturn
   {
      public :
         enum ReturnCode
         {
            kSuccess, 
            kFailure, 
            kNumReturnCodes
         };

         enum ErrorCode
         {
            kNone,    
            kTimeout, 
            kNumErrorCodes
         };

         RemoteServerReturn() :
            m_ret( kFailure ),
            m_err( kNone )
         {
            if ( gettimeofday( &m_created, 0 ) )
            {
               m_created.tv_sec = 0;
               m_created.tv_usec = 0;
            }
            m_time.tv_sec = m_created.tv_sec;
            m_time.tv_usec = m_created.tv_usec;
         }

         RemoteServerReturn( const RemoteServerReturn& sr ) :
            m_ret( sr.m_ret ),
            m_err( sr.m_err )
         {
            m_created.tv_sec = sr.m_created.tv_sec;
            m_created.tv_usec = sr.m_created.tv_usec;

            m_time.tv_sec = sr.m_time.tv_sec;
            m_time.tv_usec = sr.m_time.tv_usec;
         }

         ReturnCode      returnCode() const { return m_ret; }
         ErrorCode       errorCode()  const { return m_err; }

         struct timeval  elapsed()    const {
            struct timeval retval;
            retval.tv_sec = m_time.tv_sec - m_created.tv_sec;
            retval.tv_usec = m_time.tv_usec - m_created.tv_usec;
            if ( retval.tv_usec < 0 )
            {
               --retval.tv_sec;
               retval.tv_usec += 1000000;
            }
            return retval;
         }

         void setReturnCode( ReturnCode ret ) { m_ret = ret; }
         void setErrorCode( ErrorCode err ) { m_err = err; }

         void updateTime( const struct timeval& t ) {
            m_time.tv_sec = t.tv_sec;
            m_time.tv_usec = t.tv_usec;
         }

         void reset() {
            m_ret = kFailure;
            m_err = kNone;
            if ( gettimeofday( &m_created, 0 ) )
            {
               m_created.tv_sec = 0;
               m_created.tv_usec = 0;
            }
            m_time.tv_sec = m_created.tv_sec;
            m_time.tv_usec = m_created.tv_usec;
         }

      private :
         ReturnCode      m_ret;
         ErrorCode       m_err;
         struct timeval  m_created;
         struct timeval  m_time;
   };


   class RemoteServer
   {
      public :
         RemoteServer( struct timeval* timeout,
                       string address,
                       int port,
                       const SocketBuilder& socketBuilder,
                       SocketBase* socket = 0 );

         virtual ~RemoteServer();

         const struct sockaddr_in*  sockaddr_in() const;
         const struct sockaddr*     sockaddr()    const;
         socklen_t                  addrlen()     const;
         string                     name()        const;
         int                        port()        const;

         int set_fd( fd_set* fd_bitmap, SocketBase::StateType s ) const;

         bool isset_fd( const fd_set* fd_bitmap, SocketBase::StateType s )
            const;

         void flushSocket() const;

         //@startgroup

         void contact( const Message& msg ,
                       Response& response ,
                       RemoteServerReturn& retval );

         void sendTo( const Message& msg ,
                      RemoteServerReturn& retval ) const;

         size_t receiveFrom( Response& response ,
                             RemoteServerReturn& retval ,
                             size_t length = 0 );

         //@endgroup

         void closeSocket();

      protected :
         SocketBase* socket() const;

         virtual bool checkTimeout( const RemoteServerReturn& retval ) const;
         virtual void updateTime( RemoteServerReturn& retval ) const;

      private :
         struct timeval* m_timeout;
         // We may want to store a socket instead of address and port.
         string m_address;
         int m_port;
         const SocketBuilder& m_socketBuilder;
         mutable SocketBase* m_socket;
         mutable struct sockaddr_in* m_sockaddr;
   };

   class AsynchronousRemoteServer : public RemoteServer
   {
      public :
         AsynchronousRemoteServer( string address,
                                   int port,
                                   const SocketBuilder& socketBuilder,
                                   SocketBase* socket = 0) :
            RemoteServer(0, address, port, socketBuilder, socket) {}

         virtual ~AsynchronousRemoteServer() {}

      protected :
         bool checkTimeout( const RemoteServerReturn& retval ) const;
         void updateTime( RemoteServerReturn& retval ) const;
   };


   //--------- Exceptions ---------//

   class QSERemoteServer : public QSExceptionBase
   {
      public :
         QSERemoteServer( const string& fname,
                          int line,
                          const RemoteServer* server ) :
            QSExceptionBase( fname, line ),
            m_server( server )
         {}

         virtual ~QSERemoteServer() {}

      protected :
         const RemoteServer* server() const { return m_server; }

         void derivedMsg() const;

         virtual void errMsg() const = 0;

      private :
         const RemoteServer*  m_server;
   };

   class QSERemoteServerGethostbynameFailed : public QSERemoteServer
   {
      public :
         QSERemoteServerGethostbynameFailed( const string& fname,
                                             int line,
                                             const RemoteServer* server ) :
            QSERemoteServer( fname, line, server )
         {}

         virtual ~QSERemoteServerGethostbynameFailed() {}

      protected :
         void errMsg() const;
   };

}

#endif /* __CODEX_QUORUM_REMOTESERVER_H__ */

---