ACE/netsvcs/lib/TS_Clerk_Handler.h

   1 /* -*- C++ -*- */
   2
   3 //=============================================================================
   4 /**
   5  *  @file    TS_Clerk_Handler.h
   6  *
   7  *  @author Prashant Jain
   8  */
   9 //=============================================================================
  10
  11
  12 #ifndef ACE_TS_CLERK_HANDLER_H
  13 #define ACE_TS_CLERK_HANDLER_H
  14
  15 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  16 # pragma once
  17 #endif /* ACE_LACKS_PRAGMA_ONCE */
  18
  19 #include "ace/SOCK_Connector.h"
  20 #include "ace/Svc_Handler.h"
  21 #include "ace/Connector.h"
  22 #include "ace/MMAP_Memory_Pool.h"
  23 #include "ace/Malloc_T.h"
  24 #include "ace/Null_Mutex.h"
  25 #include "ace/svc_export.h"
  26 #include "ace/os_include/os_dirent.h"
  27
  28 #include "Time_Request_Reply.h"
  29
  30 /**
  31  * @class ACE_Time_Info
  32  *
  33  * @brief A simple struct containing delta time and a sequence number.
  34  */
  35 class ACE_Time_Info
  36 {
  37
  38 public:
  39   time_t delta_time_;
  40
  41   ACE_UINT32 sequence_num_;
  42 };
  43
  44 class ACE_TS_Clerk_Processor;  // forward declaration
  45
  46 #if defined ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION_EXPORT
  47 template class ACE_Svc_Export ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>;
  48 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION_EXPORT */
  49
  50 /**
  51  * @class ACE_TS_Clerk_Handler
  52  *
  53  * @brief The Clerk Handler provides the interface that is used by the
  54  * Clerk Processor to send time update requests to all the
  55  * servers. It obtains these updates from the servers and passes
  56  * the updates to the Clerk Processor
  57  *
  58  * The Clerk Processor uses send_request() to send a request for
  59  * time update to a server. The Clerk Handler internally computes
  60  * the round trip delay for the reply to come back. Once it gets
  61  * the reply back from the server (handle_input), it adjusts the
  62  * system time using the round trip delay estimate and then
  63  * passes the delta time by reference back to the Clerk
  64  * Processor.
  65  */
  66 class ACE_Svc_Export ACE_TS_Clerk_Handler : public ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>
  67 {
  68 public:
  69   /// Default constructor.
  70   ACE_TS_Clerk_Handler (ACE_TS_Clerk_Processor *processor = 0,
  71                         ACE_INET_Addr &addr = (ACE_INET_Addr &) ACE_Addr::sap_any);
  72
  73   // = Set/get the current state
  74   enum State
  75   {
  76     IDLE = 1,      // Prior to initialization.
  77     CONNECTING,    // During connection establishment.
  78     ESTABLISHED,   // Connection is established and active.
  79     DISCONNECTING, // In the process of disconnecting.
  80     FAILED         // Connection has failed.
  81   };
  82
  83   // = Set/get the current state.
  84   State state (void);
  85   void state (State);
  86
  87   // = Set/get the current retry timeout delay.
  88   long timeout (void);
  89   void timeout (long);
  90
  91   // = Set/get the maximum retry timeout delay.
  92   long max_timeout (void);
  93   void max_timeout (long);
  94
  95   /// Activate this instance of the <ACE_TS_Clerk_Handler>
  96   /// (called by the <ACE_TS_Clerk_Processor>).
  97   virtual int open (void * = 0);
  98
  99   /// Return the handle of the message_fifo_;
 100   virtual ACE_HANDLE get_handle (void) const;
 101
 102   /// Called when object is removed from the ACE_Reactor
 103   virtual int handle_close (ACE_HANDLE = ACE_INVALID_HANDLE,
 104                             ACE_Reactor_Mask = ACE_Event_Handler::ALL_EVENTS_MASK);
 105
 106   /// Receive time update from a server.
 107   virtual int handle_input (ACE_HANDLE);
 108
 109   /// Restart connection asynchronously when timeout occurs.
 110   virtual int handle_timeout (const ACE_Time_Value &tv,
 111                               const void *arg);
 112
 113   /// Get/Set remote addr
 114   void remote_addr (ACE_INET_Addr &addr);
 115   ACE_INET_Addr &remote_addr (void);
 116
 117   /// Send request for time update to the server as well as return the
 118   /// current time info by reference.
 119   int send_request (ACE_UINT32 sequence_num,
 120                     ACE_Time_Info &time_info);
 121
 122 protected:
 123   /// Handle SIGPIPE.
 124   virtual int handle_signal (int signum,
 125                              siginfo_t *,
 126                              ucontext_t *);
 127
 128   static void stderr_output (int = 0);
 129
 130   enum
 131     {
 132       MAX_RETRY_TIMEOUT = 300
 133       // 5 minutes is the maximum timeout.
 134     };
 135
 136 private:
 137   /// Receive a reply from a server containing time update
 138   int recv_reply (ACE_Time_Request &reply);
 139
 140   /// Reinitiate connection with the server
 141   int reinitiate_connection (void);
 142
 143   /// The current state of the connection
 144   State state_;
 145
 146   /// Amount of time to wait between reconnection attempts
 147   long timeout_;
 148
 149   /// Maximum amount of time to wait between reconnection attempts
 150   long max_timeout_;
 151
 152   /// Remote Addr used for connecting to the server
 153   ACE_INET_Addr remote_addr_;
 154
 155   /// Instance of Clerk Processor used for re-establishing connections
 156   ACE_TS_Clerk_Processor *processor_;
 157
 158   /// Time at which request was sent (used to compute round trip delay)
 159   time_t start_time_;
 160
 161   /// Next sequence number of time request (waiting for this update from
 162   /// the server).
 163   ACE_UINT32 cur_sequence_num_;
 164
 165   /// Record of current delta time and current sequence number
 166   ACE_Time_Info time_info_;
 167 };
 168
 169 /**
 170  * @class ACE_TS_Clerk_Processor
 171  *
 172  * @brief This class manages all the connections to the servers along
 173  * with querying them periodically for time updates.
 174  *
 175  * The Clerk Processor creates connections to all the servers and
 176  * creates an ACE_TS_Clerk_Handler for each connection to handle
 177  * the requests and replies. It periodically sends a request for
 178  * time update through each of the handlers and uses the replies
 179  * for computing a synchronized system time.
 180  */
 181 class ACE_TS_Clerk_Processor : public ACE_Connector <ACE_TS_Clerk_Handler, ACE_SOCK_CONNECTOR>
 182 {
 183 public:
 184   /// Default constructor
 185   ACE_TS_Clerk_Processor (void);
 186
 187   /// Query servers for time periodically (timeout value)
 188   virtual int handle_timeout (const ACE_Time_Value &tv,
 189                               const void *arg);
 190
 191   /// Set up connections to all servers
 192   int initiate_connection (ACE_TS_Clerk_Handler *,
 193                            ACE_Synch_Options &);
 194
 195 protected:
 196   // = Dynamic linking hooks.
 197   /// Called when service is linked.
 198   virtual int init (int argc, ACE_TCHAR *argv[]);
 199
 200   /// Called when service is unlinked.
 201   virtual int fini (void);
 202
 203   /// Called to determine info about the service.
 204   virtual int info (ACE_TCHAR **strp, size_t length) const;
 205
 206   // = Scheduling hooks.
 207   virtual int suspend (void);
 208   virtual int resume (void);
 209
 210 private:
 211   /// Parse svc.conf arguments.
 212   int parse_args (int argc, ACE_TCHAR *argv[]);
 213
 214   /// Allocate entry in shared memory for system time
 215   void alloc (void);
 216
 217   /// Update delta_time using times obtained from all servers
 218   int update_time ();
 219
 220   /// Allocator (used for reading/writing system time from/to shared memory)
 221   typedef ACE_Malloc <ACE_MMAP_MEMORY_POOL, ACE_Null_Mutex> MALLOC;
 222   typedef ACE_Allocator_Adapter<MALLOC> ALLOCATOR;
 223   ALLOCATOR *shmem_;
 224
 225   /// Set of TS_Clerk_Handlers and iterator over the set.
 226   typedef ACE_Unbounded_Set <ACE_TS_Clerk_Handler *> HANDLER_SET;
 227   typedef ACE_Unbounded_Set_Iterator <ACE_TS_Clerk_Handler *> HANDLER_SET_ITERATOR;
 228   HANDLER_SET handler_set_;
 229
 230   struct System_Time
 231     {
 232       time_t *delta_time_;       // Diff between system time and local time
 233       time_t *last_local_time_;  // Last local time
 234     };
 235
 236   /// Clerk system time containing pointers to entries in shared memory
 237   System_Time system_time_;
 238
 239   /// Timer id returned by Reactor
 240   long timer_id_;
 241
 242   /// Time period for updating system time
 243   long timeout_;
 244
 245   /// Pool name for backing store
 246   ACE_TCHAR poolname_[MAXNAMLEN + 1];
 247
 248   /// Do a blocking/non-blocking connect
 249   int blocking_semantics_;
 250
 251   /// Sequence number of next expected update from servers
 252   ACE_UINT32 cur_sequence_num_;
 253 };
 254
 255 ACE_SVC_FACTORY_DECLARE (ACE_TS_Clerk_Processor)
 256
 257 #endif /* ACE_TS_CLERK_HANDLER_H */