version 1.38, 2002/07/26 20:01:19
|
version 1.72, 2006/01/30 16:17:05
|
|
|
//%///////////////////////////////////////////////////////////////////////////// |
//%2006//////////////////////////////////////////////////////////////////////// |
// | // |
// Copyright (c) 2000, 2001, 2002 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. |
|
// Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
|
// EMC Corporation; Symantec 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 |
|
|
// 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 |
|
// John Alex, IBM (johnalex@us.ibm.com) - Bug#2290 |
|
// |
// | // |
//%///////////////////////////////////////////////////////////////////////////// | //%///////////////////////////////////////////////////////////////////////////// |
| |
|
|
#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/Linkage.h> |
|
#include <Pegasus/Common/TimeValue.h> |
|
#include <Pegasus/Common/CIMOperationType.h> |
| |
PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
| |
|
|
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. |
|
|
_key(key), | _key(key), |
_routing_code(routing_code), | _routing_code(routing_code), |
_mask(mask), | _mask(mask), |
|
_httpMethod (HTTP_METHOD__POST), |
|
_close_connect(false), |
|
_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) |
{ | { |
| |
} | } |
|
|
_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; |
} | } |
| |
| |
virtual ~Message(); | virtual ~Message(); |
|
Boolean getCloseConnect() const { return _close_connect; } |
|
void setCloseConnect(Boolean close_connect) |
|
{ |
|
_close_connect = close_connect; |
|
} |
| |
Uint32 getType() const { return _type; } | Uint32 getType() const { return _type; } |
| |
|
|
| |
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 |
// | // |
|
|
| |
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 getServerTime() { return _serverTime; } |
// | // |
#endif | #endif |
| |
|
|
| |
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; |
} | } |
| |
|
static CIMOperationType convertMessageTypetoCIMOpType(Uint32 type); |
|
|
|
#ifdef PEGASUS_DEBUG |
virtual void print( | virtual void print( |
PEGASUS_STD(ostream)& os, | PEGASUS_STD(ostream)& os, |
Boolean printHeader = true) const; | Boolean printHeader = true) const; |
|
#endif |
| |
// << 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 |
|
|
_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 _serverTime; |
|
Boolean _close_connect; |
|
|
// | // |
|
|
|
// << 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; |
| |
|
|
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; |
|
|
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, |
|
|
| |
CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE, | CIM_STOP_ALL_PROVIDERS_REQUEST_MESSAGE, |
| |
CIM_GET_CLASS_RESPONSE_MESSAGE, // 40 |
CIM_GET_CLASS_RESPONSE_MESSAGE, |
CIM_GET_INSTANCE_RESPONSE_MESSAGE, |
CIM_GET_INSTANCE_RESPONSE_MESSAGE, // 40 |
CIM_EXPORT_INDICATION_RESPONSE_MESSAGE, // 42 |
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, |
|
|
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, |
|
|
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, |
|
|
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, |
|
|
// 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: |
| |
|
|
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, |
|
|
| |
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 |
}; | }; |
| |
|
|
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: |
| |
|
|
{ | { |
} | } |
| |
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 |
{ | { |
|
|
| |
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]; |
} | } |
| |
|
|
| |
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]; |