gzDistRemoteChannel.h

Go to the documentation of this file.

//*****************************************************************************
// File         : gzDistRemoteChannel.h
// Module       : gzRemoteDistribution
// Description  : Definition of gzDistRemoteChannel
// Author       : Anders Sandblad, Christian Andersson
// Product      : GizmoDistribution 2.1.1
//
// Copyright © 2004 - Saab Training Systems AB, Sweden
//
// NOTE:    GizmoDistribution is a toolkit used for implementing distributed 
//          objects and events in C++
//
//
// Revision History...
//
// Who  Date    Description
//
// XAA  031113  Created file 
//
//******************************************************************************
#ifndef __GZ_DIST_REMOTE_CHANNEL_H__
#define __GZ_DIST_REMOTE_CHANNEL_H__

// Includes
#include "gzDistBase.h"
#include "gzDistRemoteMessage.h"
#include "gzDistEncoder.h"

// Forward declarations
class gzDistProtocolInterface;
class gzDistTransportInterface;


//-----------------------------------------------------------------------------

// Protocol version
const gzUByte GZ_DIST_PROTOCOL_VERSION      = 0x14; // 1.4
const gzUShort GZ_DIST_PROTOCOL_HEADER_SIZE = 29;   // Bytes

// Positions in gzDistProtocolMessageHeader data
const gzUByte GZ_DIST_PROTOCOL_MESSAGE_VERSION_POS                  = 0;
const gzUByte GZ_DIST_PROTOCOL_MESSAGE_PRIO_POS                     = 1;
const gzUByte GZ_DIST_PROTOCOL_MESSAGE_CHANNEL_POS                  = 1;
const gzUByte GZ_DIST_PROTOCOL_MESSAGE_MESSAGE_TYPE_POS             = 2;
const gzUByte GZ_DIST_PROTOCOL_MESSAGE_SENDER_PROCESS_ID_POS        = 3;
const gzUByte GZ_DIST_PROTOCOL_MESSAGE_SENDER_MACHINE_ID_POS        = 7;
const gzUByte GZ_DIST_PROTOCOL_MESSAGE_SENDER_INDEX_POS             = 11;
const gzUByte GZ_DIST_PROTOCOL_MESSAGE_FRAGMENT_LENGTH_POS          = 15;
const gzUByte GZ_DIST_PROTOCOL_MESSAGE_DESTINATION_PROCESS_ID_POS   = 17;
const gzUByte GZ_DIST_PROTOCOL_MESSAGE_DESTINATION_MACHINE_ID_POS   = 21;
const gzUByte GZ_DIST_PROTOCOL_MESSAGE_FRAGMENT_INDEX_POS           = 25;
const gzUByte GZ_DIST_PROTOCOL_MESSAGE_FRAGMENTS_POS                = 27;

enum gzDistTransportType
{
    GZ_DIST_MULTICAST,  
    GZ_DIST_BROADCAST,  
    GZ_DIST_TCP         
};

//----------------------- gzDistProtocolMessageHeader -------------------------

// Used internal and by sniffer.
class GZ_REMOTE_EXPORT gzDistProtocolMessageHeader
{
    public:
        gzDistProtocolMessageHeader();
        ~gzDistProtocolMessageHeader();

        gzVoid setVersion(gzUByte version);
        gzVoid setChannel(gzUByte channel);
        gzVoid setMessageType(gzUByte id);
        gzVoid setSenderProcessID(gzULong id);
        gzVoid setSenderMachineID(gzULong id);
        gzVoid setSenderIndex(gzULong index);
        gzVoid setFragmentLength(gzUShort length);
        gzVoid setDestinationProcessID(gzULong id);
        gzVoid setDestinationMachineID(gzULong id);
        gzVoid setFragmentIndex(gzUShort index);
        gzVoid setFragments(gzUShort fragments);
        gzVoid setPrio(gzBool prio);

        gzUByte getVersion();
        gzUByte getChannel();
        gzUByte getMessageType();
        gzULong getSenderProcessID();
        gzULong getSenderMachineID();
        gzULong getSenderIndex();
        gzUShort getFragmentLength();
        gzULong getDestinationProcessID();
        gzULong getDestinationMachineID();
        gzUShort getFragmentIndex();
        gzUShort getFragments();
        gzBool getPrio();

        gzVoid setBuffer(gzUByte* buffer);
        const gzUByte* getBuffer();
    
    private:

        inline gzUShort readShortVal(const gzUByte pos);
        inline gzULong readLongVal(const gzUByte pos);

        inline gzVoid writeShortVal(const gzUShort val, const gzUByte pos);
        inline gzVoid writeLongVal(const gzULong val, const gzUByte pos);

        gzULong m_longVal;
        gzUShort m_shortVal;
        gzUByte* m_data;
        gzUByte* m_bytePtr;
        gzBool m_littleEndian;
};


//-------------------------- gzDistDisposeMessage -----------------------------

// Internal
class gzDistDisposeRemoteMessage
{
    public:
        gzDistDisposeRemoteMessage();

        ~gzDistDisposeRemoteMessage();

        gzDistRemoteMessageSession* remoteMessage;

        gzULong lastMessageIndex;

        gzUInt lastFragmentIndex;
};


//---------------------- gzDistInstanceIDCompareClass -------------------------

// Internal
class gzDistInstanceIDCompareClass
{
    public:
        gzDistInstanceIDCompareClass(const gzDistInstanceID& instanceID) : m_instanceId(instanceID)
        {   
        }

        ~gzDistInstanceIDCompareClass()
        {}
        
        gzULong hash() const
        {
            return m_instanceId.processID;
        }

        gzBool operator ==(const gzDistInstanceIDCompareClass& right)
        {
            return (m_instanceId == right.m_instanceId);                 
        }

        const gzDistInstanceID& getInstanceID()
        {
            return m_instanceId;
        }

    
    private:

        gzDistInstanceID m_instanceId;
};


//------------------------ gzDistDisposeBufferData ------------------------------

// Internal
class gzDistRemoteInstanceIndex
{
    public:
        gzDistRemoteInstanceIndex(gzULong index) : m_acceptedIndex(index), m_receivedIndex(index),
            m_numberOfResends(0), m_acceptedFragmentIndex(0), m_totalFragments(0),
            m_lastAccept(0), m_waitingForAck(FALSE) {}
        
        ~gzDistRemoteInstanceIndex() {}

        gzDouble m_lastAccept;

        // Last accepted receive index.
        gzULong m_acceptedIndex;

        // Last received index.
        gzULong m_receivedIndex;

        // Last accepted receive fragment index.
        gzUInt m_acceptedFragmentIndex;

        // Total number of fragments in message.
        gzUInt m_totalFragments;

        // How many resends that has been done for current index.
        gzULong m_numberOfResends;

        // Tells if we are waiting from ack from this instance.
        gzBool m_waitingForAck;
};

//---------------------- gzDistResendRequestItem ----------------------

class gzDistResendRequestItem
{
    public:
        gzDistResendRequestItem(const gzDistInstanceID& id) : instanceId(id) {}
        ~gzDistResendRequestItem(){}

        const gzDistInstanceID instanceId;
        gzULong index;
        gzUInt fragment;
};

//----------------------------- gzDistRemoteChannel ---------------------------


class gzDistRemoteChannel : public gzDistRemoteChannelInterface
{
    public:
        

        GZ_REMOTE_EXPORT gzDistRemoteChannel(gzUInt reliableBufferSize = 0);

        GZ_REMOTE_EXPORT virtual ~gzDistRemoteChannel();



        GZ_REMOTE_EXPORT gzBool setTransport(gzDistTransportInterface* transport, gzDistEncoderInterface* encoder = NULL);

        GZ_REMOTE_EXPORT gzBool open();
        
        GZ_REMOTE_EXPORT gzVoid close();

        GZ_REMOTE_EXPORT gzBool isOpen();
        
        GZ_REMOTE_EXPORT gzBool send(gzDistRemoteMessage* message);


        GZ_REMOTE_EXPORT gzBool receive(gzDistRemoteMessagePtr& message);

        GZ_REMOTE_EXPORT gzUInt getProtocolHeaderSize();

        GZ_REMOTE_EXPORT gzVoid onTick();

        GZ_REMOTE_EXPORT gzBool hasPendingData();

    private:
        
        // Add or update a resend request.
        gzVoid setReply(const gzDistInstanceID& sendTo, gzULong messageIndex, gzUInt fragmentIndex);
        
        gzBool processResend();

        gzVoid sendBufferedMessages(gzUInt maxMessages);
        
        // Send a ackowledge request.
        gzVoid requestAck(const gzDistInstanceID& instanceId);
        
        // Send a reply on a ackowledge request.
        gzVoid replyAckRequest(const gzDistInstanceID& instanceId, gzULong index, gzUShort fragmentIndex);

        gzBool receiveInternal(gzDistRemoteMessagePtr& message);

        // Parse buffer and create message
        gzBool parseBuffer(gzDistSerializeMemoryData* buffer, gzDistRemoteMessagePtr& message);

        // Serialize message to buffer
        gzBool serializeMessage(gzDistRemoteMessage* message);

        // Write a header in the beginning of the buffer.
        gzVoid writeHeaders(gzDistRemoteMessage* message, gzUInt messageIndex);

        gzBool parseServerMessage(gzDistRemoteMessageServer* message, gzSerializeAdapter* adapter);

        gzBool parseSessionMessage(gzDistRemoteMessageSession* sessionMessage);
        
        gzBool serializeServerMessage(gzSerializeAdapter* adapter, const gzDistRemoteMessageServer* message);

    // --- Fragmented data managing methods ---

        // Add a fragment to a message
        gzBool disposeFragment(const gzDistInstanceID& instanceID, gzDistSerializeMemoryData* buffer, gzULong messageIndex, gzUInt fragmentIndex);

        // Gets and remove a message. The fragments param is only to verify the number of fragments.
        gzDistRemoteMessageSession* removeMessage(const gzDistInstanceID& instanceID, gzUInt fragments);

    // --- 

        // Send a request on resend on missed data.
        gzVoid requestResend(const gzDistInstanceID& sendTo, gzDistRemoteInstanceIndex* instance);

        // Reply requested data.
        gzBool replyResendRequest(gzDistResendRequestItem* requestItem);

        // Return true when we have reached end of resend buffer.
        gzBool bufferMessage(gzDistRemoteMessage* message);

        // Send message to transtporters.
        gzVoid sendMessage(gzDistRemoteMessage* message, gzUInt fromFragment);

        gzInt receiveMessage(gzUByte* receiveBuffer, gzUInt bufferSize);

        // This method is needed for other processes to verify that no messages is missed.
        gzVoid distributeIndex();

        gzVoid sendBufferStartIndex(const gzDistInstanceID& sendTo, gzULong beginningOfBuffer);

        // Copy (not allowed)
        gzDistRemoteChannel(const gzDistRemoteChannel&);
    
        // Assignment (not allowed)
        gzDistRemoteChannel& operator=(const gzDistRemoteChannel&);

        gzBool isNextExpected(gzULong messageIndex, gzUInt fragmentIndex, gzDistRemoteInstanceIndex* instance);

        gzVoid removeInstance(const gzDistInstanceID& instanceId);

        gzVoid removeAckRequest(const gzDistInstanceID& instanceId);

        gzVoid sendShutdown();

        gzVoid buildAckList();

        gzVoid requestAcks();

        gzVoid manageSpecialCommands(gzUByte command);

    // --- Data ---

        gzDistProtocolMessageHeader m_messageHeader;

        gzDistSerializeAdapterMemory m_memoryAdapter;

        // For fragment managing.
        gzDict<gzDistInstanceIDCompareClass, gzDistDisposeRemoteMessage> m_messageStore;

    // --- Reliable management data ---

        // For reliable managing
        gzDict<gzDistInstanceIDCompareClass, gzDistRemoteInstanceIndex> m_instanceStore;

        // Used to store received messages temporary during resend processing.
        gzRefList<gzDistRemoteMessage> m_tempRecMessages;

        // Next time to reply resend requests.
        gzDouble m_nextResendTime;

        gzList<gzDistResendRequestItem> m_resendRequests;

        // The sender index from this instance. Index start at index = 1.
        gzULong m_messageIndex;

        // Reliable
        gzBool m_reliable;

        // A buffer containing this instance data.
        gzArray<gzRefPointer<gzDistRemoteMessage> > m_resendBuffer;

        // Current position in m_resendBuffer
        gzUInt m_bufferIndex;

        // The message index where m_resendBuffer begins.
        gzUInt m_bufferPosition;

        // Time for last tick!!
        gzDouble m_lastTick;

        // Time for last index distribution.
        gzDouble m_lastIndexDistribution;

        // The number of instances we are expecting ack from.
        gzUInt m_waitingForAckCounter;

        // Messages will temporary be placed here during 'wait for ack'.
        gzRefList<gzDistRemoteMessage> m_tempSendMessages;
    
    // ---

        // Is open?
        gzBool m_open;

        // Transport (mandatory)
        gzDistTransportInterface* m_transport;

        // Encoder (optional)
        gzDistEncoderInterface* m_encoder;

        // A handle to a buffer when data is receiving.
        gzDistSerializeMemoryData* m_receiveBuffer;

        // A receive buffer used when any type of encoder is used.
        gzUByte* m_codeReceiveBuffer;
};


//-------------------------------- Utilities ----------------------------------

/*  Create a channel with a default transport installed.
    The default server transport uses UDP multicast
    on group GZ_DIST_DEFAULT_IP_ADDRESS and port GZ_DIST_DEFAULT_SERVER_PORT.
    These constants are defined in gzDistBase.h
    \param reliable         Set this to TRUE if a reliable connection is desired.
                            Zero gives best-effort.
    \param transportType    Set this to GZ_DIST_BROADCAST to create a broadcast channel.
                            GZ_DIST_MULTICAST (default) will create a multicast channel.
                            It is possible to use a TCP copnnection by seting the parameter to GZ_DIST_TCP.
                            This will create a TCP client. In this case, the gzDistRouter is needed.
                            gzDistRouter is a tool that can be downloaded from the homepage of GizmoSDK.
    \param encoder          Use this to add a compressor, crypto etc.
    \return                 A pointer to a gzDistRemoteChannel.
    \note                   A reliable mode GizmoDistribution process cannot cooperate
                            with a best-effort mode GizmoDistribution process.
    \sa                     gzDistRemoteChannel::gzDistRemoteChannel() \n
                            gzDistCreateDefaultSessionChannel() \n
                            gzDistCreateChannel()*/
GZ_REMOTE_EXPORT gzDistRemoteChannel* gzDistCreateDefaultServerChannel(gzBool reliable = FALSE, gzDistTransportType transportType = GZ_DIST_MULTICAST, gzDistEncoderInterface* encoder = NULL);



GZ_REMOTE_EXPORT gzDistRemoteChannel* gzDistCreateDefaultSessionChannel(gzBool reliable = FALSE, gzDistTransportType transportType = GZ_DIST_MULTICAST, gzDistEncoderInterface* encoder = NULL);



GZ_REMOTE_EXPORT gzDistRemoteChannel* gzDistCreateChannel(gzUInt reliableBufferSize, gzDistTransportType transportType, gzDistEncoderInterface* encoder, const gzString& address, gzUInt port, const gzString& iface = "0.0.0.0");


#endif

---