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.4 and 1.5

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

version 1.5, 2005/05/12 13:40:18

Line 206

hub. Services communicate with each other via the Meta

Dispatcher.

<pre>

<pre> Service A--Message----1----> (block on semaphore)

Service A--Message----1----> (block on semaphore)

Meta Dispatcher|

Line 271

Line 270

<ol>

<li>Define the Service Class</li>

<pre>

<pre>// Define our service class

// Define our service class

class MessageQueueClient : public MessageQueueService

{

Line 317

Line 315

</pre>

<li>Construct the Service</li>

<pre>

<pre>// Create our Service

// Create our Service

MessageQueueClient *q_client =

new MessageQueueClient("test client");

</pre>

<li>Register the Service</li>

<pre>

<pre>// Register our service with the Meta Dispatcher

// Register our service with the Meta Dispatcher

q_client->register_service("test client",

q_client->_client_capabilities,

q_client->_client_mask);

Line 349

Line 345

program:

<pre>

Array<Uint32>; services;

while( services.size() == 0 )

Line 380

Line 375

<ol>

<li>Define the Request and Response Message Pair by Inheriting from AsyncMessage.</li>

<pre>

class test_request : public AsyncRequest

{

Line 455

Line 449

process the reply.

<pre>

void MessageQueueClient::send_test_request(char *greeting, Uint32 qid)

{

</pre>

<li>Construct the Request</li>

<pre>

<pre> test_request *req =

test_request *req =

new test_request(Base::get_next_xid(),

qid, // destination queue ID

Line 474

Line 466

<li>Send the message using <code>MessageQueueService::SendWait</code></li>

<pre>

<pre> AsyncMessage *response = SendWait(req);

AsyncMessage *response = SendWait(req);

</pre>

<li>Process the Response.

<pre>

<pre> if( response != 0 )

if( response != 0 )

{

msg_count++;

delete response;

Line 517

Line 507

before inserting the request on the Service's queue.

<pre>

Boolean MessageQueueServer::messageOK(const Message *msg)

{

if(msg->getMask() & message_mask::ha_async)

Line 550

Line 539

the message.

<pre>

void MessageQueueServer::_handle_incoming_operation(AsyncOpNode *op)

{

if ( operation != 0 )

Line 576

Line 564

this method. If the Service does not handle the Request it

must pass the Request to the Base class by calling <code>Base::_handle_async_request(req)</code>

<pre>

<pre>void MessageQueueServer::_handle_async_request(AsyncRequest *req)

void MessageQueueServer::_handle_async_request(AsyncRequest *req)

{

if (req->getType() == 0x04100000 )

{

Line 603

Line 590

program.

<pre>

if( msg->getType() == 0x04100000 )

{

Line 611

Line 597

<ol>

<li>Construct the Reply</li>

<pre>

test_response *resp =

new test_response(msg->getKey(),

msg->getRouting(),

Line 625

Line 610

<li>Complete the Reply by calling the following

helper routine in the Base class</li>

<pre>

<pre> _completeAsyncResponse(msg, resp, ASYNC_OPSTATE_COMPLETE, 0);

_completeAsyncResponse(msg, resp, ASYNC_OPSTATE_COMPLETE, 0);

}

</pre>

Line 663

Line 647

<pre>

cout << " sending LEGACY to test server" << endl;

Message *legacy = new Message(0x11100011,

Line 697

Line 680

<pre>

void MessageQueueService::handle_AsyncLegacyOperationStart(

AsyncLegacyOperationStart *req)

{

Line 738

Line 720

<li>Implement the virtual <code>_handle_async_request</code> method.</li>

<pre>

void MessageQueueServer::_handle_async_request(AsyncRequest *req)

{

if (req->getType() == 0x04100000 )

Line 753

Line 734

}

</pre>

<li>Implement a dispatcher for <code>ASYNC_LEGACY_OP_START</code></li>

<pre>

<pre> else if ( req->getType() == async_messages::ASYNC_LEGACY_OP_START )

else if ( req->getType() == async_messages::ASYNC_LEGACY_OP_START )

{

req->op->processing();

handle_LegacyOpStart(static_cast<AsyncLegacyOperationStart *>(req));

Line 767

Line 747

</pre>

<li>Implement a dispatcher for <code>ASYNC_LEGACY_OP_START</code></li>

<pre>

void MessageQueueServer::handle_LegacyOpStart(AsyncLegacyOperationStart *req)

{

Line 812

Line 791

<pre>

<pre> Service A--Message----1---->

Service A--Message----1---->

. <-----------(return)-+----->-(loop)--->-+

. | Meta Dispatcher |

Line 849

Line 827

<pre>

Boolean SendAsync(AsyncOpNode *op,

Uint32 destination,

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

Line 953

Line 930

callback function.

<pre>

<pre>virtual void _handle_async_request(AsyncRequest *req);

virtual void _handle_async_request(AsyncRequest *req);

</pre>

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

Line 1002

Line 978

<pre>

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

</pre>

Line 1029

Line 1004

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

<code>ASYNC_OPSTATE_COMPLETE</code> bit.

<pre>

void my_class::async_callback_function(AsyncOpNode *op,

MessageQueue *q,

void *parm)

Line 1053

Line 1027

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

All of the legacy message handling code in Pegasus is

All of the legacy message handling code in Pegasus is syncrhonous, meaning that a service can send a request

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.

undetermined.

There are couple of possible strategies for handing

non-blocking response messages.

non-blocking response messages. <ol>

<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

Line 1078

Line 1048

<ol>

<li>Write the request generation method.

<pre>

void my_class::generate_request(Uint32 destination)

{

AsyncOpNode *op = get_op();

Line 1092

Line 1061

</li>

<li> Write the request handling method.

<pre>

void my_class::handle_response(AsyncOpNode *op)

{

my_response *res = op->get_response();

Line 1109

Line 1077

<li> Have your callback method call your response

method.

<pre>

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

{

my_class *myself = static_cast<queue>

Line 1128

Line 1095

This strategy requires two separate code blocks within

the request/response method, and conditional execution

depending on the status of the operation.

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.

convention that is in Pegasus.

<ol>

<li>Write the request generation block.

<pre>

void my_class::handle_operation(AsyncOpNode *op)

{

if(op == NULL)

Line 1164

Line 1128

</li>

<li> Write the request handling block.

<pre>

void my_class::handle_operation(AsyncOpNode *op)

{

if(op == NULL)

Line 1194

Line 1157

<li> Have your callback method call your handler

method.

<pre>

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

{

my_class *myself = static_cast<queue>

Line 1214

Line 1176

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

<pre>

<tt>

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

//

Line 1395

Line 1356

<h3>MessageQueueService</h3>

<pre>

<tt>

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

//

Line 1550

Line 1510

<h3>Asynchronous Messages</h3>

<pre>

<tt>

//%2005////////////////////////////////////////////////////////////////////////

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

//

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

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

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

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

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

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

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

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

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

//

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Line 2082

Line 2047

<h3>AsyncOpNode</h3>

<pre>

<tt>

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

//

Line 2598

Line 2562

Last modified: Wed Mar 13 12:26:56 EST 2002

</body>

</body></html>

</html>

Legend:

Removed from v.1.4
changed lines
	Added in v.1.5

No CVS admin address has been configured