basicEhsDoc.h

Go to the documentation of this file.

/*********************************************************************
 ** Copyright (c) 2006 MaK Technologies, Inc.
 ** All rights reserved.
 *********************************************************************/
/*******************************************************************************
 ** $RCSfile: basicEhsDoc.h,v $ $Revision: 1.11 $ $State: Exp $
 *******************************************************************************/
#ifndef DtBasicEhsDoc_H_
#define DtBasicEhsDoc_H_

#include <rtiMsConfig.h>
#include "webSpyUtils.h"

#include <wwwRequestXmlBlock.h>
#include <lrcEventLog.h>
#include <vlutil/vlString.h>
#include <vlutil/vlSmartPointers.h>
#include <vlutil/vlThreadSafe.h>

#include <ehs.h>

// Forward References
class DtBasicEhsDoc;
typedef DtBoost::shared_ptr<DtBasicEhsDoc> DtBasicEhsDocSP;
typedef DtBoost::weak_ptr<DtBasicEhsDoc>   DtBasicEhsDocWP;


// The DtBasicEhsDoc is the base class for all MAK RTI EHS pages
// NOTE: any changes to basic EHS functionality should be made by extending this class
//       without modification to the 3rd party library
class DT_DLL_WWWEHS DtBasicEhsDoc : public EHS
{
private:
   // No default constructor
   DtBasicEhsDoc();
   // Copy Constructor not implimented : Copy not allowed
   DtBasicEhsDoc(const DtBasicEhsDoc&);
   // Assignment not implimented : Copy not allowed
   DtBasicEhsDoc& operator=(const DtBasicEhsDoc&);

public:
   
   DtBasicEhsDoc( const DtString& name );
   virtual ~DtBasicEhsDoc();

   inline DtString name() const;

   // Takes ownership of a new state update for the web server connection represented
   // by this page ( if appendToExisting is set, the new state extends the existing state)
   virtual void updateState( std::auto_ptr< DtWebSpyUtils::ConnectionState > connState, bool appendToExisting );

   // Get the current page for the requested component
   std::auto_ptr< DtString > getComponentState(
      unsigned long componentId, DtWebSpyUtils::StateComponentType stateType ) const;


   // Append an event to the page's connection log
   virtual void appendLogEvent( unsigned long componentId, DtLrcConsoleLogXmlBlockSP logSegmentSP );

   // Over-rides the base EHS request handler.
   // It adds default handling for file requests and calls the derived
   // class' specialization for all other requests
   virtual ResponseCode HandleRequest( HttpRequest * ipoHttpRequest, 
                                       HttpResponse * ipoHttpResponse );

   // Return a handle to the sub-document registered by the requested name
   // Returns null if child not found (or not a DtBasicEhsDoc)
   virtual DtBasicEhsDoc* childDoc( const DtString& childName );

protected:

   typedef std::auto_ptr< DtString > ( DtBasicEhsDoc::*RequestHandlerFn)( unsigned long,
      DtWwwRequestXmlBlockSP requestSP, std::auto_ptr< DtString > requestString );

   typedef std::map< DtWebSpyUtils::WwwControlMsgCommandId, RequestHandlerFn > MessageHandlersByKindMap;

   // Default handler for file requests (ex. .htm and .jpg files )
   virtual ResponseCode HandleFileRequest( HttpRequest * ipoHttpRequest, 
                                           HttpResponse * ipoHttpResponse );

   // Handler to deal with all non-file requests
   // - the standard EHS doc tree is mapped as a directory structure
   // - Derived classes may over-ride this method to serve the page, 
   //   but they must ensure that all operations are thread-safe
   //   (ie - if page uses more than just myPage (which is threadsafe))
   // - By default, the page expects HttpRequests to come in the form of WwwRequest messages
   //   or just empty requests for the default state page
   virtual ResponseCode HandleNonFileRequest( HttpRequest * ipoHttpRequest, 
                                              HttpResponse * ipoHttpResponse );


   // Parse the HTTP Request call a registered Request Handler to return the requested page
   // Handlers may forward the request message from the web client to the HTTP server for processing
   std::auto_ptr< DtString > processHttpRequest( HttpRequest * ipoHttpRequest );


   // Parse an XML request from the web client into a usable form
   DtWwwRequestXmlBlockSP parseWebClientRequestMessage( const DtString& request ) const;


   // Return the value of the first instance of a name/value pair in an XML request
   // - returns null string if name not found
   virtual DtString getRequestParam( const DtString& paramName, DtWwwRequestXmlBlockSP request ) const;

   // Set the value of the first instance of a name/value pair in an XML request ( adds a new param if it
   // does not exist )
   void setRequestParam( const DtString& paramName, const DtString& paramVal, DtWwwRequestXmlBlockSP request ) const;


   // Error Condition Responses:

   // 403 - forbidden uri
   virtual ResponseCode forbiddenUriResponse403( HttpRequest * ipoHttpRequest, HttpResponse * ipoHttpResponse );

   // 404 - file not found
   virtual ResponseCode uriNotFoundResponse404( HttpRequest * ipoHttpRequest, HttpResponse * ipoHttpResponse );


   // Register a handler for a specific WwwRequestMsg type
   void registerRequestHandler( DtWebSpyUtils::WwwControlMsgCommandId kind, DtBasicEhsDoc::RequestHandlerFn func );

   // UnRegister a handler for a specific WwwRequestMsg type
   void unRegisterRequestHandler( DtWebSpyUtils::WwwControlMsgCommandId kind, DtBasicEhsDoc::RequestHandlerFn func );

   // Get the registered handler for the specific WwwRequestMsg type
   RequestHandlerFn requestHandlerForKind( DtWebSpyUtils::WwwControlMsgCommandId kind ) const;

protected:

   DtClock myClock;

   // Name with which the page is to be Registered with EHS
   DtString myPageName;

   // Cache of the current body of the page
   // - Not thread-safe => cannot be accessed by the web-server since EHS threads will use it
   DtString myPage;

   // WwwRequest message handlers registered by derived web pages to deal with incoming requests/commands
   // from the Web Client
   MessageHandlersByKindMap myRequestHandlers;


   // The current state of the RTI component(s) represented by this page
   // - myState is threadsafe since it is updated by the WwwSpy thread and read by the EHS thread
   DtThreadSafe< DtWebSpyUtils::ConnectionState > myState;

   // The current event log(s) of the RTI LRC component(s) represented by this page
   // - myLog is threadsafe since it is updated by the WwwSpy thread and read by the EHS thread
   DtThreadSafe< DtLrcEventLog > myLrcLogs;
};

DtString DtBasicEhsDoc::name() const { return myPageName; }

#endif // DtBasicEhsDoc_H_