pegasus/src/Pegasus/Common/Message.h - diff

Return to Message.h CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/Message.h between version 1.5.2.13 and 1.72

version 1.5.2.13, 2001/12/10 16:24:58

version 1.72, 2006/01/30 16:17:05

Line 1

//%///-*-c++-*-/////////////////////////////////////////////////////////////////

//%2006////////////////////////////////////////////////////////////////////////

// The Open Group, Tivoli Systems

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

// IBM Corp.; EMC Corporation, The Open Group.

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// EMC Corporation; Symantec Corporation; The Open Group.

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to

Line 24

Line 32

// Author: Mike Brasher (mbrasher@bmc.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)

// Mike Day (mdday@us.ibm.com)

// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)

// 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

//%/////////////////////////////////////////////////////////////////////////////

Line 35

Line 51

#include <Pegasus/Common/Config.h>

#include <iostream>

#include <cstring>

#include <Pegasus/Common/Exception.h>

#include <Pegasus/Common/InternalException.h>

#include <Pegasus/Common/IPC.h>

#include <Pegasus/Common/StatisticalData.h>

#include <Pegasus/Common/Linkage.h>

#include <Pegasus/Common/TimeValue.h>

#include <Pegasus/Common/CIMOperationType.h>

PEGASUS_NAMESPACE_BEGIN

// REVIEW: could class be renamed to MessageMask (coding standard)

class PEGASUS_COMMON_LINKAGE message_mask

{

public:

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_connection;

static Uint32 type_http;

static Uint32 type_http_error;

static Uint32 type_cimom;

static Uint32 type_request;

static Uint32 type_reply;

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

inline Uint32 get_type(Uint32 flags)

{

return (flags & 0x000fffff);

}

inline Uint32 get_handling(Uint32 flags)

{

return( flags & 0xfff00000);

}

};

class cimom;

class MessageQueue;

class MessageQueueService;

class AsyncLegacyOperationStart;

class AsyncLegacyOperationResult;

enum HttpMethod

{

HTTP_METHOD__POST,

HTTP_METHOD_M_POST

};

/** The Message class and derived classes are used to pass messages between

modules. Messages are passed between modules using the message queues

Line 78

Line 131

Message(

Uint32 type,

Uint32 destination = 0,

Uint32 key = getNextKey(),

Uint32 routing_code = 0,

Uint32 mask = message_mask::type_legacy)

_type(type),

_key(key),

_routing_code(routing_code),

_mask(mask),

_httpMethod (HTTP_METHOD__POST),

_close_connect(false),

_last_thread_id(pegasus_thread_self()),

_next(0),

_prev(0)

_prev(0),

_async(0),

dest(destination),

_isComplete(true),

_index(0)

{

}

Message & operator = ( const Message & msg)

{

if (this != &msg)

{

_type = msg._type;

_key = msg._key;

_routing_code = msg._routing_code;

_mask = msg._mask;

_last_thread_id = msg._last_thread_id;

_next = _prev = _async = 0;

dest = msg.dest;

_httpMethod = msg._httpMethod;

_index = msg._index;

_isComplete = msg._isComplete;

}

return *this;

}

virtual ~Message();

Boolean getCloseConnect() const { return _close_connect; }

void setCloseConnect(Boolean close_connect)

{

_close_connect = close_connect;

}

Uint32 getType() const { return _type; }

Line 100

Line 188

void setKey(Uint32 key) { _key = key; }

Uint32 getRouting() const { return _routing_code; }

void setRouting(Uint32 routing) { _routing_code = routing; }

Uint32 getMask() const { return _mask; }

void setMask(Uint32 mask) { _mask = mask; }

HttpMethod getHttpMethod() const { return _httpMethod; }

void setHttpMethod(HttpMethod httpMethod) {_httpMethod = httpMethod;}

#ifndef PEGASUS_DISABLE_PERFINST

// Needed for performance measurement

void startServer();

void endServer();

void startProvider();

void endProvider();

TimeValue getStartServerTime() const { return _timeServerStart; }

void setStartServerTime(TimeValue timeServerStart)

{

_timeServerStart = timeServerStart;

}

TimeValue getStartProviderTime() const { return _timeProviderStart; }

void setStartProviderTime(TimeValue timeProviderStart)

{

_timeProviderStart = timeProviderStart;

}

TimeValue getEndServerTime() const { return _timeServerEnd; }

void setEndServerTime (TimeValue timeServerEnd)

{

_timeServerEnd = timeServerEnd;

}

TimeValue getEndProviderTime() const { return _timeProviderEnd; }

void setEndProviderTime(TimeValue timeProviderEnd)

{

_timeProviderEnd = timeProviderEnd;

}

TimeValue getServerTime() { return _serverTime; }

#endif

Message* getNext() { return _next; }

const Message* getNext() const { return _next; }

Line 110

Line 255

static Uint32 getNextKey()

{

AutoMutex autoMut(_mut);

_mut.lock( pegasus_thread_self() ) ;

Uint32 ret = _nextKey++;

_mut.unlock();

return ret;

}

virtual void print(PEGASUS_STD(ostream)& os) const;

static CIMOperationType convertMessageTypetoCIMOpType(Uint32 type);

#ifdef PEGASUS_DEBUG

virtual void print(

PEGASUS_STD(ostream)& os,

Boolean printHeader = true) const;

#endif

// << 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;

}

// << 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:

Uint32 _type;

Uint32 _key;

Uint32 _routing_code;

Uint32 _mask;

HttpMethod _httpMethod;

// Needed for performance measurement

TimeValue _timeServerStart;

TimeValue _timeServerEnd;

TimeValue _timeProviderStart;

TimeValue _timeProviderEnd;

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* _prev;

protected:

public:

Message *_async;

Uint32 dest;

//needed for PEP 128 - transmitting Server Response Time to Client

Uint64 totServerTime;

private:

MessageQueue* _owner;

Boolean _isComplete;

Uint32 _index;

static Uint32 _nextKey;

static Mutex _mut;

friend class cimom;

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

{

Line 172

Line 395

CIM_CREATE_INSTANCE_REQUEST_MESSAGE,

CIM_MODIFY_CLASS_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_INSTANCES_REQUEST_MESSAGE,

CIM_ENUMERATE_INSTANCE_NAMES_REQUEST_MESSAGE,

Line 182

Line 405

CIM_REFERENCES_REQUEST_MESSAGE,

CIM_REFERENCE_NAMES_REQUEST_MESSAGE,

CIM_GET_PROPERTY_REQUEST_MESSAGE,

CIM_SET_PROPERTY_REQUEST_MESSAGE,

CIM_SET_PROPERTY_REQUEST_MESSAGE, //20

CIM_GET_QUALIFIER_REQUEST_MESSAGE,

CIM_SET_QUALIFIER_REQUEST_MESSAGE,

CIM_DELETE_QUALIFIER_REQUEST_MESSAGE,

Line 191

Line 414

CIM_ENABLE_INDICATION_SUBSCRIPTION_REQUEST_MESSAGE,

CIM_MODIFY_INDICATION_SUBSCRIPTION_REQUEST_MESSAGE,

CIM_DISABLE_INDICATION_SUBSCRIPTION_REQUEST_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_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_STOP_ALL_PROVIDERS_REQUEST_MESSAGE,

CIM_GET_CLASS_RESPONSE_MESSAGE,

CIM_GET_INSTANCE_RESPONSE_MESSAGE,

CIM_GET_INSTANCE_RESPONSE_MESSAGE, // 40

CIM_EXPORT_INDICATION_RESPONSE_MESSAGE,

CIM_DELETE_CLASS_RESPONSE_MESSAGE,

CIM_DELETE_INSTANCE_RESPONSE_MESSAGE,

Line 202

Line 441

CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE,

CIM_ENUMERATE_CLASSES_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_EXEC_QUERY_RESPONSE_MESSAGE,

CIM_ASSOCIATORS_RESPONSE_MESSAGE,

Line 212

Line 451

CIM_GET_PROPERTY_RESPONSE_MESSAGE,

CIM_SET_PROPERTY_RESPONSE_MESSAGE,

CIM_GET_QUALIFIER_RESPONSE_MESSAGE,

CIM_SET_QUALIFIER_RESPONSE_MESSAGE,

CIM_SET_QUALIFIER_RESPONSE_MESSAGE, // 60

CIM_DELETE_QUALIFIER_RESPONSE_MESSAGE,

CIM_ENUMERATE_QUALIFIERS_RESPONSE_MESSAGE,

CIM_INVOKE_METHOD_RESPONSE_MESSAGE,

CIM_ENABLE_INDICATION_SUBSCRIPTION_RESPONSE_MESSAGE,

CIM_MODIFY_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, // 70

// new

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,

CIM_STOP_ALL_PROVIDERS_RESPONSE_MESSAGE,

// Monitor-related messages:

Line 231

Line 485

// HTTP messages:

HTTP_MESSAGE,

HTTP_ERROR_MESSAGE, // 80

// 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, // 90

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, // 100

ASYNC_FIND_MODULE_IN_SERVICE_RESPONSE,

ASYNC_ASYNC_MODULE_OP_START,

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

};

Line 241

Line 542

stack of queue-ids of queues which they must be returned to. This provides

a light efficient stack for this purpose.

class QueueIdStack

class PEGASUS_COMMON_LINKAGE QueueIdStack

{

public:

Line 249

Line 550

{

}

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& 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

{

Line 291

Line 574

void push(Uint32 x)

{

#ifdef PEGASUS_DEBUG

if (_size == MAX_SIZE)

throw StackOverflow();

#endif

_items[_size++] = x;

}

Uint32& top()

{

#ifdef PEGASUS_DEBUG

if (_size == 0)

throw StackUnderflow();

#endif

return _items[_size-1];

}

Line 312

Line 597

void pop()

{

#ifdef PEGASUS_DEBUG

if (_size == 0)

throw StackUnderflow();

#endif

_size--;

}

/** Make a copy of this stack and then pop the top element. */

QueueIdStack copyAndPop() const

QueueIdStack copyAndPop() const;

{

return QueueIdStack(*this, 0);

}

private:

// 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 };

Uint32 _items[MAX_SIZE];

Legend:

Removed from v.1.5.2.13
changed lines
	Added in v.1.72

No CVS admin address has been configured