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.11 and 1.60.2.1

version 1.5.2.11, 2001/12/06 22:33:25

version 1.60.2.1, 2005/01/26 16:18:38

Line 1

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

//%2004////////////////////////////////////////////////////////////////////////

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

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

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

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

#ifndef Pegasus_Message_h

#define Pegasus_Message_h

#include <Pegasus/Common/Config.h>

#include <iostream>

#include <cstring>

#include <Pegasus/Common/Config.h>

#include <Pegasus/Common/InternalException.h>

#include <Pegasus/Common/Exception.h>

#include <Pegasus/Common/IPC.h>

#include <Pegasus/Common/StatisticalData.h>

#include <Pegasus/Common/Linkage.h>

#include <Pegasus/Common/CIMDateTime.h>

PEGASUS_NAMESPACE_BEGIN

class PEGASUS_EXPORT message_mask

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

Line 123

{

public:

Message(Uint32 type, Uint32 key = getNextKey(), Uint32 mask = message_mask::type_legacy)

Message(

: _type(type), _key(key), _mask(mask), _next(0), _prev(0) { }

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),

_last_thread_id(pegasus_thread_self()),

_next(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();

Line 90

Line 176

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();

CIMDateTime getStartServerTime() const { return _timeServerStart; }

void setStartServerTime(CIMDateTime timeServerStart)

{

_timeServerStart = timeServerStart;

}

CIMDateTime getStartProviderTime() const { return _timeProviderStart; }

void setStartProviderTime(CIMDateTime timeProviderStart)

{

_timeProviderStart = timeProviderStart;

}

CIMDateTime getEndServerTime() const { return _timeServerEnd; }

void setEndServerTime (CIMDateTime timeServerEnd)

{

_timeServerEnd = timeServerEnd;

}

CIMDateTime getEndProviderTime() const { return _timeProviderEnd; }

void setEndProviderTime(CIMDateTime timeProviderEnd)

{

_timeProviderEnd = timeProviderEnd;

}

CIMDateTime getProviderTime() { return _providerTime;}

CIMDateTime getTotalTime() { return _totalTime; }

CIMDateTime getServerTime() { return _serverTime; }

#endif

Message* getNext() { return _next; }

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

Line 100

Line 246

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;

virtual void print(

PEGASUS_STD(ostream)& os,

Boolean printHeader = true) 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;

}

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

CIMDateTime _timeServerStart;

CIMDateTime _timeServerEnd;

CIMDateTime _timeProviderStart;

CIMDateTime _timeProviderEnd;

CIMDateTime _providerTime;

CIMDateTime _serverTime;

CIMDateTime _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* _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 162

Line 382

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 172

Line 392

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 181

Line 401

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_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_STOP_ALL_PROVIDERS_REQUEST_MESSAGE, // 40

CIM_GET_CLASS_RESPONSE_MESSAGE,

CIM_GET_INSTANCE_RESPONSE_MESSAGE,

CIM_EXPORT_INDICATION_RESPONSE_MESSAGE,

Line 190

Line 428

CIM_CREATE_INSTANCE_RESPONSE_MESSAGE,

CIM_MODIFY_CLASS_RESPONSE_MESSAGE,

CIM_MODIFY_INSTANCE_RESPONSE_MESSAGE,

CIM_ENUMERATE_CLASSES_RESPONSE_MESSAGE,

CIM_ENUMERATE_CLASSES_RESPONSE_MESSAGE, // 50

CIM_ENUMERATE_CLASS_NAMES_RESPONSE_MESSAGE,

CIM_ENUMERATE_INSTANCES_RESPONSE_MESSAGE,

CIM_ENUMERATE_INSTANCE_NAMES_RESPONSE_MESSAGE,

Line 200

Line 438

CIM_REFERENCES_RESPONSE_MESSAGE,

CIM_REFERENCE_NAMES_RESPONSE_MESSAGE,

CIM_GET_PROPERTY_RESPONSE_MESSAGE,

CIM_SET_PROPERTY_RESPONSE_MESSAGE,

CIM_SET_PROPERTY_RESPONSE_MESSAGE, // 60

CIM_GET_QUALIFIER_RESPONSE_MESSAGE,

CIM_SET_QUALIFIER_RESPONSE_MESSAGE,

CIM_DELETE_QUALIFIER_RESPONSE_MESSAGE,

Line 209

Line 447

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

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,

CIM_STOP_ALL_PROVIDERS_RESPONSE_MESSAGE, // 80

// Monitor-related messages:

Line 221

Line 476

// HTTP messages:

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

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

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,

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,

NUMBER_OF_MESSAGES

};

Line 231

Line 530

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 239

Line 538

{

}

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 281

Line 562

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 302

Line 585

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.11
changed lines
	Added in v.1.60.2.1

No CVS admin address has been configured