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.9 and 1.49

version 1.5.2.9, 2001/12/05 22:36:29

version 1.49, 2004/04/16 22:17:41

Line 1

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

//%2003////////////////////////////////////////////////////////////////////////

// The Open Group, Tivoli Systems

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

// IBM Corp.; EMC 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 26

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

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

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

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

static Uint32 type_CIMAsyncOperation;

static Uint32 type_export;

static Uint32 type_lifetime;

static Uint32 type_socket;

static Uint32 type_connection;

static Uint32 type_http;

static Uint32 type_http_error;

static Uint32 type_cimom;

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 56

Line 116

{

public:

Message(Uint32 type, Uint32 key = getNextKey())

Message(

: _type(type), _key(key), _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)

{

}

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;

}

return *this;

}

virtual ~Message();

Line 69

Line 165

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

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

{

_timeProviderStart = timeProviderStart;

}

timeval getEndServerTime() const { return _timeServerEnd; }

void setEndServerTime (timeval timeServerEnd)

{

_timeServerEnd = timeServerEnd;

}

timeval getEndProviderTime() const { return _timeProviderEnd; }

void setEndProviderTime(timeval timeProviderEnd)

{

_timeProviderEnd = timeProviderEnd;

}

Uint32 getTotalTime() { return _totalTime; }

#endif

Message* getNext() { return _next; }

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

Line 77

Line 229

const Message* getPrevious() const { return _prev; }

static Uint32 getNextKey() { return ++_nextKey; }

static Uint32 getNextKey()

{

_mut.lock( pegasus_thread_self() ) ;

Uint32 ret = _nextKey++;

_mut.unlock();

return ret;

}

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;

}

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

private:

Uint32 _type;

Uint32 _key;

Uint32 _routing_code;

Uint32 _mask;

HttpMethod _httpMethod;

// Needed for performance measurement

timeval _timeServerStart;

timeval _timeServerEnd;

timeval _timeProviderStart;

timeval _timeProviderEnd;

Uint64 _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;

private:

MessageQueue* _owner;

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 132

Line 342

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 142

Line 352

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 151

Line 361

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 160

Line 388

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 170

Line 398

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 179

Line 407

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 191

Line 436

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

// for indication consumers

CIM_CONSUME_INDICATION_REQUEST_MESSAGE,

CIM_CONSUME_INDICATION_RESPONSE_MESSAGE,

CIM_NOTIFY_PROVIDER_ENABLE_REQUEST_MESSAGE,

CIM_NOTIFY_PROVIDER_ENABLE_RESPONSE_MESSAGE,

NUMBER_OF_MESSAGES

};

Legend:

Removed from v.1.5.2.9
changed lines
	Added in v.1.49

No CVS admin address has been configured