FountainNode.h

Go to the documentation of this file.

/* ex: set tabstop=4 expandtab: */
/*                                                                                                                      */
/*  (c) 2004-2006 Iowa State University                                         */
/*      see the LICENSE file in the top level directory         */
/*                                                                                                                      */
/* $Header: /afs/scl/project/cvsroot/fountain/source/nodes/FountainNode.h,v 1.41 2006/03/08 05:09:16 samm Exp $ */
#ifndef FOUNTAIN_NODE_H__
#define FOUNTAIN_NODE_H__

//forward class declarations
template <class T> class FountainNodeCreator;

#include "define.h"
#include "FountainMessage.h"
#include "NodeMessage.h"
#include "FountainWireProt.h"
#include "FountainSocketHandlers.h"
#include "NodeID.h"
#include "FountainErrors.h"
#include "monitor/NodeMonitor.h"
#include "TreeTopology.h"
#include "LokiInclude.h"
#include <bamboo/SSSXML.h>
#include <string>
#include <unistd.h>
#include <memory>
#include <sys/types.h> //for time_t

class FountainNode {
    protected:
                //member variables
        
                FountainSocketHandlers socketHandlers_;
                        
                TreeTopology::ChildNodeContainer children_;
                
                typedef TreeTopology::ChildNodeContainer::iterator childIterator;
                
                typedef TreeTopology::ChildNodeContainer::const_iterator constChildIterator;
                                                
                NodeID myID_;
                
                NodeID parentID_;
                
                FountainWireProtPtr parentConnectionPtr_;
                
        private:
                //member variables
                        
                NodeID masterNodeID_;
        
                NodeMonitorBase::NodeMonitorPtr myNodeInfoPtr_;
                
                time_t parentPulseLastSeen_;
                
        public:
                //member methods
                        
                virtual void checkConnections();
                
        protected:
                //member methods
                                
        virtual NodeResponsePtr processRequest(FountainMessage::MessageAction action, ConstParseMsgPtr request, time_t timeout=0);

                virtual NodeResponsePtr processPingPong(ConstParseMsgPtr request, time_t timeout=0);
                
                void handleParentMessage();
        
                void checkChildren();
                                
                void handleJoin(ConstParseMsgPtr request, FountainWireProtPtr requestConnection);
                
                FountainNode(const NodeID& myID, const NodeID& masterNodeID);
                
                virtual ~FountainNode() {}
        
        class forwardMessageToChildren {
            public:
                forwardMessageToChildren(ConstParseMsgPtr request) : request_(request) {}
                
                                inline void operator() (TreeTopology::ChildNodeContainer::value_type element) {
                    element.second->forwardMessage(request_); 
                }
            private:
                ConstParseMsgPtr request_;
        };
        
    private:
                //member methods
                
                int handleChildMessage(FountainWireProtPtr childCon, const NodeID& childID);
                
                virtual int handleLostChild(const NodeID& childID);
                
                virtual void handleLostParent(const char* message);

        void pokeParent();
        
        void pokeChildren();
        
                void handleSync(ConstParseMsgPtr request, FountainWireProtPtr requestCon);
                
                void handleWakeup();

        virtual void joinMasterNode();
                
                int joinParentNode(const NodeID& newParentID);
                
                void checkParent();
                
                FountainNode& operator=(const FountainNode& rhs);
                
                FountainNode(const FountainNode& rhs);
                
                //these two classes have to be friends of us since they do the actual
                //object instantiation
                template <typename T> friend class Loki::CreateUsingNew;
                template <typename T> friend class FountainNodeCreator;
};

template <class T>
class FountainNodeCreator : public Loki::CreateUsingNew<T> {
        public:
                static T* Create();
};

typedef Loki::SingletonHolder<FountainNode, FountainNodeCreator> SingleFountainNode;

#endif

---