ACE/apps/JAWS2/JAWS/IO_Handler.h

   1 /* -*- c++ -*- */
   2
   3 //=============================================================================
   4 /**
   5  *  @file    IO_Handler.h
   6  *
   7  *  @author James Hu
   8  */
   9 //=============================================================================
  10
  11 #ifndef JAWS_IO_HANDLER_H
  12 #define JAWS_IO_HANDLER_H
  13
  14 #include "ace/Asynch_IO.h"
  15
  16 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  17 # pragma once
  18 #endif /* ACE_LACKS_PRAGMA_ONCE */
  19
  20 #include "ace/Singleton.h"
  21 #include "ace/Synch_Traits.h"
  22 #include "ace/RW_Thread_Mutex.h"
  23
  24 #include "JAWS/Export.h"
  25
  26 class JAWS_IO;
  27 class JAWS_Synch_IO;
  28 class JAWS_Asynch_IO;
  29 class JAWS_IO_Handler;
  30 class JAWS_IO_Handler_Factory;
  31 class JAWS_Data_Block;
  32 class JAWS_Pipeline_Handler;
  33 class JAWS_Waiter;
  34
  35 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  36 class ACE_Message_Block;
  37 ACE_END_VERSIONED_NAMESPACE_DECL
  38
  39 /**
  40  * @class JAWS_Abstract_IO_Handler
  41  *
  42  * @brief This class defines the abstract interface for an I/O handler
  43  * class in the context of Web-likes servers
  44  */
  45 class JAWS_Export JAWS_Abstract_IO_Handler
  46 {
  47 public:
  48   virtual ~JAWS_Abstract_IO_Handler (void);
  49
  50   virtual void task (JAWS_Pipeline_Handler *ph) = 0;
  51   virtual JAWS_Pipeline_Handler *task (void) = 0;
  52
  53   virtual void message_block (JAWS_Data_Block *mb) = 0;
  54   virtual JAWS_Data_Block *message_block (void) = 0;
  55
  56   /// This method is called by the IO class when new passive connection has
  57   /// been established.
  58   virtual void accept_complete (ACE_HANDLE handle) = 0;
  59
  60   /// This method is called by the IO class when new passive connection has
  61   /// been established.
  62   virtual void accept_error (void) = 0;
  63
  64 #if 0
  65   /// This method is called by the IO class when new active connection has
  66   /// been established.
  67   virtual void connect_complete (ACE_Message_Block *) = 0;
  68
  69   /// This method is called by the IO class when new active connection has
  70   /// been established.
  71   virtual void connect_error (ACE_Message_Block *) = 0;
  72 #endif
  73
  74   /// This method is called by the IO class when new client data shows
  75   /// up.
  76   virtual void read_complete (ACE_Message_Block *data) = 0;
  77
  78   /// This method is called by the IO class when there was an error in
  79   /// reading new data from the client.
  80   virtual void read_error (void) = 0;
  81
  82   /// This method is called by the IO class when the requested file has
  83   /// been successfully transmitted to the client.
  84   virtual void transmit_file_complete (void) = 0;
  85
  86   /// This method is called by the IO class when there was an error in
  87   /// transmitting the requested file to the client.
  88   virtual void transmit_file_error (int result) = 0;
  89
  90   /// This method is called by the IO class when the requested file has
  91   /// been successfully received from the client.
  92   virtual void receive_file_complete (void) = 0;
  93
  94   /// This method is called by the IO class when there was an error in
  95   /// receiving the requested file from the client.
  96   virtual void receive_file_error (int result) = 0;
  97
  98   /// This method is called by the IO class when there was an error in
  99   /// writing data to the client.
 100   virtual void write_error (void) = 0;
 101
 102   /// This method is called by the IO class when the confirmation
 103   /// message has been delivered to the client.
 104   virtual void confirmation_message_complete (void) = 0;
 105
 106   /// This method is called by the IO class when the error message has
 107   /// been delivered to the client.
 108   virtual void error_message_complete (void) = 0;
 109
 110   /// Returns the factory for this IO handler
 111   virtual JAWS_IO_Handler_Factory *factory (void) = 0;
 112
 113   /// Returns the socket handle for this handler
 114   virtual ACE_HANDLE handle (void) const = 0;
 115
 116   /// Cleans up the handler.
 117   virtual void done (void) = 0;
 118
 119   /// Returns the status of the handler
 120   virtual int status (void) = 0;
 121
 122   /// puts handler in an idle state
 123   virtual void idle (void) = 0;
 124
 125   enum { IDLE = 0, IDLE_A = 1,
 126          ACCEPT_OK = 2, ACCEPT_OK_A = 3,
 127          ACCEPT_ERROR = 4, ACCEPT_ERROR_A = 5,
 128          READ_OK = 6, READ_OK_A = 7,
 129          READ_ERROR = 8, READ_ERROR_A = 9,
 130          WRITE_OK = 10, WRITE_OK_A = 11,
 131          WRITE_ERROR = 12, WRITE_ERROR_A = 13,
 132          TRANSMIT_OK = 14, TRANSMIT_OK_A = 15,
 133          TRANSMIT_ERROR = 16, TRANSMIT_ERROR_A = 17,
 134          RECEIVE_OK = 18, RECEIVE_OK_A = 19,
 135   /// The different states of the handler
 136          RECEIVE_ERROR = 20, RECEIVE_ERROR_A = 21 };
 137
 138 };
 139
 140 #if defined (ACE_HAS_WIN32_OVERLAPPED_IO) || defined(ACE_HAS_AIO_CALLS)
 141
 142 // Forward reference.
 143 class JAWS_Asynch_IO_Handler;
 144
 145 class JAWS_Export JAWS_Asynch_Handler : public ACE_Service_Handler
 146 {
 147 public:
 148   JAWS_Asynch_Handler (void);
 149   virtual ~JAWS_Asynch_Handler (void);
 150
 151   /// This method will be called when an asynchronous read completes on
 152   /// a stream.
 153   virtual void handle_read_stream (const ACE_Asynch_Read_Stream::Result
 154                                    &result);
 155
 156   /// This method will be called when an asynchronous write completes
 157   /// on a stream.
 158   virtual void handle_write_stream (const ACE_Asynch_Write_Stream::Result
 159                                     &result);
 160
 161   /// This method will be called when an asynchronous transmit file
 162   /// completes.
 163   virtual void handle_transmit_file (const ACE_Asynch_Transmit_File::Result
 164                                      &result);
 165
 166   /// This method will be called when an asynchronous accept completes.
 167   virtual void handle_accept (const ACE_Asynch_Accept::Result &result);
 168
 169   virtual void handler (JAWS_Asynch_IO_Handler *ioh);
 170   virtual JAWS_Asynch_IO_Handler * handler (void);
 171
 172   virtual void dispatch_handler (void);
 173
 174   /// Call back entry point for ACE_Asynch_Acceptor
 175   virtual void open (ACE_HANDLE h, ACE_Message_Block &mb);
 176
 177   /// Receives the ACT.
 178   virtual void act (const void *act_ref);
 179
 180   //virtual ACE_HANDLE handle (void) const;
 181
 182 private:
 183   JAWS_Asynch_IO_Handler *ioh_;
 184 };
 185 #endif /* defined(ACE_HAS_WIN32_OVERLAPPED_IO) || defined(ACE_HAS_AIO_CALLS) */
 186
 187
 188 class JAWS_Export JAWS_IO_Handler : public JAWS_Abstract_IO_Handler
 189 {
 190 public:
 191   JAWS_IO_Handler (JAWS_IO_Handler_Factory *factory);
 192   virtual ~JAWS_IO_Handler (void);
 193
 194   // Inherited from JAWS_IO_Handler
 195
 196   virtual void accept_complete (ACE_HANDLE handle);
 197   virtual void accept_error (void);
 198   virtual void read_complete (ACE_Message_Block *data);
 199   virtual void read_error (void);
 200   virtual void transmit_file_complete (void);
 201   virtual void transmit_file_error (int result);
 202   virtual void receive_file_complete (void);
 203   virtual void receive_file_error (int result);
 204   virtual void write_error (void);
 205   virtual void confirmation_message_complete (void);
 206   virtual void error_message_complete (void);
 207
 208   virtual JAWS_IO_Handler_Factory *factory (void);
 209   virtual ACE_HANDLE handle (void) const;
 210
 211   virtual void done (void);
 212   virtual int status (void);
 213   virtual void idle (void);
 214
 215   virtual void acquire (void);
 216   virtual void lock (void);
 217   virtual void release (void);
 218
 219   virtual void task (JAWS_Pipeline_Handler *ph);
 220   virtual JAWS_Pipeline_Handler *task (void);
 221
 222   virtual void message_block (JAWS_Data_Block *mb);
 223   virtual JAWS_Data_Block *message_block (void);
 224
 225 protected:
 226   /// The state of the handler.
 227   int status_;
 228
 229   /// This maintains the state of the request.
 230   JAWS_Data_Block *mb_;
 231
 232   /// The socket handle returned from accept.
 233   ACE_HANDLE handle_;
 234
 235   /// This is a reference to the next stage of the pipeline when the IO
 236   /// request completes.
 237   JAWS_Pipeline_Handler *task_;
 238
 239   /// The reference to the handler's factory.
 240   JAWS_IO_Handler_Factory *factory_;
 241 };
 242
 243 class JAWS_Export JAWS_IO_Handler_Factory
 244 {
 245 public:
 246   /// Destructor
 247   virtual ~JAWS_IO_Handler_Factory (void);
 248
 249   /// This creates a new JAWS_IO_Handler
 250   virtual JAWS_IO_Handler *create_io_handler (void);
 251
 252   /// This deletes a JAWS_IO_Handler
 253   virtual void destroy_io_handler (JAWS_IO_Handler *handler);
 254 };
 255
 256 typedef JAWS_IO_Handler JAWS_Synch_IO_Handler;
 257 typedef JAWS_IO_Handler_Factory JAWS_Synch_IO_Handler_Factory;
 258
 259 typedef ACE_Singleton<JAWS_Synch_IO_Handler_Factory, ACE_SYNCH_MUTEX>
 260         JAWS_Synch_IO_Handler_Factory_Singleton;
 261
 262 #if defined(ACE_HAS_WIN32_OVERLAPPED_IO) || defined(ACE_HAS_AIO_CALLS)
 263
 264 class JAWS_Export JAWS_Asynch_IO_Handler_Factory : public JAWS_IO_Handler_Factory
 265 {
 266 public:
 267   /// Destructor
 268   virtual ~JAWS_Asynch_IO_Handler_Factory (void);
 269
 270   /// This creates a new JAWS_IO_Handler
 271   virtual JAWS_IO_Handler *create_io_handler (void);
 272
 273   /// This deletes a JAWS_IO_Handler
 274   virtual void destroy_io_handler (JAWS_IO_Handler *handler);
 275 };
 276
 277 class JAWS_Export JAWS_Asynch_IO_Handler : public JAWS_IO_Handler
 278 {
 279 friend class JAWS_Asynch_Handler;
 280 friend class JAWS_Asynch_IO_Handler_Factory;
 281 friend class JAWS_Waiter;
 282
 283   // Provide implementations for the common functions.
 284 public:
 285   explicit JAWS_Asynch_IO_Handler (JAWS_Asynch_IO_Handler_Factory *factory);
 286   virtual ~JAWS_Asynch_IO_Handler (void);
 287
 288   virtual ACE_Handler *handler (void);
 289
 290   virtual void acquire (void);
 291   virtual void lock (void);
 292   virtual void release (void);
 293
 294 protected:
 295
 296   JAWS_Asynch_Handler *handler_;
 297   ACE_SYNCH_RW_MUTEX count_;
 298 };
 299
 300 #else
 301
 302 typedef JAWS_IO_Handler JAWS_Asynch_IO_Handler;
 303 typedef JAWS_IO_Handler_Factory JAWS_Asynch_IO_Handler_Factory;
 304
 305 #endif /* defined(ACE_HAS_WIN32_OVERLAPPED_IO) || defined(ACE_HAS_AIO_CALLS) */
 306
 307 typedef ACE_Singleton<JAWS_Asynch_IO_Handler_Factory, ACE_SYNCH_MUTEX>
 308         JAWS_Asynch_IO_Handler_Factory_Singleton;
 309
 310 #endif /* JAWS_IO_HANDLER_H */