BaseRpc.h

Go to the documentation of this file.

// Copyright (C) 2006 Institut fuer Telematik, Universitaet Karlsruhe (TH)
//
// 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.
//

#ifndef __BASERPC_H_
#define __BASERPC_H_

#include <oversim_mapset.h>

#include <omnetpp.h>

#include <RpcState.h>
#include <RpcListener.h>
#include <RpcMacros.h>

#include <ProxNodeHandle.h>

class UnderlayConfigurator;
class GlobalStatistics;
class GlobalParameters;
class NeighborCache;
class CryptoModule;
class WaitingContexts;
class BaseOverlay;

class ProxListener;

class BaseRpc : public RpcListener,
                public cSimpleModule
{
public:

    BaseRpc();

    const NodeHandle& getThisNode() { return thisNode; };

    simtime_t getUdpTimeout() { return rpcUdpTimeout; };

protected:

    // overlay identity
    NodeHandle thisNode;   
    BaseOverlay* overlay;

    // overlay common parameters
    bool debugOutput;           
    // references to global modules
    GlobalStatistics* globalStatistics;  
    virtual bool internalHandleRpcCall(BaseCallMessage* msg);

    virtual void internalHandleRpcResponse(BaseResponseMessage* msg,
                                           cPolymorphic* context, int rpcId,
                                           simtime_t rtt);

    virtual void internalHandleRpcTimeout(BaseCallMessage* msg,
                                          const TransportAddress& dest,
                                          cPolymorphic* context,
                                          int rpcId, const OverlayKey& destKey);
    void initRpcs();

    void finishRpcs();

    virtual void internalHandleRpcMessage(BaseRpcMessage* msg);

    inline uint32_t sendRouteRpcCall(CompType destComp,
                                     const TransportAddress& dest,
                                     const OverlayKey& destKey,
                                     BaseCallMessage* msg,
                                     cPolymorphic* context = NULL,
                                     RoutingType routingType = DEFAULT_ROUTING,
                                     simtime_t timeout = -1,
                                     int retries = 0,
                                     int rpcId = -1,
                                     RpcListener* rpcListener = NULL)
    {
        if (dest.isUnspecified() && destKey.isUnspecified())
            opp_error("BaseRpc::sendRouteRpcCall() with both key and "
                      "transportAddress unspecified!");
        return sendRpcCall(ROUTE_TRANSPORT, destComp, dest, destKey, msg,
                           context, routingType, timeout, retries,
                           rpcId, rpcListener);
    }

    inline uint32_t sendRouteRpcCall(CompType destComp,
                                     const OverlayKey& destKey,
                                     BaseCallMessage* msg,
                                     cPolymorphic* context = NULL,
                                     RoutingType routingType = DEFAULT_ROUTING,
                                     simtime_t timeout = -1,
                                     int retries = 0,
                                     int rpcId = -1,
                                     RpcListener* rpcListener = NULL)
    {
        return sendRpcCall(ROUTE_TRANSPORT, destComp,
                           TransportAddress::UNSPECIFIED_NODE,
                           destKey, msg, context, routingType, timeout,
                           retries, rpcId, rpcListener);
    }

    inline uint32_t sendRouteRpcCall(CompType destComp,
                                     const TransportAddress& dest,
                                     BaseCallMessage* msg,
                                     cPolymorphic* context = NULL,
                                     RoutingType routingType = DEFAULT_ROUTING,
                                     simtime_t timeout = -1,
                                     int retries = 0,
                                     int rpcId = -1,
                                     RpcListener* rpcListener = NULL)
    {
        return sendRpcCall(ROUTE_TRANSPORT, destComp, dest,
                           OverlayKey::UNSPECIFIED_KEY, msg, context,
                           routingType, timeout, retries, rpcId, rpcListener);
    }

    inline uint32_t sendUdpRpcCall(const TransportAddress& dest,
                                   BaseCallMessage* msg,
                                   cPolymorphic* context = NULL,
                                   simtime_t timeout = -1,
                                   int retries = 0, int rpcId = -1,
                                   RpcListener* rpcListener = NULL)
    {
        return sendRpcCall(UDP_TRANSPORT, INVALID_COMP, dest,
                           OverlayKey::UNSPECIFIED_KEY, msg, context,
                           NO_OVERLAY_ROUTING, timeout, retries, rpcId,
                           rpcListener);
    }

    inline uint32_t sendInternalRpcCall(CompType destComp,
                                        BaseCallMessage* msg,
                                        cPolymorphic* context = NULL,
                                        simtime_t timeout = -1,
                                        int retries = 0,
                                        int rpcId = -1,
                                        RpcListener* rpcListener = NULL)
    {
        return sendRpcCall(INTERNAL_TRANSPORT, destComp,
                           TransportAddress::UNSPECIFIED_NODE,
                           OverlayKey::UNSPECIFIED_KEY, msg, context,
                           NO_OVERLAY_ROUTING, timeout, retries, rpcId,
                           rpcListener);
    }

    void cancelRpcMessage(uint32_t nonce);

    void cancelAllRpcs();

    void sendRpcResponse(TransportType transportType,
                         CompType destComp,
                         const TransportAddress &dest,
                         const OverlayKey &destKey,
                         BaseCallMessage* call,
                         BaseResponseMessage* response);

    void sendRpcResponse(BaseCallMessage* call,
                         BaseResponseMessage* response);

    int pingNode(const TransportAddress& dest,
                  simtime_t timeout = -1,
                  int retries = 0,
                  cPolymorphic* context = NULL,
                  const char* caption = "PING",
                  RpcListener* rpcListener = NULL,
                  int rpcId = -1,
                  TransportType transportType = INVALID_TRANSPORT);

    virtual bool handleRpcCall(BaseCallMessage* msg);

    virtual CompType getThisCompType() = 0;

    CompType thisCompType;

    virtual void sendMessageToUDP(const TransportAddress& addr,
                                  cPacket* message,
                                  simtime_t delay = SIMTIME_ZERO)
    {
        throw cRuntimeError("sendMessageToUDP() not implemented");
    };

    virtual void pingResponse(PingResponse* pingResponse,
                              cPolymorphic* context, int rpcId,
                              simtime_t rtt);

    virtual void pingTimeout(PingCall* pingCall,
                             const TransportAddress& dest,
                             cPolymorphic* context,
                             int rpcId);

    NeighborCache *neighborCache; 
    CryptoModule *cryptoModule; 
    int numPingSent;
    int bytesPingSent;
    int numPingResponseSent;
    int bytesPingResponseSent;

    bool internalHandleMessage(cMessage* msg);


private:

    virtual void handleTimerEvent(cMessage* msg);

    uint32_t sendRpcCall(TransportType transportType,
                         CompType destComp,
                         const TransportAddress& dest,
                         const OverlayKey& destKey,
                         BaseCallMessage* msg,
                         cPolymorphic* context,
                         RoutingType routingType,
                         simtime_t timeout, int retries,
                         int rpcId, RpcListener* rpcListener);

    void sendRpcMessageWithTransport(TransportType transportType,
                                     CompType destComp,
                                     RoutingType routingType,
                                     const std::vector<TransportAddress>& sourceRoute,
                                     const OverlayKey& destKey,
                                     BaseRpcMessage* message);

    virtual void internalSendRouteRpc(BaseRpcMessage* message,
                                      const OverlayKey& destKey,
                                      const std::vector<TransportAddress>&
                                      sourceRoute,
                                      RoutingType routingType) = 0;

    virtual void internalSendRpcResponse(BaseCallMessage* call,
                                         BaseResponseMessage* response) = 0;

    void pingRpcCall(PingCall* call);
    void pingRpcResponse(PingResponse* response, cPolymorphic* context,
                         int rpcId, simtime_t rtt);
    void pingRpcTimeout(PingCall* pingCall, const TransportAddress& dest,
                        cPolymorphic* context, int rpcId);

    typedef UNORDERED_MAP<int,RpcState> RpcStates;

    int rpcsPending;
    RpcListener* defaultRpcListener;
    RpcStates rpcStates;
    simtime_t rpcUdpTimeout, rpcKeyTimeout;
    bool optimizeTimeouts;
    bool rpcExponentialBackoff;
};

#endif