App/include/Tourist/App/CacheXferWorker.h

   1 #ifndef CACHEEXPORTERWORKER_
   2 #define CACHEEXPORTERWORKER_
   3
   4 #include "Tourist/LocalNode.h"
   5 #include "Tourist/Util/Util.h"
   6 #include "Tourist/AvlCache.h"
   7 #include "Tourist/Message/RemoteNode.h"
   8 #include "Tourist/Message/MessageDispatcher.h"
   9 #include "Tourist/Message/MessageNotification.h"
  10 #include "Poco/Runnable.h"
  11 #include "Poco/AutoPtr.h"
  12 #include "Poco/NotificationQueue.h"
  13
  14 using Tourist::Message::RemoteNode;
  15 using Tourist::Message::MessageDispatcher;
  16 using Tourist::Message::MessageNotification;
  17
  18 using Poco::Runnable;
  19 using Poco::NotificationQueue;
  20 using Poco::AutoPtr;
  21
  22 namespace Tourist {
  23 //forwar declaration of LocalNode
  24   class LocalNode;
  25 namespace Message {
  26   class MsgCacheXferRequest;
  27 }
  28 }
  29
  30 namespace Tourist {
  31 namespace App {
  32
  33 class CacheXferWorker : public Runnable
  34 {
  35 public:
  36
  37   /**
  38    * Creates a worker thread.
  39    *
  40    * @param contactNode Remote node to ask for nodes.
  41    * @param threadName Name of the thread
  42    * @param request Encapsulate the request parameters.
  43    * @param dispatcher Instance of message bus to use for message communication
  44    */
  45   CacheXferWorker (RemoteNode *contactNode, string threadName,
  46        Tourist::Message::MsgCacheXferRequest *request, MessageDispatcher *dispatcher,
  47        int timeout = 5);
  48
  49   CacheXferWorker (RemoteNode *contactNode, string threadName, \
  50      Tourist::Message::MsgCacheXferRequest *remoteRequest, MessageDispatcher *dispatcher,
  51       LocalNode *localnode, int timeout = 5);
  52
  53   ~CacheXferWorker();
  54
  55  //void changeState(int event);
  56
  57   void stopWorker();
  58
  59   void startWorker();
  60
  61   bool isStopped();
  62
  63   //call by thread
  64   void run();
  65
  66   //Return the container holding the result of cache exchange.
  67   NodeSet getNodes();
  68
  69   //Return the status of operation performed by this worker thread.
  70   int getStatus();
  71
  72   /**
  73    * Callback method from the message bus (MessageDispatcher)
  74    * This method enquee the message object as delivered by dispatcher
  75    * thread this is to ensure the no delay for message delivery task.
  76    */
  77   void onMessage(const AutoPtr<MessageNotification>& notification);
  78
  79   int getTaskType();
  80
  81   static int TASK_REMOTE_TO_LOCAL;//Transfer routing cache from remote node to local.
  82   static int TASK_LOCAL_TO_REMOTE;//Transfer routing cache from local node to remote.
  83
  84   static int STATUS_UNKNOWN; //Initial transfer status
  85   static int STATUS_TIMEDOUT;// Transfer failed as operation timedout. Usually this means
  86                              // an error in communication.
  87   static int STATUS_TIMEDOUT_PARTIAL; //Transfer failed as operation timedout. Usually this means
  88                          // that there was some partial transfer of cache.
  89   static int STATUS_CONNECT_FAILED; //indicates that remote node is not connected.
  90   static int STATUS_OK;
  91
  92   //< state codes declaration > //
  93   const static int AWAIT_RESPONSE; //indicates that worker is waiting for the transfer to finish.
  94   const static int PROCESSING_RESPONSE; //indicates that worker is/was processing response
  95
  96   //<event code>//
  97   static int FINISHED;
  98   static int RESPONSE_RECVD;
  99   static int RESPONSE_OK;
 100   static int RESPONSE_PARTIAL;
 101   static int STOPPED; //indicate that controller asked for stopping this thread
 102
 103   void duplicate();
 104
 105   void release();
 106
 107 private:
 108
 109   //called to clean-up any resources used by this
 110   //thread.
 111   void cleanUp();
 112
 113   void processResponse();
 114
 115   void processRequest();
 116
 117   RemoteNode *contactNode;
 118
 119   //suggest if this worker thread should run or not.
 120   //No gurantte is made that if the thread will actually be running
 121   //or not
 122   bool shouldbeRunning;
 123
 124   //Indicates whether the thread is actually stopped or not
 125   bool stopped;
 126
 127   //Name of the worker thread
 128   string threadName;
 129
 130   Logger &logger;
 131
 132   //Result of worker threads are put in this set to let controller
 133   //fetch it.
 134   NodeSet result;
 135
 136   //status are mentioned in the controller class 'CacheXfer'
 137   int state, status;
 138
 139   int timeout;
 140
 141   //Notificaiton
 142   NotificationQueue queue;
 143
 144   //Type of work this worker thread is going to do. Currently
 145   //these tasks includes (a) Asking a remote node to transfer its cache
 146   //with a specified cache type and range of levels. (b) To transfer
 147   //cache of LocalNode to remote node.
 148   int taskType;
 149
 150   Tourist::Message::MsgCacheXferRequest *xferRequest;
 151
 152   MessageDispatcher *dispatcher;
 153
 154   Tourist::LocalNode *node;
 155
 156   //for reference counting
 157   int rc;
 158   static int ref_count;
 159 };
 160
 161 } // namespace App
 162 } // namespace Tourist
 163
 164
 165 #endif /*CACHEEXPORTERWORKER_*/