mch/MoteHost.h

   1 #ifndef REMOTE_MCH_MOTEHOST_H
   2 #define REMOTE_MCH_MOTEHOST_H
   3
   4 #include "remote.h"
   5
   6 #include "protocols/tcputil.h"
   7 #include "protocols/Message.h"
   8 #include "protocols/motecontrol/MoteMsg.h"
   9 #include "protocols/host_server/HostMsg.h"
  10 #include "protocols/host_server/MsgMoteConnectionInfoList.h"
  11 #include "protocols/host_server/MsgMoteAddresses.h"
  12
  13 #include "mch/DeviceManager.h"
  14 #include "mch/Mote.h"
  15
  16 namespace remote { namespace mch {
  17
  18 using namespace remote::protocols;
  19 using namespace remote::protocols::host_server;
  20 using namespace remote::protocols::motecontrol;
  21
  22 /** Mote control host.
  23  *
  24  * This class connects the various MCH parts into a mote host.
  25  * On startup it will connect to the mote control server and
  26  * start listening for new control message. It will also open
  27  * the mote plug pipe to receive events from external scripts
  28  * when new motes are attached and detached. Finally, it will
  29  * listen to the TTY of all motes and forward mote console data
  30  * to the mote control server.
  31  */
  32 class MoteHost
  33 {
  34 public:
  35         /** Start mote control host.
  36          *
  37          * @param argc  Number of command line arguments.
  38          * @param argv  String array of command line arguments.
  39          * @return      The result code of the terminating mote host.
  40          */
  41         static int main(int argc, char **argv);
  42
  43 private:
  44         /** Establish connection to server. */
  45         static void lookForServer();
  46
  47         /** Main event loop. */
  48         static void serviceLoop();
  49
  50         /** Handle mote plug/unplug event. */
  51         static void handlePlugEvent();
  52
  53         /** Handle incoming message from mote control server. */
  54         static void handleMessage();
  55
  56         /** Handle command request for mote.
  57          *
  58          * @param mote          The mote to which the request belongs.
  59          * @param addresses     The address information of the mote.
  60          * @param request       The request to handle.
  61          */
  62         static void handleRequest(Mote *mote, MsgMoteAddresses& addresses, MsgRequest& request);
  63
  64         /** Handle serial data for mote.
  65          *
  66          * @param mote          The mote which has incoming serial data.
  67          */
  68         static void handleMoteData(Mote *mote);
  69
  70         /** Send request confirmation message.
  71          *
  72          * @param mote          The mote for which the request was addressed.
  73          * @param command       The request command that was executed.
  74          * @param result        The result of the command execution.
  75          */
  76         static void confirmRequest(Mote *mote, uint8_t command, result_t result);
  77
  78         /** Get the status code of a mote.
  79          *
  80          * @param mote          The mote for which to get the status code.
  81          * @return              The mote status code.
  82          */
  83         static status_t getMoteStatus(Mote *mote);
  84
  85         /** Prepare plug event message payload.
  86          *
  87          * @param motelist      The mote map from which prepare the message.
  88          * @param info          The message payload which to prepare.
  89          * @return              True if the payload should be sent.
  90          */
  91         static bool makeMoteInfoList(motemap_t& motelist, MsgMoteConnectionInfoList& infolist);
  92
  93         /** Rebuild select() file descriptor set.
  94          *
  95          * @param fdset         The file descriptor set to rebuild.
  96          * @return              The number of file descriptors in the fdset.
  97          */
  98         static int rebuildFdSet(fd_set& fdset);
  99
 100         /** Exit handler to be used with atexit.
 101          */
 102         static void handleExit();
 103
 104         /** Handle received signal
 105          *
 106          * @param signo         The number of the received signal.
 107          */
 108         static void handleSignal(int signo);
 109
 110         /** Install signal handlers
 111          *
 112          * Setup handlers to receive exit signals.
 113          */
 114         static void installSignalHandlers();
 115
 116         /** Shutdown the mote host?
 117          *
 118          * @return              True if the mote host should shutdown.
 119          */
 120         static inline bool exitDaemon()
 121         {
 122                 return exitSignal != 0;
 123         }
 124
 125         static int clientsock;          /**< Server connection socket. */
 126         static int plugpipe;            /**< Plug event pipe. */
 127         static Message msg;             /**< Message manager. */
 128         static DeviceManager devices;   /**< Mote device manager. */
 129         static int exitSignal;          /**< Caught exit signal or zero. */
 130
 131         /* Option values. */
 132         static bool daemonize;
 133         static std::string pidFile;
 134         static std::string serverHost;
 135         static uint16_t serverPort;
 136         static uint64_t retryInterval;
 137         static std::string eventPipe;
 138         static std::string devicePath;
 139 };
 140
 141 }}
 142
 143 #endif