diff options
Diffstat (limited to 'TAO/examples/Content_Server/AMI_Observer/Callback_Handler.h')
-rw-r--r-- | TAO/examples/Content_Server/AMI_Observer/Callback_Handler.h | 138 |
1 files changed, 138 insertions, 0 deletions
diff --git a/TAO/examples/Content_Server/AMI_Observer/Callback_Handler.h b/TAO/examples/Content_Server/AMI_Observer/Callback_Handler.h new file mode 100644 index 00000000000..db3f8bb2656 --- /dev/null +++ b/TAO/examples/Content_Server/AMI_Observer/Callback_Handler.h @@ -0,0 +1,138 @@ +// -*- C++ -*- +// $Id$ + +// ============================================================================ +// +// = LIBRARY +// AMI_Observer +// +// = FILENAME +// Callback_Handler.h +// +// = DESCRIPTION +// Header file for the Web_Server::AMI_CallbackHandler +// implementation. +// +// = AUTHOR +// Ossama Othman <ossama@uci.edu> +// +// ============================================================================ + +#ifndef CALLBACK_HANDLER_H +#define CALLBACK_HANDLER_H + +#include "ace/FILE_Addr.h" +#include "ace/FILE_IO.h" +#include "Push_Web_ServerS.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +class Callback_Handler + : public virtual POA_Web_Server::AMI_CallbackHandler +{ + // = TITLE + // Class that asynchronously sends chunks of data to the + // client-side <Callback> object, and handles all asynchronous + // replies emanating from it. + // + // = DESCRIPTION + // The <Push_Iterator_Factory_i> object in the Content Server + // creates a <Callback_Handler> instance for each requested file, + // and executes the run() method in that instance (in this + // class). To allow the Content Server to service other requests + // without having to wait for the requested file to be completely + // sent to the client, the run() method in this class issues the + // next_chunk() method, which reads the first chunk of data and + // sends it asynchronously to the client-side <Callback> object + // by issuing a sendc_next_chunk() call. + // + // This may seem a bit odd since the next_chunk() method in this + // class is actually the reply handler method for the + // sendc_next_chunk() method. The next_chunk() method is + // initially invoked as a means to bootstrap the process of + // asynchronously sending chunks of data to the client-side + // <Callback> object. However, since the next_chunk() method + // actually invokes sendc_next_chunk(), all subsequent calls will + // be performed asynchronously. This design also guarantees that + // the client-side <Callback> object will receive all chunks of + // data in the proper order since the next chunk of data will not + // be sent until this <Callback_Handler> receives the asynchronous + // reply from the client-side <Callback> object. Again, that + // asynchronous reply is handled by the next_chunk() method, at + // which point the entire cycle is started again until the last + // chunk of data is sent. + // + // Notice that no threads are explicitly created at the + // application level, yet concurrency is achieved due to the fact + // that all operations are performed asynchronously. + + friend class Callback_Handler_Friend; + // Dummy friend class declaration to quiet down a warning. + +public: + Callback_Handler (const char *pathname, + Web_Server::Callback_ptr callback); + // Constructor that creates a content iterator corresponding to the + // name of the file being retrieved from the web server. + + virtual void next_chunk (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)); + // The callback for this reply handler. + + virtual void next_chunk_excep (::Messaging::ExceptionHolder * + ACE_ENV_ARG_DECL_NOT_USED) + ACE_THROW_SPEC ((CORBA::SystemException)); + + void run (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + Web_Server::Error_Result)); + // Activate and run this Reply Handler. The contents (not the + // pointer itself) of the <request_count> parameter will be + // incremented when file retrieval begins, and decremented when file + // retrieval completes. + +private: + ~Callback_Handler (void); + // Destructor (private to ensure that Callback_Handler is allocated + // on the heap). + + void open_file (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException, + Web_Server::Error_Result)); + // Open the file to be uploaded to the client callback. + + void deactivate (ACE_ENV_SINGLE_ARG_DECL) + ACE_THROW_SPEC ((CORBA::SystemException)); + // Deactivate this reply handler. + +private: + + ACE_FILE_Addr file_; + // The Addr corresponding to the retrieved file. + + ACE_FILE_IO file_io_; + // The object that provides all file related IO operations + // (e.g. read, write, etc). + + Web_Server::Callback_var callback_; + // The iterator used to obtain individual chunks of data from the + // web server. + + Web_Server::AMI_CallbackHandler_var ami_handler_; + // Reference to this Reply Handler's self. + + Web_Server::Chunk_Type_var chunk_; + // The chunk of data that is sent to the client callback during each + // callback invocation. + + CORBA::ULong chunk_index_; + // The number of the current chunk of data being sent. (Used only + // for debugging purposes.) + + int last_chunk_; + // Flag that indicates all chunks of data have been sent. +}; + +#endif /* CALLBACK_HANDLER_H */ |