(file) Return to Message.h CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/Message.h between version 1.6 and 1.33

version 1.6, 2001/12/13 14:54:00 version 1.33, 2002/05/01 21:32:53
Line 24 
Line 24 
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com) // Modified By: Nitin Upasani, Hewlett-Packard Company (Nitin_Upasani@hp.com)
 // Modified By: Carol Ann Krug Graves, Hewlett-Packard Company  //              Carol Ann Krug Graves, Hewlett-Packard Company
 //              (carolann_graves@hp.com) //              (carolann_graves@hp.com)
   //              Mike Day (mdday@us.ibm.com)
   //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
   //              Arthur Pichlkostner (via Markus: sedgewick_de@yahoo.de)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 37 
Line 40 
 #include <cstring> #include <cstring>
 #include <Pegasus/Common/Exception.h> #include <Pegasus/Common/Exception.h>
 #include <Pegasus/Common/IPC.h> #include <Pegasus/Common/IPC.h>
   #include <Pegasus/Common/StatisticalData.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   // REVIEW: could class be renamed to MessageMask (coding standard)
   
 class PEGASUS_COMMON_LINKAGE message_mask class PEGASUS_COMMON_LINKAGE message_mask
 { {
    public:    public:
   
       static Uint32 type_legacy;       static Uint32 type_legacy;
       static Uint32 type_CIMClass;        static Uint32 type_CIMOperation;
       static Uint32 type_CIMInstance;        static Uint32 type_CIMAsyncOperation;
       static Uint32 type_CIMIndication;        static Uint32 type_export;
       static Uint32 type_CIMQualifier;        static Uint32 type_lifetime;
       static Uint32 type_CIMSubscription;  
       static Uint32 type_socket;       static Uint32 type_socket;
       static Uint32 type_connection;       static Uint32 type_connection;
       static Uint32 type_http;       static Uint32 type_http;
         static Uint32 type_http_error;
       static Uint32 type_cimom;       static Uint32 type_cimom;
   
       static Uint32 no_delete;  
   
       static Uint32 type_request;  
       static Uint32 type_reply;  
       static Uint32 type_control;       static Uint32 type_control;
         static Uint32 type_service;
         static Uint32 type_broadcast;
         static Uint32 type_client_exception;
   
         static Uint32 ha_no_delete;
         static Uint32 ha_request;
         static Uint32 ha_reply;
         static Uint32 ha_synchronous;
         static Uint32 ha_async;
         static Uint32 ha_wait;
   
  
 // more for documentation than for use // more for documentation than for use
       inline Uint32 get_classification(Uint32 flags)  
         inline Uint32 get_type(Uint32 flags)
       {       {
          return (flags & 0x000fffff);          return (flags & 0x000fffff);
       }       }
Line 72 
Line 86 
       }       }
 }; };
  
   class cimom;
 class MessageQueue; class MessageQueue;
   class MessageQueueService;
   class AsyncLegacyOperationStart;
   class AsyncLegacyOperationResult;
  
 /** The Message class and derived classes are used to pass messages between /** The Message class and derived classes are used to pass messages between
     modules. Messages are passed between modules using the message queues     modules. Messages are passed between modules using the message queues
Line 91 
Line 109 
  
     Message(     Message(
         Uint32 type,         Uint32 type,
            Uint32 destination = 0,
         Uint32 key = getNextKey(),         Uint32 key = getNextKey(),
            Uint32 routing_code = 0,
         Uint32 mask = message_mask::type_legacy)         Uint32 mask = message_mask::type_legacy)
         :         :
         _type(type),         _type(type),
         _key(key),         _key(key),
            _routing_code(routing_code),
         _mask(mask),         _mask(mask),
         _next(0),         _next(0),
         _prev(0)           _prev(0),
            _async(0),
            dest(destination)
     {     {
  
     }     }
  
         Message(const Message & msg)
         {
            if( this != &msg)
            {
               _type = msg._type;
               _key = msg._key;
               _routing_code = msg._routing_code;
               _mask = msg._mask;
               _next = _prev = _async = 0;
               dest = msg.dest;
            }
         }
   
         Message & operator = ( const Message & msg)
         {
            if (this != &msg)
            {
               _type = msg._type;
               _key = msg._key;
               _routing_code = msg._routing_code;
               _mask = msg._mask;
               _next = _prev = _async = 0;
               dest = msg.dest;
            }
            return *this;
         }
   
   
     virtual ~Message();     virtual ~Message();
  
     Uint32 getType() const { return _type; }     Uint32 getType() const { return _type; }
Line 113 
Line 164 
  
     void setKey(Uint32 key) { _key = key; }     void setKey(Uint32 key) { _key = key; }
  
       Uint32 getMask() const        Uint32 getRouting() const { return _routing_code; }
         void setRouting(Uint32 routing) { _routing_code = routing; }
   
         Uint32 getMask() const { return _mask; }
   
         void setMask(Uint32 mask) { _mask = mask; }
   
   #ifdef PEGASUS_HAS_PERFINST
   //
   // Needed for performance measurement
   //
   
         void startServer();
   
         void endServer();
   
         void startProvider();
   
         void endProvider();
   
         timeval getStartServerTime() const { return _timeServerStart; }
   
         void setStartServerTime(timeval timeServerStart)
         {
              _timeServerStart = timeServerStart;
         }
   
         timeval getStartProviderTime() const { return _timeProviderStart; }
   
         void setStartProviderTime(timeval timeProviderStart)
       {       {
          return _mask;            _timeProviderStart = timeProviderStart;
       }       }
  
       void setMask(Uint32 mask)        timeval getEndServerTime() const { return _timeServerEnd; }
   
         void setEndServerTime (timeval timeServerEnd)
       {       {
          _mask = mask;            _timeServerEnd = timeServerEnd;
       }       }
  
         timeval getEndProviderTime() const { return _timeProviderEnd; }
   
         void setEndProviderTime(timeval timeProviderEnd)
         {
             _timeProviderEnd = timeProviderEnd;
         }
   
         Uint32 getTotalTime() { return _totalTime; }
   //
   #endif
  
     Message* getNext() { return _next; }     Message* getNext() { return _next; }
  
Line 143 
Line 235 
  
     virtual void print(PEGASUS_STD(ostream)& os) const;     virtual void print(PEGASUS_STD(ostream)& os) const;
  
         // << Thu Dec 27 10:46:04 2001 mdd >> for use with DQueue container
         // as used by AsyncOpNode
         Boolean operator == (const void *msg )
         {
            if (reinterpret_cast<void *>(this) == msg )
               return true;
            return false;
         }
   
         Message *get_async(void)
         {
            Message *ret = _async;
            _async = 0;
            return ret;
   
         }
   
         void put_async(Message * msg)
         {
            _async = msg;
         }
   
   
 private: private:
       Uint32 _type;       Uint32 _type;
       Uint32 _key;       Uint32 _key;
         Uint32 _routing_code;
       Uint32 _mask;       Uint32 _mask;
   // Needed for performance measurement
         timeval _timeServerStart;
         timeval _timeServerEnd;
         timeval _timeProviderStart;
         timeval _timeProviderEnd;
         Uint64 _totalTime;
   //
       Message* _next;       Message* _next;
       Message* _prev;       Message* _prev;
   
      protected:
   
      public:
         Message *_async;
         Uint32 dest;
      private:
       MessageQueue* _owner;       MessageQueue* _owner;
       static Uint32 _nextKey;       static Uint32 _nextKey;
       static Mutex _mut;       static Mutex _mut;
         friend class cimom;
       friend class MessageQueue;       friend class MessageQueue;
 };        friend class MessageQueueService;
         friend class AsyncLegacyOperationStart;
         friend class AsyncLegacyOperationResult;
  
 // each component needs to support a set of these messgaes and pass that array  };
 // to the dispatcher so the dispatcher can route messages at the first level  
 // i.e., client will not accept request messages.  
 // every message should have a response  
   
 // dispatcher supports full cim api set (as below)  
 // repository needs to be a peer to the provider manager  
 //  
  
 // mkdir _dispatcher  
 // mkdir _providermanager  
 // mkdir _server (http incoming, front end)  
 // mkdir _repositorymanager  
 //       _subscriptionprocessor  
 //       _indicationprocessor  
 //       _configurationmanager  
 //       _cimom (loads and links everyone, hooks up queues)  
   
 // fundamental messages:  
   
 // start, stop, pause, resume  
 // handshaking: interrogate (as in windows service api)  
 //              message class support  
 //              message namespace support ???  
  
 enum MessageType enum MessageType
 { {
Line 196 
Line 306 
     CIM_CREATE_INSTANCE_REQUEST_MESSAGE,     CIM_CREATE_INSTANCE_REQUEST_MESSAGE,
     CIM_MODIFY_CLASS_REQUEST_MESSAGE,     CIM_MODIFY_CLASS_REQUEST_MESSAGE,
     CIM_MODIFY_INSTANCE_REQUEST_MESSAGE,     CIM_MODIFY_INSTANCE_REQUEST_MESSAGE,
     CIM_ENUMERATE_CLASSES_REQUEST_MESSAGE,      CIM_ENUMERATE_CLASSES_REQUEST_MESSAGE, //10
     CIM_ENUMERATE_CLASS_NAMES_REQUEST_MESSAGE,     CIM_ENUMERATE_CLASS_NAMES_REQUEST_MESSAGE,
     CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE,     CIM_ENUMERATE_INSTANCES_REQUEST_MESSAGE,
     CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE,     CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE,
Line 206 
Line 316 
     CIM_REFERENCES_REQUEST_MESSAGE,     CIM_REFERENCES_REQUEST_MESSAGE,
     CIM_REFERENCE_NAMES_REQUEST_MESSAGE,     CIM_REFERENCE_NAMES_REQUEST_MESSAGE,
     CIM_GET_PROPERTY_REQUEST_MESSAGE,     CIM_GET_PROPERTY_REQUEST_MESSAGE,
     CIM_SET_PROPERTY_REQUEST_MESSAGE,      CIM_SET_PROPERTY_REQUEST_MESSAGE, //20
     CIM_GET_QUALIFIER_REQUEST_MESSAGE,     CIM_GET_QUALIFIER_REQUEST_MESSAGE,
     CIM_SET_QUALIFIER_REQUEST_MESSAGE,     CIM_SET_QUALIFIER_REQUEST_MESSAGE,
     CIM_DELETE_QUALIFIER_REQUEST_MESSAGE,     CIM_DELETE_QUALIFIER_REQUEST_MESSAGE,
Line 215 
Line 325 
     CIM_ENABLE_INDICATION_SUBSCRIPTION_REQUEST_MESSAGE,     CIM_ENABLE_INDICATION_SUBSCRIPTION_REQUEST_MESSAGE,
     CIM_MODIFY_INDICATION_SUBSCRIPTION_REQUEST_MESSAGE,     CIM_MODIFY_INDICATION_SUBSCRIPTION_REQUEST_MESSAGE,
     CIM_DISABLE_INDICATION_SUBSCRIPTION_REQUEST_MESSAGE,     CIM_DISABLE_INDICATION_SUBSCRIPTION_REQUEST_MESSAGE,
     CIM_GET_CLASS_RESPONSE_MESSAGE,      CIM_PROCESS_INDICATION_REQUEST_MESSAGE,
       CIM_HANDLE_INDICATION_REQUEST_MESSAGE, // 30
       CIM_NOTIFY_PROVIDER_REGISTRATION_REQUEST_MESSAGE,
       CIM_NOTIFY_PROVIDER_TERMINATION_REQUEST_MESSAGE,
   
       // new
       CIM_ENABLE_INDICATIONS_REQUEST_MESSAGE,
       CIM_DISABLE_INDICATIONS_REQUEST_MESSAGE,
       CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE,
       CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE,
       CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE,
   
       // new
       CIM_DISABLE_MODULE_REQUEST_MESSAGE,
       CIM_ENABLE_MODULE_REQUEST_MESSAGE,
   
       CIM_GET_CLASS_RESPONSE_MESSAGE, // 40
     CIM_GET_INSTANCE_RESPONSE_MESSAGE,     CIM_GET_INSTANCE_RESPONSE_MESSAGE,
     CIM_EXPORT_INDICATION_RESPONSE_MESSAGE,      CIM_EXPORT_INDICATION_RESPONSE_MESSAGE, // 42
     CIM_DELETE_CLASS_RESPONSE_MESSAGE,     CIM_DELETE_CLASS_RESPONSE_MESSAGE,
     CIM_DELETE_INSTANCE_RESPONSE_MESSAGE,     CIM_DELETE_INSTANCE_RESPONSE_MESSAGE,
     CIM_CREATE_CLASS_RESPONSE_MESSAGE,     CIM_CREATE_CLASS_RESPONSE_MESSAGE,
Line 243 
Line 369 
     CIM_ENABLE_INDICATION_SUBSCRIPTION_RESPONSE_MESSAGE,     CIM_ENABLE_INDICATION_SUBSCRIPTION_RESPONSE_MESSAGE,
     CIM_MODIFY_INDICATION_SUBSCRIPTION_RESPONSE_MESSAGE,     CIM_MODIFY_INDICATION_SUBSCRIPTION_RESPONSE_MESSAGE,
     CIM_DISABLE_INDICATION_SUBSCRIPTION_RESPONSE_MESSAGE,     CIM_DISABLE_INDICATION_SUBSCRIPTION_RESPONSE_MESSAGE,
       CIM_PROCESS_INDICATION_RESPONSE_MESSAGE,
       CIM_NOTIFY_PROVIDER_REGISTRATION_RESPONSE_MESSAGE,
       CIM_NOTIFY_PROVIDER_TERMINATION_RESPONSE_MESSAGE,
       CIM_HANDLE_INDICATION_RESPONSE_MESSAGE,
   
       // new
       CIM_ENABLE_INDICATIONS_RESPONSE_MESSAGE,
       CIM_DISABLE_INDICATIONS_RESPONSE_MESSAGE,
       CIM_CREATE_SUBSCRIPTION_RESPONSE_MESSAGE,
       CIM_MODIFY_SUBSCRIPTION_RESPONSE_MESSAGE,
       CIM_DELETE_SUBSCRIPTION_RESPONSE_MESSAGE,
   
       // new
       CIM_DISABLE_MODULE_RESPONSE_MESSAGE,
       CIM_ENABLE_MODULE_RESPONSE_MESSAGE,
  
     // Monitor-related messages:     // Monitor-related messages:
  
Line 255 
Line 396 
     // HTTP messages:     // HTTP messages:
  
     HTTP_MESSAGE,     HTTP_MESSAGE,
       HTTP_ERROR_MESSAGE,
   
       // Exception messages to be passed to a CIM client application:
   
       CLIENT_EXCEPTION_MESSAGE,
   
       ASYNC_REGISTER_CIM_SERVICE,
       ASYNC_DEREGISTER_CIM_SERVICE,
       ASYNC_UPDATE_CIM_SERVICE,
       ASYNC_IOCTL,
       ASYNC_CIMSERVICE_START,
       ASYNC_CIMSERVICE_STOP,
       ASYNC_CIMSERVICE_PAUSE,
       ASYNC_CIMSERVICE_RESUME,
   
       ASYNC_ASYNC_OP_START,
       ASYNC_ASYNC_OP_RESULT,
       ASYNC_ASYNC_LEGACY_OP_START,
       ASYNC_ASYNC_LEGACY_OP_RESULT,
   
       ASYNC_FIND_SERVICE_Q,
       ASYNC_FIND_SERVICE_Q_RESULT,
       ASYNC_ENUMERATE_SERVICE,
       ASYNC_ENUMERATE_SERVICE_RESULT,
   
       ASYNC_REGISTERED_MODULE,
       ASYNC_DEREGISTERED_MODULE,
       ASYNC_FIND_MODULE_IN_SERVICE,
       ASYNC_FIND_MODULE_IN_SERVICE_RESPONSE,
   
       ASYNC_ASYNC_MODULE_OP_START,
       ASYNC_ASYNC_MODULE_OP_RESULT,
  
     NUMBER_OF_MESSAGES     NUMBER_OF_MESSAGES
 }; };

Legend:
Removed from v.1.6  
changed lines
  Added in v.1.33
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2