pegasus/doc/MessageQueueService.html - diff

Return to MessageQueueService.html CVS log

Up to [Pegasus] / pegasus / doc

Diff for /pegasus/doc/MessageQueueService.html between version 1.3 and 1.4

version 1.3, 2002/03/12 22:57:40

version 1.4, 2002/03/13 17:33:36

Line 1

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<META http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"><title>XML Pointer Language (XPointer) Version 1.0</title><style type="text/css">

<META http-equiv="Content-Type" content="text/html;

charset=ISO-8859-1"><meta http-equiv="Content-Type"

content="text/html;

charset=ISO-8859-1"><title>Pegasus

Meta Dispatcher </title><style type="text/css">

body {

margin: 2em 1em 2em;

Line 40

Line 44

p.copyright small { font-size: small }

pre { margin-left: 2em }

p {

margin-top: 0.6em;

margin-bottom: 0.6em;

}

dt, dd { margin-top: 0; margin-bottom: 0 } /* opera 3.50 */

dt { font-weight: bold }

Line 57

Line 61

}

code { font-family: monospace; }

var {font-family: monospace; font-style: normal; font-weight: bold;}

div.constraint,

div.issue,

div.note,

div.notice { margin-left: 2em; }

li p { margin-top: 0.3em;

li p { margin-top: 0.8em;

margin-bottom: 0.3em; }

margin-bottom: 0.8em; }

li {margin-top: 0.4em; margin-bottom: 0.4em;}

div.exampleInner pre { margin-left: 1em;

margin-top: 0em; margin-bottom: 0em}

Line 97

Line 103

<body>

this is copyright text

<div class="constraint">this is a constraint</div>

<div class="exampleInner"><code>this is an inner example</code></div>

<h1>Pegasus Meta Dispatcher</h1>

The Pegasus Meta Dispatcher is a set of classes that extend the

Line 124

Line 125

<a href = "#non-blocking">Jump to the non-blocking message interface.</a>

<h2>Purposes of Meta Dispatcher</h2>

The Meta Dispatcher has two primary goals:

The Meta Dispatcher has three primary goals:

<ol>

<li>Provide for orderly asynchronous message-based communication

among a dynamic set of Pegasus Services.</li>

Line 796

Line 799

<hr>

<a name="non-blocking"><h2>Sending Messages without Blocking (Async with Callback)</h2></a>

<h2>Sending Messages without Blocking (Async with Callback)</h2>

Whenever there is a possibility that the processing of

Line 842

Line 844

The <code>MessageQueueService</code> class sends

non-blocking messages using the <code>SendAsync</code>

method from <code>MessageQueueService.h</code>.

<pre>

Boolean SendAsync(AsyncOpNode *op,

Uint32 destination,

void (*callback)(AsyncOpNode *, MessageQueue *, void *),

Line 851

Line 857

void <font

color=#990000>*callback_ptr);

</pre>

<var>AsyncOpNode *op (In)</var> is the shared data

structure that controls the message flow and

consolidates the response data. This data structure is

also passed to the callback function as the first

parameter. The caller must

allocate and free this data structure.

<var>Uint32 destination (In)</var> is the queue ID of

the service which will receive the asynchronous

request message.</var>

<var>void (*callback)(AsyncOpNode *, MessageQueue *,

void *) (In)</var> is the static class method that

will be called when the request/response pair is complete.

The callback is always passed <var>op</var> as the

first parameter. The second parameter is the

<var>MessageQueue *</var> object instance that is

executing the callback function. Because callback

functions must be static class methods, the callback

can use the <var>MessageQueue *</var> parameter as a

pseudo <var>this</var> pointer.

<var>MessageQueue *callback_q (In)</var> is the

queue pointer that will be passed to the callback

routine as the second parameter. It also controls

which queue instance receives the callback.

<var>void *callback_ptr (In)</var> is a pointer that will

be passed to the callback function.

<h2>Class Definitions</h2>

</div>

</div></div>

<h3>cimom (Meta Dispatcher)</h3>

<pre>

class PEGASUS_COMMON_LINKAGE cimom : public MessageQueue

{

public :

cimom(void);

virtual ~cimom(void) ;

Boolean moduleChange(struct timeval last);

Uint32 getModuleCount(void);

Uint32 getModuleIDs(Uint32 *ids, Uint32 count) throw(IPCException);

AsyncOpNode *get_cached_op(void) throw(IPCException);

void cache_op(AsyncOpNode *op) throw(IPCException);

void set_default_op_timeout(const struct timeval *buffer);

void get_default_op_timeout(struct timeval *timeout) const ;

virtual void handleEnqueue();

<h3>How the Meta Dispatcher Processes Non-Blocking Messages</h3>

void register_module(RegisterCimService *msg);

void deregister_module(Uint32 quid);

The focus of processing non-blocking messages is to

void update_module(UpdateCimService *msg );

remove the possibility of deadlock. Therefore, all

void ioctl(AsyncIoctl *msg );

message processing is performed by background

threads. All access by services to shared data

structures is discrete in the sense that one service

never calls into another service. For example,

callback routines are executed by the background

thread of the receiving service. (As opposed to the

sending service making a callback into the

receiving service.)

void find_service_q(FindServiceQueue *msg );

<ol>

void enumerate_service(EnumerateService *msg );

<li>The requesting service creates a request, an

Boolean route_async(AsyncOpNode *operation);

<code>AsyncOpNode</code> and calls

void _shutdown_routed_queue(void);

<code>MessageQueueService::SendAsync(...)</code>.</li>

<li><code>SendAsync</code> marks the

<code>AsyncOpNode</code> as

<code>ASYNC_OPFLAGS_CALLBACK</code> with the

<code>ASYNC_OPSTATE_COMPLETE</code> bit

clear.</li> <li>The Meta Dispatcher routes

the <code>AsyncOpNode</code> to the responding

service.</li> <li>The responding service's

background thread pulls the message off its

internal queue and processes the request. This

will frequently entail creating and inserting a

response message into the <code>AsyncOpNode</code>

by calling

<code>AsyncOpNode::put_response(AsyncMessage

*)</code>.</li> <li>The responding service

completes the response by calling

<code>MessageQueueService::_complete_op_node(AsyncOpNode

*, Uint32, Uint32, Uint32)</code>.</li>

<li><code>_complete_op_node</code> passes the

operation back to the Meta Dispatcher, which

routes it back to the requesting

service.</li> <li>The requesting service's

background thread pulls the

<code>AsyncOpNode</code> off its internal queue

and calls

<code>AsyncOpNode::_async_callback</code>, which

is a function pointer that holds the address of the

requesting service's static callback method..</li>

<li>The requesting service deallocates the op

node, the request message, and the response message.</li>

</ol>

<h3>Virtual Methods for Non-Blocking Messages</h3>

To use non-blocking messages, a service should

implement the following virtual method from

<code>MessageQueueService</code>, plus a static class

callback function.

<pre>

virtual void _handle_async_request(AsyncRequest *req);

</pre>

<var>AsyncRequest *req (In)</var> is the incoming

request. <code>req->op</code> is the

<code>AsyncOpNode</code> that is controlling this

operation.

This method is called by the service's background

thread whenever an <code>AsyncRequest</code>

message is sent to the service. This includes

both blocking and non-blocking request messages.

Within <code>_handle_async_request</code> you

can determine whether the message is blocking or

non-blocking by using the following code

segment:

protected:

if(req->op->read_flags() & ASYNC_OPFLAGS_CALLBACK )

Uint32 get_module_q(const String & name);

{

void _make_response(AsyncRequest *req, Uint32 code);

void _completeAsyncResponse(AsyncRequest *request,

AsyncReply *reply,

Uint32 state,

Uint32 flag);

private:

struct timeval _default_op_timeout;

struct timeval _last_module_change;

DQueue<message_module> _modules;

DQueue<AsyncOpNode> _recycle;

// let everyone know you are working on the request

req->op->processing();

AsyncDQueue<AsyncOpNode> _routed_ops;

// this request is part of a callback (non-blocking) operation

DQueue<AsyncOpNode> _internal_ops;

AsyncResponse *response = new AsyncResponse(...);

static PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL _routing_proc(void *);

// initialize the response message however is appropriate

Thread _routing_thread;

// put the response to the op node

req->op->put_response(response);

static Uint32 get_xid(void);

// complete the operation

void _handle_cimom_op(AsyncOpNode *op, Thread *thread, MessageQueue *queue);

_complete_op_node(req->op, 0, 0, async_results::OK);

Uint32 _ioctl(Uint32, Uint32, void *);

return;

}

</code></pre>

</div>

AtomicInt _die;

AtomicInt _routed_queue_shutdown;

static AtomicInt _xid;

// CIMOperationRequestDispatcher *_cim_dispatcher;

<pre>

// CIMOperationResponseEncoder *_cim_encoder;

// CIMOperationRequestDecoder *_cim_decoder;

// CIMRepository *_repository;

};

static void async_callback_function(AsyncOpNode *op, MessageQueue *, void *);

</pre>

<var>AsyncOpNode *op (In)</var> is the

incoming shared object that is controlling this

completing operation.

<var>MessageQueue *q (In)</var> is a pointer to

the class that has received the complete

<var>op</var>. This parameter is meant to be used

as a <code>this</code> pointer because the

callback is a static class method.

<var>void *parm (In)</var> is a pointer that the

class passed to <code>SendAsync</code>. It can be

used as a convenience for the class.

This method is only called when a

<h3>MessageQueueService</h3>

non-blocking operation is complete, meaning that

the responding service has added a response

message to the <var>op</var> and set the

<code>ASYNC_OPSTATE_COMPLETE</code> bit.

<pre>

class message_module;

void my_class::async_callback_function(AsyncOpNode *op,

MessageQueue *q,

class PEGASUS_COMMON_LINKAGE MessageQueueService : public MessageQueue

void *parm)

{

public:

typedef MessageQueue Base;

MessageQueueService(const char *name, Uint32 queueID, Uint32 capabilities, Uint32 mask) ;

virtual ~MessageQueueService(void);

virtual void handle_heartbeat_request(AsyncRequest *req);

virtual void handle_heartbeat_reply(AsyncReply *rep);

virtual void handle_AsyncIoctl(AsyncIoctl *req);

virtual void handle_CimServiceStart(CimServiceStart *req);

virtual void handle_CimServiceStop(CimServiceStop *req);

virtual void handle_CimServicePause(CimServicePause *req);

virtual void handle_CimServiceResume(CimServiceResume *req);

virtual void handle_AsyncOperationStart(AsyncOperationStart *req);

virtual void handle_AsyncOperationResult(AsyncOperationResult *req);

virtual Boolean accept_async(AsyncOpNode *op);

virtual Boolean messageOK(const Message *msg) ;

AsyncReply *SendWait(AsyncRequest *request);

void _completeAsyncResponse(AsyncRequest *request,

AsyncReply *reply,

Uint32 state,

Uint32 flag);

Boolean register_service(String name, Uint32 capabilities, Uint32 mask);

Boolean update_service(Uint32 capabilities, Uint32 mask);

Boolean deregister_service(void);

virtual void _shutdown_incoming_queue(void);

void find_services(String name,

Uint32 capabilities,

Uint32 mask,

Array<Uint32> *results);

void enumerate_service(Uint32 queue, message_module *result);

Uint32 get_next_xid(void);

AsyncOpNode *get_op(void);

void return_op(AsyncOpNode *op);

Uint32 _capabilities;

Uint32 _mask;

AtomicInt _die;

protected:

virtual void _handle_incoming_operation(AsyncOpNode *operation, Thread *thread, MessageQueue *queue);

virtual void _handle_async_request(AsyncRequest *req);

virtual void _make_response(AsyncRequest *req, Uint32 code);

cimom *_meta_dispatcher;

private:

void handleEnqueue();

DQueue<AsyncOpNode> _pending;

AsyncDQueue<AsyncOpNode> _incoming;

static PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL _req_proc(void *);

AtomicInt _incoming_queue_shutdown;

Thread _req_thread;

struct timeval _default_op_timeout;

static AtomicInt _xid;

my_class *myself = static_cast<my_class *>(q);

AsyncRequest *request = op->get_request();

AsyncResponse *response = op->get_response();

};

// process response

delete request;

delete response;

myself->put_op(op);

return;

}

</pre>

</div>

<h3>Strategies for Handling Non-Blocking Responses</h3>

All of the legacy message handling code in Pegasus is

syncrhonous, meaning that a service can send a request

and receive the response in two adjacent lines of

code. Non-blocking messages are different because the

timing and existence of a response message is

undetermined.

There are couple of possible strategies for handing

non-blocking response messages.

<h3>Asynchronous Messages</h3>

<ol>

<li>Seperate the request creation and sending code

from the response handling code into distinct methods.</li>

<li>Handle request creation and sending and response

handling in the same method using different code blocks.

</ol>

<h4>Separate Request and Response Handling Methods</h4>

<ol>

<li>Write the request generation method.

<pre>

extern const Uint32 CIMOM_Q_ID;

void my_class::generate_request(Uint32 destination)

class AsyncOpNode;

class PEGASUS_COMMON_LINKAGE async_results

{

public:

AsyncOpNode *op = get_op();

static const Uint32 OK;

my_request *req = new my_request(...);

static const Uint32 PARAMETER_ERROR;

op->put_request(req);

static const Uint32 MODULE_ALREADY_REGISTERED;

static const Uint32 MODULE_NOT_FOUND;

static const Uint32 INTERNAL_ERROR;

static const Uint32 ASYNC_STARTED;

static const Uint32 ASYNC_PROCESSING;

static const Uint32 ASYNC_COMPLETE;

static const Uint32 ASYNC_CANCELLED;

static const Uint32 ASYNC_PAUSED;

static const Uint32 ASYNC_RESUMED;

static const Uint32 CIM_SERVICE_STARTED;

static const Uint32 CIM_SERVICE_STOPPED;

static const Uint32 CIM_SERVICE_PAUSED;

static const Uint32 CIM_SERVICE_RESUMED;

static const Uint32 CIM_NAK;

static const Uint32 ASYNC_PHASE_COMPLETE;

static const Uint32 ASYNC_CHILD_COMPLETE;

static const Uint32 ASYNC_PHASE_STARTED;

static const Uint32 ASYNC_CHILD_STARTED;

static const Uint32 CIM_PAUSED;

static const Uint32 CIM_STOPPED;

};

SendAsync(op, destination, my_callback, this, (void *)0);

return;

}

</pre>

</li>

<li> Write the request handling method.

<pre>

class PEGASUS_COMMON_LINKAGE async_messages

void my_class::handle_response(AsyncOpNode *op)

{

public:

my_response *res = op->get_response();

static const Uint32 HEARTBEAT;

if(res != 0 )

static const Uint32 REPLY;

static const Uint32 REGISTER_CIM_SERVICE;

static const Uint32 DEREGISTER_CIM_SERVICE;

static const Uint32 UPDATE_CIM_SERVICE;

static const Uint32 IOCTL;

static const Uint32 CIMSERVICE_START;

static const Uint32 CIMSERVICE_STOP;

static const Uint32 CIMSERVICE_PAUSE;

static const Uint32 CIMSERVICE_RESUME;

static const Uint32 ASYNC_OP_START;

static const Uint32 ASYNC_OP_RESULT;

static const Uint32 ASYNC_LEGACY_OP_START;

static const Uint32 ASYNC_LEGACY_OP_RESULT;

static const Uint32 FIND_SERVICE_Q;

static const Uint32 FIND_SERVICE_Q_RESULT;

static const Uint32 ENUMERATE_SERVICE;

static const Uint32 ENUMERATE_SERVICE_RESULT;

};

class PEGASUS_COMMON_LINKAGE AsyncMessage : public Message

{

public:

// handle response

AsyncMessage(Uint32 type,

delete response;

Uint32 key,

}

Uint32 routing,

put_op(op);

Uint32 mask,

return;

AsyncOpNode *operation);

}

</pre>

</li>

<li> Have your callback method call your response

method.

<pre>

virtual ~AsyncMessage(void)

void my_class:my_callback(AsyncOpNode *op, MessageQueue *queue, void *parm)

{

my_class *myself = static_cast<queue>

myself->handle_response(op);

return;

}

</pre>

</li>

</ol>

</div>

Boolean operator ==(void *key);

Boolean operator ==(const AsyncMessage& msg);

AsyncOpNode *op;

Thread *_myself;

MessageQueue *_service;

};

<h4>Singe Request and Response Handling Method</h4>

This strategy requires two separate code blocks within

the request/response method, and conditional execution

depending on the status of the operation.

I think the advantage of this strategy is that it

matches more closely the current

<code>handleEnqueue(Message *msg)</code> code

convention that is in Pegasus.

inline Boolean AsyncMessage::operator ==(void *key)

{

if( key == reinterpret_cast<void *>(this))

<ol>

return true;

<li>Write the request generation block.

return false;

<pre>

}

inline Boolean AsyncMessage::operator ==(const AsyncMessage& msg)

void my_class::handle_operation(AsyncOpNode *op)

{

return this->operator==(reinterpret_cast<void *>(const_cast<AsyncMessage *>(&msg)));

if(op == NULL)

}

class PEGASUS_COMMON_LINKAGE AsyncRequest : public AsyncMessage

{

public:

AsyncOpNode *op = get_op();

AsyncRequest(Uint32 type,

my_request *req = new my_request(...);

Uint32 key,

op->put_request(req);

Uint32 routing,

Uint32 mask,

AsyncOpNode *operation,

Uint32 destination,

Uint32 response,

Boolean blocking);

SendAsync(op, destination, my_callback, this, (void *)0);

virtual ~AsyncRequest(void)

}

else

{

}

return;

}

</pre>

</li>

<li> Write the request handling block.

<pre>

Uint32 dest;

void my_class::handle_operation(AsyncOpNode *op)

Uint32 resp;

Boolean block;

};

class PEGASUS_COMMON_LINKAGE AsyncReply : public AsyncMessage

{

public:

if(op == NULL)

AsyncReply(Uint32 type,

{

Uint32 key,

AsyncOpNode *op = get_op();

Uint32 routing,

my_request *req = new my_request(...);

Uint32 mask,

op->put_request(req);

AsyncOpNode *operation,

Uint32 result_code,

Uint32 destination,

Boolean blocking);

SendAsync(op, destination, my_callback, this, (void *)0);

virtual ~AsyncReply(void)

}

else

{

if(op != 0 )

my_response *res = op->get_response();

delete op;

if(res != 0 )

{

// handle response

delete response;

}

put_op(op);

}

return;

}

Uint32 result;

</pre>

Uint32 dest;

</li>

Boolean block;

<li> Have your callback method call your handler

};

method.

<pre>

class PEGASUS_COMMON_LINKAGE RegisterCimService : public AsyncRequest

{

public:

RegisterCimService(Uint32 routing,

AsyncOpNode *operation,

Boolean blocking,

String service_name,

Uint32 service_capabilities,

Uint32 service_mask,

Uint32 service_queue);

virtual ~RegisterCimService(void)

void my_class:my_callback(AsyncOpNode *op, MessageQueue *queue, void *parm)

{

my_class *myself = static_cast<queue>

myself->handle_operation(op);

return;

}

</pre>

</li>

</ol>

</div>

String name;

Uint32 capabilities;

Uint32 mask;

Uint32 queue;

};

class PEGASUS_COMMON_LINKAGE DeRegisterCimService : public AsyncRequest

<h2>Class Definitions</h2>

{

public:

DeRegisterCimService(Uint32 routing,

AsyncOpNode *operation,

Boolean blocking,

Uint32 service_queue);

<h3>cimom (Meta Dispatcher)</h3>

virtual ~DeRegisterCimService(void)

<pre>

{

<tt>

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

//

// The Open Group, Tivoli Systems

//

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

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

// deal in the Software without restriction, including without limitation the

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// sell copies of the Software, and to permit persons to whom the Software is

// furnished to do so, subject to the following conditions:

//

// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED

// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR

// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

//

//==============================================================================

//

// Author: Mike Day (mdday@us.ibm.com

//

// Modified By:

//

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

#ifndef CIMOM_include

#define CIMOM_include

#include <Pegasus/Common/Config.h>

#include <Pegasus/Common/Exception.h>

#include <Pegasus/Common/MessageQueue.h>

#include <Pegasus/Common/DQueue.h>

#include <Pegasus/Common/Thread.h>

#include <Pegasus/Common/Array.h>

#include <Pegasus/Common/AsyncOpNode.h>

#include <Pegasus/Common/CimomMessage.h>

#include <Pegasus/Common/MessageQueueService.h>

PEGASUS_NAMESPACE_BEGIN

extern const Uint32 CIMOM_Q_ID;

class PEGASUS_COMMON_LINKAGE module_capabilities

{

public:

static Uint32 async;

static Uint32 remote;

static Uint32 trusted;

static Uint32 paused;

static Uint32 stopped;

} ;

class PEGASUS_COMMON_LINKAGE cimom;

class PEGASUS_COMMON_LINKAGE message_module

{

public:

message_module(void)

: _name(), _capabilities(0),

_mask(0), _q_id(0) { }

message_module(const String & name,

Uint32 capabilities,

Uint32 mask,

Uint32 queue)

: _name(name), _capabilities(capabilities),

_mask(mask), _q_id(queue) { }

Boolean operator == (const message_module *mm) const;

Boolean operator == (const String & name ) const ;

Boolean operator == (const message_module & mm ) const ;

Boolean operator == (const void *) const;

Boolean operator == (Uint32) const;

const String & get_name(void) const ;

Uint32 get_capabilities(void) const ;

Uint32 get_mask(void) const ;

Uint32 get_queue(void) const ;

void put_name(String & name);

void put_capabilities(Uint32 capabilities);

void put_mask(Uint32 mask);

void put_queue(Uint32 queue) ;

private:

String _name;

Uint32 _capabilities;

Uint32 _mask;

struct timeval _heartbeat;

Uint32 _q_id;

friend class cimom;

};

class MessageQueueService;

class PEGASUS_COMMON_LINKAGE cimom : public MessageQueue

{

public :

cimom(void);

virtual ~cimom(void) ;

Boolean moduleChange(struct timeval last);

Uint32 getModuleCount(void);

Uint32 getModuleIDs(Uint32 *ids, Uint32 count) throw(IPCException);

AsyncOpNode *get_cached_op(void) throw(IPCException);

void cache_op(AsyncOpNode *op) throw(IPCException);

void set_default_op_timeout(const struct timeval *buffer);

void get_default_op_timeout(struct timeval *timeout) const ;

void register_module(RegisterCimService *msg);

void deregister_module(Uint32 quid);

void update_module(UpdateCimService *msg );

void ioctl(AsyncIoctl *msg );

void find_service_q(FindServiceQueue *msg );

void enumerate_service(EnumerateService *msg );

Boolean route_async(AsyncOpNode *operation);

void _shutdown_routed_queue(void);

protected:

Uint32 get_module_q(const String & name);

static void _make_response(Message *req, Uint32 code);

static void _completeAsyncResponse(AsyncRequest *request,

AsyncReply *reply,

Uint32 state,

Uint32 flag);

static void _complete_op_node(AsyncOpNode *op, Uint32 state, Uint32 flag, Uint32 code);

static void _default_callback(AsyncOpNode *, MessageQueue *, void *);

private:

struct timeval _default_op_timeout;

struct timeval _last_module_change;

DQueue<message_module> _modules;

DQueue<AsyncOpNode> _recycle;

AsyncDQueue<AsyncOpNode> _routed_ops;

DQueue<AsyncOpNode> _internal_ops;

static PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL _routing_proc(void *);

Thread _routing_thread;

static Uint32 get_xid(void);

void _handle_cimom_op(AsyncOpNode *op, Thread *thread, MessageQueue *queue);

Uint32 _ioctl(Uint32, Uint32, void *);

AtomicInt _die;

AtomicInt _routed_queue_shutdown;

static AtomicInt _xid;

static cimom *_global_this;

}

friend class MessageQueueService;

Uint32 queue;

};

} ;

class PEGASUS_COMMON_LINKAGE UpdateCimService : public AsyncRequest

PEGASUS_NAMESPACE_END

{

public:

UpdateCimService(Uint32 routing,

AsyncOpNode *operation,

Boolean blocking,

Uint32 service_queue,

Uint32 service_capabilities,

Uint32 service_mask);

virtual ~UpdateCimService(void)

#endif // CIMOM_include

{

</tt>

</pre>

}

<h3>MessageQueueService</h3>

Uint32 queue;

<pre>

Uint32 capabilities;

<tt>

Uint32 mask;

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