BaseApp.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 __BASEAPP_H_
#define __BASEAPP_H_

//class GlobalNodeList;
class GlobalStatistics;
class UnderlayConfigurator;
class NodeHandle;
class OverlayKey;
class CommonAPIMessage;

#include <omnetpp.h>

#include "NodeVector.h"
#include <BaseRpc.h>
#include <BaseTcpSupport.h>
#include <INotifiable.h>
#include <BaseOverlay.h>


class BaseApp : public INotifiable, public BaseRpc, public BaseTcpSupport
{
private:

    void forwardResponse(const OverlayKey& key, cPacket* msg,
                         const NodeHandle& nextHopNode);

    void handleCommonAPIMessage(CommonAPIMessage* commonAPIMsg);

protected:
    int numInitStages() const;

    void initialize(int stage);

    virtual void initializeApp(int stage);

    void handleMessage(cMessage* msg);

    virtual void receiveChangeNotification(int category, const cPolymorphic * details);

    virtual void handleTransportAddressChangedNotification();

    virtual void handleNodeLeaveNotification();

    virtual void handleNodeGracefulLeaveNotification();

    void finish();

    virtual void finishApp();

    // common API for structured p2p-overlays
    inline void callRoute(const OverlayKey& key, cPacket* msg,
                          const TransportAddress& hint
                              = TransportAddress::UNSPECIFIED_NODE,
                          RoutingType routingType = DEFAULT_ROUTING)
    {
        std::vector<TransportAddress> sourceRoute;
        sourceRoute.push_back(hint);
        callRoute(key, msg, sourceRoute, routingType);
    }

    void callRoute(const OverlayKey& key, cPacket* msg,
                   const std::vector<TransportAddress>& sourceRoute,
                   RoutingType routingType = DEFAULT_ROUTING);

    virtual void deliver(OverlayKey& key, cMessage* msg);

    virtual void forward(OverlayKey* key, cPacket** msg,
                         NodeHandle* nextHopNode);

    virtual void update(const NodeHandle& node, bool joined);

    inline NodeVector* callLocalLookup(const OverlayKey& key, int num,
                                       bool safe)
    {
        return overlay->local_lookup(key, num, safe);
    };

    inline NodeVector* callNeighborSet(int num)
    {
        return overlay->neighborSet(num);
    };

    inline bool isSiblingFor(const NodeHandle& node, const OverlayKey& key,
                             int numSiblings, bool* err)
    {
        return overlay->isSiblingFor(node, key, numSiblings, err);
    };

    //virtual void handleTimerEvent(cMessage* msg);

    virtual void handleLowerMessage(cMessage* msg);

    virtual void handleUpperMessage(cMessage* msg);

    virtual void handleUDPMessage(cMessage* msg);

    virtual void handleReadyMessage(CompReadyMessage* msg);

    virtual void bindToPort(int port);

    virtual void sendMessageToUDP(const TransportAddress& destAddr,
                                  cPacket *msg,
                                  simtime_t delay = SIMTIME_ZERO);

    virtual void handleTraceMessage(cMessage* msg);

    void sendMessageToLowerTier(cPacket* msg);

    UnderlayConfigurator* underlayConfigurator; 
    GlobalNodeList* globalNodeList; 
    GlobalStatistics* globalStatistics; 
    NotificationBoard* notificationBoard; 
    // parameters
    bool debugOutput; 
    // statistics
    int numOverlaySent; 
    int bytesOverlaySent; 
    int numOverlayReceived; 
    int bytesOverlayReceived; 
    int numUdpSent; 
    int bytesUdpSent; 
    int numUdpReceived; 
    int bytesUdpReceived; 
    simtime_t creationTime; 
public:

    BaseApp();

    virtual ~BaseApp();



protected://methods: rpc handling
    bool internalHandleRpcCall(BaseCallMessage* msg);
    void internalHandleRpcResponse(BaseResponseMessage* msg,
                                   cPolymorphic* context, int rpcId,
                                   simtime_t rtt);

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

    virtual CompType getThisCompType();
    void sendReadyMessage(bool ready = true,
                          const OverlayKey& nodeId =
                              OverlayKey::UNSPECIFIED_KEY);

private:
    void internalSendRpcResponse(BaseCallMessage* call,
                                 BaseResponseMessage* response);
};

#endif