ACE/apps/JAWS/server/JAWS_IO.h

   1 /* -*- c++ -*- */
   2
   3 //=============================================================================
   4 /**
   5  *  @file    JAWS_IO.h
   6  *
   7  *  @author James Hu
   8  */
   9 //=============================================================================
  10
  11
  12 #ifndef JAWS_IO_H
  13 #define JAWS_IO_H
  14
  15 #include "ace/ACE.h"
  16
  17 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  18 # pragma once
  19 #endif /* ACE_LACKS_PRAGMA_ONCE */
  20
  21 #include "ace/Asynch_IO.h"
  22
  23 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  24 class ACE_Message_Block;
  25 ACE_END_VERSIONED_NAMESPACE_DECL
  26
  27 class JAWS_IO_Handler;
  28
  29
  30 /**
  31  * @class JAWS_IO
  32  *
  33  * @brief This class defines the abstract interface for an I/O class in
  34  * the context of Web-likes servers
  35  *
  36  * An I/O class should have the following interface. Derived
  37  * classes will define the exactly how the I/O will take place
  38  * (Asynchronous, Synchronous, Reactive)
  39  */
  40 class JAWS_IO
  41 {
  42 public:
  43   JAWS_IO ();
  44   virtual ~JAWS_IO ();
  45   void handler (JAWS_IO_Handler *handler);
  46
  47   virtual void handle (ACE_HANDLE h) = 0;
  48   virtual ACE_HANDLE handle () const = 0;
  49
  50   // James, please add documentation here.
  51
  52   /// read from the handle size bytes into the message block.
  53   virtual void read (ACE_Message_Block& mb, int size) = 0;
  54
  55   /// send header, filename, trailer to the handle.
  56   virtual void transmit_file (const char *filename,
  57                               const char *header,
  58                               int header_size,
  59                               const char *trailer,
  60                               int trailer_size) = 0;
  61
  62   /// read data from the handle and store in filename.
  63   virtual void receive_file (const char *filename,
  64                              void *initial_data,
  65                              int initial_data_length,
  66                              int entire_length) = 0;
  67
  68   /// send a confirmation message to the handle.
  69   virtual void send_confirmation_message (const char *buffer, int length) = 0;
  70
  71   /// send an error message to the handle.
  72   virtual void send_error_message (const char *buffer, int length) = 0;
  73
  74 protected:
  75   JAWS_IO_Handler *handler_;
  76 };
  77
  78 /**
  79  * @class JAWS_IO_Handler
  80  *
  81  * @brief This class defines the abstract interface for an I/O handler class in
  82  * the context of Web-likes servers
  83  */
  84 class JAWS_IO_Handler
  85 {
  86 public:
  87   /// Destructor.
  88   virtual ~JAWS_IO_Handler ();
  89
  90   /// This method is called by the IO class when new client data shows
  91   /// up.
  92   virtual void read_complete (ACE_Message_Block &data) = 0;
  93
  94   /// This method is called by the IO class when there was an error in
  95   /// reading new data from the client.
  96   virtual void read_error () = 0;
  97
  98   /// This method is called by the IO class when the requested file has
  99   /// been successfully transmitted to the client.
 100   virtual void transmit_file_complete () = 0;
 101
 102   /// This method is called by the IO class when there was an error in
 103   /// transmitting the requested file to the client.
 104   virtual void transmit_file_error (int result) = 0;
 105
 106   /// This method is called by the IO class when the requested file has
 107   /// been successfully received from the client.
 108   virtual void receive_file_complete () = 0;
 109
 110   /// This method is called by the IO class when there was an error in
 111   /// receiving the requested file from the client.
 112   virtual void receive_file_error (int result) = 0;
 113
 114   /// This method is called by the IO class when there was an error in
 115   /// writing data to the client.
 116   virtual void write_error () = 0;
 117
 118   /// This method is called by the IO class when the confirmation
 119   /// message has been delivered to the client.
 120   virtual void confirmation_message_complete () = 0;
 121
 122   /// This method is called by the IO class when the error message has
 123   /// been delivered to the client.
 124   virtual void error_message_complete () = 0;
 125 };
 126
 127 /**
 128  * @class JAWS_Synch_IO
 129  *
 130  * @brief This class defines the interface for a Synchronous I/O class.
 131  */
 132 class JAWS_Synch_IO : public JAWS_IO
 133 {
 134 public:
 135   JAWS_Synch_IO ();
 136
 137   ~JAWS_Synch_IO ();
 138
 139   virtual void handle (ACE_HANDLE h);
 140   virtual ACE_HANDLE handle () const;
 141
 142   void read (ACE_Message_Block& mb, int size);
 143
 144   void transmit_file (const char *filename,
 145                       const char *header,
 146                       int header_size,
 147                       const char *trailer,
 148                       int trailer_size);
 149
 150   void receive_file (const char *filename,
 151                      void *initial_data,
 152                      int initial_data_length,
 153                      int entire_length);
 154
 155   void send_confirmation_message (const char *buffer,
 156                                   int length);
 157
 158   void send_error_message (const char *buffer,
 159                            int length);
 160
 161 protected:
 162   virtual void send_message (const char *buffer,
 163                              int length);
 164
 165   ACE_HANDLE handle_;
 166 };
 167
 168 // This only works on Win32
 169 #if defined (ACE_HAS_WIN32_OVERLAPPED_IO)
 170
 171 /**
 172  * @class JAWS_Asynch_IO
 173  *
 174  * @brief This class defines the interface for a Asynchronous I/O class.
 175  */
 176 class JAWS_Asynch_IO : public JAWS_IO, public ACE_Handler
 177 {
 178 public:
 179   JAWS_Asynch_IO ();
 180
 181   ~JAWS_Asynch_IO ();
 182
 183   virtual void handle (ACE_HANDLE h) { ACE_Handler::handle (h); };
 184   virtual ACE_HANDLE handle () const { return ACE_Handler::handle (); };
 185
 186   void read (ACE_Message_Block& mb, int size);
 187
 188   void transmit_file (const char *filename,
 189                       const char *header,
 190                       int header_size,
 191                       const char *trailer,
 192                       int trailer_size);
 193
 194   void receive_file (const char *filename,
 195                      void *initial_data,
 196                      int initial_data_length,
 197                      int entire_length);
 198
 199   void send_confirmation_message (const char *buffer,
 200                                   int length);
 201
 202   void send_error_message (const char *buffer,
 203                            int length);
 204
 205 protected:
 206   enum Message_Types
 207   {
 208     CONFORMATION,
 209     ERROR_MESSAGE
 210   };
 211
 212   virtual void send_message (const char *buffer,
 213                              int length,
 214                              int act);
 215
 216   /// This method will be called when an asynchronous read completes on
 217   /// a stream.
 218   virtual void handle_read_stream (const ACE_Asynch_Read_Stream::Result &result);
 219
 220   /// This method will be called when an asynchronous write completes
 221   /// on a stream.
 222   virtual void handle_write_stream (const ACE_Asynch_Write_Stream::Result &result);
 223
 224   /// This method will be called when an asynchronous transmit file
 225   /// completes.
 226   virtual void handle_transmit_file (const ACE_Asynch_Transmit_File::Result &result);
 227 };
 228
 229 #endif /* ACE_HAS_WIN32_OVERLAPPED_IO */
 230
 231
 232 //-------------------Adding SYNCH IO no Caching
 233
 234 /**
 235  * @class JAWS_Synch_IO_No_Cache
 236  *
 237  * @brief This class defines the interface for a Synchronous I/O class,
 238  * however in this class we do not use any caching.
 239  *
 240  * Wondering how this is useful?
 241  * The ACE_Filecache ACE_NOMAP option is broken and even if it were not, there
 242  * are other use cases in which we want to avoid caching altogether. For example,
 243  * we use JAWS in conjunction with the CIAO Repository Manager, however the two
 244  * do not have any explicit knowledge of each other. Therefore if the RM tried
 245  * to remove a package and its files from disk, its operation would [partially]
 246  * fail if JAWS still holds some of the files in its cache.
 247  */
 248 class JAWS_Synch_IO_No_Cache : public JAWS_IO
 249 {
 250 public:
 251   JAWS_Synch_IO_No_Cache ();
 252
 253   ~JAWS_Synch_IO_No_Cache ();
 254
 255   virtual void handle (ACE_HANDLE h);
 256   virtual ACE_HANDLE handle () const;
 257
 258   void read (ACE_Message_Block& mb, int size);
 259
 260   void transmit_file (const char *filename,
 261                       const char *header,
 262                       int header_size,
 263                       const char *trailer,
 264                       int trailer_size);
 265
 266   void receive_file (const char *filename,
 267                      void *initial_data,
 268                      int initial_data_length,
 269                      int entire_length);
 270
 271   void send_confirmation_message (const char *buffer,
 272                                   int length);
 273
 274   void send_error_message (const char *buffer,
 275                            int length);
 276
 277 protected:
 278   virtual void send_message (const char *buffer, int length);
 279
 280   ACE_HANDLE handle_;
 281 };
 282
 283 //-------------------
 284
 285 #endif /* JAWS_IO_H */
 286