(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.33 and 1.68

version 1.33, 2002/05/01 21:32:53 version 1.68, 2005/04/14 17:51:48
Line 1 
Line 1 
 //%///-*-c++-*-/////////////////////////////////////////////////////////////////  //%2005////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 29 
Line 35 
 //              Mike Day (mdday@us.ibm.com) //              Mike Day (mdday@us.ibm.com)
 //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com) //              Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)
 //              Arthur Pichlkostner (via Markus: sedgewick_de@yahoo.de) //              Arthur Pichlkostner (via Markus: sedgewick_de@yahoo.de)
   //                              Willis White (whiwill@us.ibm.com) PEP 127 and 128
   //         Brian G. Campbell, EMC (campbell_brian@emc.com) - PEP140/phase1
   //              Amit K Arora, IBM (amita@in.ibm.com) for Bug#1090
   //
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 38 
Line 48 
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <iostream> #include <iostream>
 #include <cstring> #include <cstring>
 #include <Pegasus/Common/Exception.h>  #include <Pegasus/Common/InternalException.h>
 #include <Pegasus/Common/IPC.h> #include <Pegasus/Common/IPC.h>
 #include <Pegasus/Common/StatisticalData.h> #include <Pegasus/Common/StatisticalData.h>
   #include <Pegasus/Common/Linkage.h>
   #include <Pegasus/Common/TimeValue.h>
   #include <Pegasus/Common/CIMOperationType.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 92 
Line 105 
 class AsyncLegacyOperationStart; class AsyncLegacyOperationStart;
 class AsyncLegacyOperationResult; class AsyncLegacyOperationResult;
  
   enum HttpMethod
   {
       HTTP_METHOD__POST,
       HTTP_METHOD_M_POST
   };
   
 /** 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
     (see MessageQueue class). Derived classes may add their own fields.     (see MessageQueue class). Derived classes may add their own fields.
Line 118 
Line 137 
          _key(key),          _key(key),
          _routing_code(routing_code),          _routing_code(routing_code),
          _mask(mask),          _mask(mask),
            _httpMethod (HTTP_METHOD__POST),
           _last_thread_id(pegasus_thread_self()),
          _next(0),          _next(0),
          _prev(0),          _prev(0),
          _async(0),          _async(0),
          dest(destination)           dest(destination),
            _isComplete(true),
            _index(0)
       {       {
  
       }       }
  
       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)       Message & operator = ( const Message & msg)
       {       {
          if (this != &msg)          if (this != &msg)
Line 147 
Line 157 
             _key = msg._key;             _key = msg._key;
             _routing_code = msg._routing_code;             _routing_code = msg._routing_code;
             _mask = msg._mask;             _mask = msg._mask;
               _last_thread_id = msg._last_thread_id;
             _next = _prev = _async = 0;             _next = _prev = _async = 0;
             dest = msg.dest;             dest = msg.dest;
                           _httpMethod = msg._httpMethod;
                           _index = msg._index;
                           _isComplete = msg._isComplete;
   
          }          }
          return *this;          return *this;
       }       }
Line 171 
Line 186 
  
       void setMask(Uint32 mask) { _mask = mask; }       void setMask(Uint32 mask) { _mask = mask; }
  
 #ifdef PEGASUS_HAS_PERFINST        HttpMethod getHttpMethod() const { return _httpMethod; }
   
         void setHttpMethod(HttpMethod httpMethod) {_httpMethod = httpMethod;}
   
   
   #ifndef PEGASUS_DISABLE_PERFINST
 // //
 // Needed for performance measurement // Needed for performance measurement
 // //
Line 184 
Line 204 
  
       void endProvider();       void endProvider();
  
       timeval getStartServerTime() const { return _timeServerStart; }        TimeValue getStartServerTime() const { return _timeServerStart; }
  
       void setStartServerTime(timeval timeServerStart)        void setStartServerTime(TimeValue timeServerStart)
       {       {
            _timeServerStart = timeServerStart;            _timeServerStart = timeServerStart;
       }       }
  
       timeval getStartProviderTime() const { return _timeProviderStart; }        TimeValue getStartProviderTime() const { return _timeProviderStart; }
  
       void setStartProviderTime(timeval timeProviderStart)        void setStartProviderTime(TimeValue timeProviderStart)
       {       {
           _timeProviderStart = timeProviderStart;           _timeProviderStart = timeProviderStart;
       }       }
  
       timeval getEndServerTime() const { return _timeServerEnd; }        TimeValue getEndServerTime() const { return _timeServerEnd; }
  
       void setEndServerTime (timeval timeServerEnd)        void setEndServerTime (TimeValue timeServerEnd)
       {       {
           _timeServerEnd = timeServerEnd;           _timeServerEnd = timeServerEnd;
       }       }
  
       timeval getEndProviderTime() const { return _timeProviderEnd; }        TimeValue getEndProviderTime() const { return _timeProviderEnd; }
  
       void setEndProviderTime(timeval timeProviderEnd)        void setEndProviderTime(TimeValue timeProviderEnd)
       {       {
           _timeProviderEnd = timeProviderEnd;           _timeProviderEnd = timeProviderEnd;
       }       }
  
       Uint32 getTotalTime() { return _totalTime; }            TimeValue getProviderTime() { return _providerTime;}
   
         TimeValue getTotalTime() { return _totalTime; }
   
             TimeValue getServerTime() { return _serverTime; }
 // //
 #endif #endif
  
Line 226 
Line 250 
  
       static Uint32 getNextKey()       static Uint32 getNextKey()
       {       {
             AutoMutex autoMut(_mut);
          _mut.lock( pegasus_thread_self() ) ;  
          Uint32 ret = _nextKey++;          Uint32 ret = _nextKey++;
          _mut.unlock();  
          return ret;          return ret;
       }       }
  
       virtual void print(PEGASUS_STD(ostream)& os) const;        static CIMOperationType convertMessageTypetoCIMOpType(Uint32 type);
   
         virtual void print(
             PEGASUS_STD(ostream)& os,
             Boolean printHeader = true) const;
  
       // << Thu Dec 27 10:46:04 2001 mdd >> for use with DQueue container       // << Thu Dec 27 10:46:04 2001 mdd >> for use with DQueue container
       // as used by AsyncOpNode       // as used by AsyncOpNode
Line 257 
Line 283 
          _async = msg;          _async = msg;
       }       }
  
         // << Tue Jul  1 11:02:49 2003 mdd >> pep_88 and helper for i18n and l10n
         Boolean thread_changed(void)
         {
            if(_last_thread_id != pegasus_thread_self())
            {
               _last_thread_id = pegasus_thread_self();
               return true;
            }
   
            return false;
         }
   
         // << Tue Jul  1 13:41:02 2003 mdd >> pep_88 -
         // assist in synchronizing responses with requests
   
         void synch_response(Message *req)
         {
            _key = req->_key;
            _routing_code = req->_routing_code;
         }
   
                           // set the message index indicating what piece (or sequence) this is
                           // message indexes start at zero
                           void setIndex(Uint32 index) { _index = index; }
   
                           // increment the message index
                           void incrementIndex() { _index++; }
   
                           // set the complete flag indicating if this message piece is the
                           // last or not
                           void setComplete(Boolean isComplete)
                                   { _isComplete = isComplete ? true:false; }
   
                           // get the message index (or sequence number)
                           Uint32 getIndex() const { return _index; }
   
                           // is this the first piece of the message ?
                           Boolean isFirst() const { return _index == 0 ? true : false; }
   
                           // is this message complete? (i.e the last in a one or more sequence)
                           Boolean isComplete() const { return _isComplete; }
  
    private:    private:
       Uint32 _type;       Uint32 _type;
       Uint32 _key;       Uint32 _key;
       Uint32 _routing_code;       Uint32 _routing_code;
       Uint32 _mask;       Uint32 _mask;
         HttpMethod _httpMethod;
 // Needed for performance measurement // Needed for performance measurement
       timeval _timeServerStart;        TimeValue _timeServerStart;
       timeval _timeServerEnd;        TimeValue _timeServerEnd;
       timeval _timeProviderStart;        TimeValue _timeProviderStart;
       timeval _timeProviderEnd;        TimeValue _timeProviderEnd;
       Uint64 _totalTime;            TimeValue _providerTime;
             TimeValue _serverTime;
         TimeValue _totalTime;
 // //
   
         // << Tue Jul  1 11:02:35 2003 mdd >> pep_88 and helper for i18n and l10n
         PEGASUS_THREAD_TYPE _last_thread_id;
   
       Message* _next;       Message* _next;
       Message* _prev;       Message* _prev;
  
Line 278 
Line 352 
    public:    public:
       Message *_async;       Message *_async;
       Uint32 dest;       Uint32 dest;
             //needed for PEP 128 - transmitting Server Response Time to Client
         Uint64 totServerTime;
   
    private:    private:
       MessageQueue* _owner;       MessageQueue* _owner;
         Boolean _isComplete;
         Uint32 _index;
       static Uint32 _nextKey;       static Uint32 _nextKey;
       static Mutex _mut;       static Mutex _mut;
   
   
   
       friend class cimom;       friend class cimom;
       friend class MessageQueue;       friend class MessageQueue;
       friend class MessageQueueService;       friend class MessageQueueService;
Line 331 
Line 413 
     CIM_NOTIFY_PROVIDER_TERMINATION_REQUEST_MESSAGE,     CIM_NOTIFY_PROVIDER_TERMINATION_REQUEST_MESSAGE,
  
     // new     // new
     CIM_ENABLE_INDICATIONS_REQUEST_MESSAGE,  
     CIM_DISABLE_INDICATIONS_REQUEST_MESSAGE,  
     CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE,     CIM_CREATE_SUBSCRIPTION_REQUEST_MESSAGE,
     CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE,     CIM_MODIFY_SUBSCRIPTION_REQUEST_MESSAGE,
     CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE,     CIM_DELETE_SUBSCRIPTION_REQUEST_MESSAGE,
Line 341 
Line 421 
     CIM_DISABLE_MODULE_REQUEST_MESSAGE,     CIM_DISABLE_MODULE_REQUEST_MESSAGE,
     CIM_ENABLE_MODULE_REQUEST_MESSAGE,     CIM_ENABLE_MODULE_REQUEST_MESSAGE,
  
     CIM_GET_CLASS_RESPONSE_MESSAGE, // 40      CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE,
     CIM_GET_INSTANCE_RESPONSE_MESSAGE,  
     CIM_EXPORT_INDICATION_RESPONSE_MESSAGE, // 42      CIM_GET_CLASS_RESPONSE_MESSAGE,
       CIM_GET_INSTANCE_RESPONSE_MESSAGE,  // 40
       CIM_EXPORT_INDICATION_RESPONSE_MESSAGE,
     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 352 
Line 434 
     CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE,     CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE,
     CIM_ENUMERATE_CLASSES_RESPONSE_MESSAGE,     CIM_ENUMERATE_CLASSES_RESPONSE_MESSAGE,
     CIM_ENUMERATE_CLASS_NAMES_RESPONSE_MESSAGE,     CIM_ENUMERATE_CLASS_NAMES_RESPONSE_MESSAGE,
     CIM_ENUMERATE_INSTANCES_RESPONSE_MESSAGE,      CIM_ENUMERATE_INSTANCES_RESPONSE_MESSAGE,  // 50
     CIM_ENUMERATE_INSTANCE_NAMES_RESPONSE_MESSAGE,     CIM_ENUMERATE_INSTANCE_NAMES_RESPONSE_MESSAGE,
     CIM_EXEC_QUERY_RESPONSE_MESSAGE,     CIM_EXEC_QUERY_RESPONSE_MESSAGE,
     CIM_ASSOCIATORS_RESPONSE_MESSAGE,     CIM_ASSOCIATORS_RESPONSE_MESSAGE,
Line 362 
Line 444 
     CIM_GET_PROPERTY_RESPONSE_MESSAGE,     CIM_GET_PROPERTY_RESPONSE_MESSAGE,
     CIM_SET_PROPERTY_RESPONSE_MESSAGE,     CIM_SET_PROPERTY_RESPONSE_MESSAGE,
     CIM_GET_QUALIFIER_RESPONSE_MESSAGE,     CIM_GET_QUALIFIER_RESPONSE_MESSAGE,
     CIM_SET_QUALIFIER_RESPONSE_MESSAGE,      CIM_SET_QUALIFIER_RESPONSE_MESSAGE,  // 60
     CIM_DELETE_QUALIFIER_RESPONSE_MESSAGE,     CIM_DELETE_QUALIFIER_RESPONSE_MESSAGE,
     CIM_ENUMERATE_QUALIFIERS_RESPONSE_MESSAGE,     CIM_ENUMERATE_QUALIFIERS_RESPONSE_MESSAGE,
     CIM_INVOKE_METHOD_RESPONSE_MESSAGE,     CIM_INVOKE_METHOD_RESPONSE_MESSAGE,
Line 372 
Line 454 
     CIM_PROCESS_INDICATION_RESPONSE_MESSAGE,     CIM_PROCESS_INDICATION_RESPONSE_MESSAGE,
     CIM_NOTIFY_PROVIDER_REGISTRATION_RESPONSE_MESSAGE,     CIM_NOTIFY_PROVIDER_REGISTRATION_RESPONSE_MESSAGE,
     CIM_NOTIFY_PROVIDER_TERMINATION_RESPONSE_MESSAGE,     CIM_NOTIFY_PROVIDER_TERMINATION_RESPONSE_MESSAGE,
     CIM_HANDLE_INDICATION_RESPONSE_MESSAGE,      CIM_HANDLE_INDICATION_RESPONSE_MESSAGE,  // 70
  
     // new     // new
     CIM_ENABLE_INDICATIONS_RESPONSE_MESSAGE,  
     CIM_DISABLE_INDICATIONS_RESPONSE_MESSAGE,  
     CIM_CREATE_SUBSCRIPTION_RESPONSE_MESSAGE,     CIM_CREATE_SUBSCRIPTION_RESPONSE_MESSAGE,
     CIM_MODIFY_SUBSCRIPTION_RESPONSE_MESSAGE,     CIM_MODIFY_SUBSCRIPTION_RESPONSE_MESSAGE,
     CIM_DELETE_SUBSCRIPTION_RESPONSE_MESSAGE,     CIM_DELETE_SUBSCRIPTION_RESPONSE_MESSAGE,
Line 385 
Line 465 
     CIM_DISABLE_MODULE_RESPONSE_MESSAGE,     CIM_DISABLE_MODULE_RESPONSE_MESSAGE,
     CIM_ENABLE_MODULE_RESPONSE_MESSAGE,     CIM_ENABLE_MODULE_RESPONSE_MESSAGE,
  
       CIM_STOP_ALL_PROVIDERS_RESPONSE_MESSAGE,
   
     // Monitor-related messages:     // Monitor-related messages:
  
     SOCKET_MESSAGE,     SOCKET_MESSAGE,
Line 396 
Line 478 
     // HTTP messages:     // HTTP messages:
  
     HTTP_MESSAGE,     HTTP_MESSAGE,
     HTTP_ERROR_MESSAGE,      HTTP_ERROR_MESSAGE,  // 80
  
     // Exception messages to be passed to a CIM client application:     // Exception messages to be passed to a CIM client application:
  
Line 411 
Line 493 
     ASYNC_CIMSERVICE_PAUSE,     ASYNC_CIMSERVICE_PAUSE,
     ASYNC_CIMSERVICE_RESUME,     ASYNC_CIMSERVICE_RESUME,
  
     ASYNC_ASYNC_OP_START,      ASYNC_ASYNC_OP_START,  // 90
     ASYNC_ASYNC_OP_RESULT,     ASYNC_ASYNC_OP_RESULT,
     ASYNC_ASYNC_LEGACY_OP_START,     ASYNC_ASYNC_LEGACY_OP_START,
     ASYNC_ASYNC_LEGACY_OP_RESULT,     ASYNC_ASYNC_LEGACY_OP_RESULT,
Line 423 
Line 505 
  
     ASYNC_REGISTERED_MODULE,     ASYNC_REGISTERED_MODULE,
     ASYNC_DEREGISTERED_MODULE,     ASYNC_DEREGISTERED_MODULE,
     ASYNC_FIND_MODULE_IN_SERVICE,      ASYNC_FIND_MODULE_IN_SERVICE,  // 100
     ASYNC_FIND_MODULE_IN_SERVICE_RESPONSE,     ASYNC_FIND_MODULE_IN_SERVICE_RESPONSE,
  
     ASYNC_ASYNC_MODULE_OP_START,     ASYNC_ASYNC_MODULE_OP_START,
     ASYNC_ASYNC_MODULE_OP_RESULT,     ASYNC_ASYNC_MODULE_OP_RESULT,
  
       CIM_NOTIFY_PROVIDER_ENABLE_REQUEST_MESSAGE,
       CIM_NOTIFY_PROVIDER_ENABLE_RESPONSE_MESSAGE,
   
       CIM_INITIALIZE_PROVIDER_REQUEST_MESSAGE,
       CIM_INITIALIZE_PROVIDER_RESPONSE_MESSAGE,
   
       CIM_INITIALIZE_PROVIDER_AGENT_REQUEST_MESSAGE,
       CIM_INITIALIZE_PROVIDER_AGENT_RESPONSE_MESSAGE,
   
       CIM_NOTIFY_CONFIG_CHANGE_REQUEST_MESSAGE,
       CIM_NOTIFY_CONFIG_CHANGE_RESPONSE_MESSAGE,
   
       CIM_SUBSCRIPTION_INIT_COMPLETE_REQUEST_MESSAGE,
       CIM_SUBSCRIPTION_INIT_COMPLETE_RESPONSE_MESSAGE,
   
     NUMBER_OF_MESSAGES     NUMBER_OF_MESSAGES
 }; };
  
Line 438 
Line 535 
     stack of queue-ids of queues which they must be returned to. This provides     stack of queue-ids of queues which they must be returned to. This provides
     a light efficient stack for this purpose.     a light efficient stack for this purpose.
 */ */
 class QueueIdStack  class PEGASUS_COMMON_LINKAGE QueueIdStack
 { {
 public: public:
  
Line 446 
Line 543 
     {     {
     }     }
  
     QueueIdStack(const QueueIdStack& x) : _size(x._size)      QueueIdStack(const QueueIdStack& x);
     {  
         memcpy(_items, x._items, sizeof(_items));  
     }  
  
     PEGASUS_EXPLICIT QueueIdStack(Uint32 x) : _size(0)      PEGASUS_EXPLICIT QueueIdStack(Uint32 x);
     {  
         push(x);  
     }  
  
     PEGASUS_EXPLICIT QueueIdStack(Uint32 x1, Uint32 x2) : _size(0)      PEGASUS_EXPLICIT QueueIdStack(Uint32 x1, Uint32 x2);
     {  
         push(x1);  
         push(x2);  
     }  
  
     ~QueueIdStack()     ~QueueIdStack()
     {     {
     }     }
  
     QueueIdStack& operator=(const QueueIdStack& x)      QueueIdStack& operator=(const QueueIdStack& x);
     {  
         if (this != &x)  
         {  
             memcpy(_items, x._items, sizeof(_items));  
             _size = x._size;  
         }  
         return *this;  
     }  
  
     Uint32 size() const     Uint32 size() const
     {     {
Line 488 
Line 567 
  
     void push(Uint32 x)     void push(Uint32 x)
     {     {
   #ifdef PEGASUS_DEBUG
         if (_size == MAX_SIZE)         if (_size == MAX_SIZE)
             throw StackOverflow();             throw StackOverflow();
   #endif
         _items[_size++] = x;         _items[_size++] = x;
     }     }
  
     Uint32& top()     Uint32& top()
     {     {
   #ifdef PEGASUS_DEBUG
         if (_size == 0)         if (_size == 0)
             throw StackUnderflow();             throw StackUnderflow();
   #endif
         return _items[_size-1];         return _items[_size-1];
     }     }
  
Line 509 
Line 590 
  
     void pop()     void pop()
     {     {
   #ifdef PEGASUS_DEBUG
         if (_size == 0)         if (_size == 0)
             throw StackUnderflow();             throw StackUnderflow();
   #endif
         _size--;         _size--;
     }     }
  
     /** Make a copy of this stack and then pop the top element. */     /** Make a copy of this stack and then pop the top element. */
     QueueIdStack copyAndPop() const      QueueIdStack copyAndPop() const;
     {  
         return QueueIdStack(*this, 0);  
     }  
  
 private: private:
  
     // Copy the given stack but then pop the top element:     // Copy the given stack but then pop the top element:
     QueueIdStack(const QueueIdStack& x, int) : _size(x._size)      QueueIdStack(const QueueIdStack& x, int);
     {  
         memcpy(_items, x._items, sizeof(_items));  
         pop();  
     }  
  
     enum { MAX_SIZE = 5 };     enum { MAX_SIZE = 5 };
     Uint32 _items[MAX_SIZE];     Uint32 _items[MAX_SIZE];

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