ClusterSync.H

Go to the documentation of this file.

#ifndef CLUSTERSYNC_H
#define CLUSTERSYNC_H

#include "IS3DCommon.H"
#include "Event.H"
#include "FsaMgr.H"

namespace IS3D {

// the port on which the server runs by default
#define CLUSTERSYNC_SERVER_PORT 1201

// the port on which the client runs by default
#define CLUSTERSYNC_CLIENT_PORT 1301

// millisecs to sleep inside loops that block waiting for messages
#define CLUSTERSYNC_MS_SLEEP_TIME 10



// Start Defining Message types that are passed back and forth

enum ClusterMsgType {
  NO_MSG                           = 0,
  Ping_MSG                         = 2001,
  Sync_MSG                         = 2002,
  Event_MSG                        = 2003,
  EventBuffer_MSG                  = 2004
};

static const std::string clientGreeting = "hello, server";
static const std::string serverResponse = "hello, client";

class PingMessage {
public:
  PingMessage() : text("") {}
  PingMessage(const std::string& s) : text(s) {}
  
  virtual uint32 type() const {
    return Ping_MSG;
  }
  
  virtual void serialize(BinaryOutput& b) const {
    b.writeString(text);
  }
  
  virtual void deserialize(BinaryInput& b) {
    text = b.readString();
  }
  
  std::string      text;
};


class SyncMessage {
public:
  enum SyncMessageID { 
    SyncNOP=0,
    RequestEvents=1,
    ReadyToSwapBuffers=2,
    ProceedWithSwapBuffers=3,
    Shutdown=4
  };

  SyncMessage() : id(SyncNOP) {}
  SyncMessage(const int32 msg_id) : id(msg_id) {}
  
  virtual uint32 type() const {
    return Sync_MSG;
  }
  
  virtual void serialize(BinaryOutput& b) const {
    b.writeInt32(id);
  }
  
  virtual void deserialize(BinaryInput& b) {
    id = b.readInt32();

    if (id == Shutdown) {
      cout << "Received shutdown message from ClusterSync server." << endl;
      exit(0);
    }
  }

  int32 id;
};



// A message that contains a single event, currently not used
class ClusterEventMsg
{
public:
  ClusterEventMsg()           { _event = NULL; }
  ClusterEventMsg(EventRef e) { _event = e; }

  virtual ~ClusterEventMsg() {}

  uint32 type() const { return Event_MSG; }  

  void serialize(BinaryOutput &b) const {
    alwaysAssertM( ! _event.isNull(), "Null event in serialize method");
    _event->serialize(b);
  }

  void deserialize(BinaryInput &b) {
    _event = new Event("temp-name");
    _event->deserialize(b);
  }

  EventRef getEvent() { return _event; }

private:
  EventRef _event;
};


class ClusterEventBufferMsg
{
public:
  ClusterEventBufferMsg() {};
  ClusterEventBufferMsg(Array<EventRef> eventBuffer) { 
    _eventBuffer = eventBuffer; 
  }

  virtual ~ClusterEventBufferMsg() {};

  uint32 type() const { return EventBuffer_MSG; }  

  void serialize(BinaryOutput &b) const {
    b.writeInt32(_eventBuffer.size());
    
    for (int i=0;i<_eventBuffer.size();i++) {
      _eventBuffer[i]->serialize(b);
    }
    //cout << "serialize len = " << b.getLength() << endl;
  }

  void deserialize(BinaryInput &b) {
    //cout << "deserialize len = " << b.getLength() << endl;
    int32 numEvents = b.readInt32();

    for (int i=0;i<numEvents;i++) {
      EventRef e = new Event("temp-name");
      e->deserialize(b);
      _eventBuffer.append(e);
    }
  }

  void queueEventBuffer() {
    for (int i=0;i<_eventBuffer.size();i++) {
      FsaMgr::queueEvent(_eventBuffer[i]);
    }
  }

private:

  Array<EventRef> _eventBuffer;
};

// End of Messages




// Start of Client code

class ClusterSyncClient
{
public:
  ClusterSyncClient(const std::string &serverHost, int serverPort, int myPort,
            bool verbose=false);

  virtual ~ClusterSyncClient();

  void pollServerForEvents();
  
  void synchronizeSwapBuffers();

private:

  NetworkDevice      *_networkDevice;
  ReliableConduitRef _conduit;
  NetAddress         _serverAddress;
  double             _sleepTime;
  double             _verbose;
};


} // end namespace

#endif

---