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

Return to MessageQueueService.h CVS log

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

Diff for /pegasus/src/Pegasus/Common/MessageQueueService.h between version 1.62 and 1.78

version 1.62, 2008/09/17 05:57:06

version 1.78, 2009/04/09 05:23:26

Line 1

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

//%LICENSE////////////////////////////////////////////////////////////////

// Licensed to The Open Group (TOG) under one or more contributor license

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

// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with

// this work for additional information regarding copyright ownership.

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

// Each contributor licenses this file to you under the OpenPegasus Open

// Source License; you may not use this file except in compliance with the

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

// License.

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

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

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

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

//////////////////////////////////////////////////////////////////////////

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

Line 48

Line 46

PEGASUS_NAMESPACE_BEGIN

extern const Uint32 CIMOM_Q_ID;

class message_module;

class cimom;

Line 62

Line 58

typedef MessageQueue Base;

MessageQueueService(

const char* name,

const char* name);

Uint32 queueID = MessageQueue::getNextQueueId(),

Uint32 capabilities = 0,

Uint32 mask = MessageMask::ha_request |

MessageMask::ha_reply |

MessageMask::ha_async);

virtual ~MessageQueueService();

virtual Boolean isAsync() const { return true; }

// enqueue may throw an IPCException

virtual void enqueue(Message *);

AsyncReply* SendWait(AsyncRequest* request);

Line 83

Line 73

MessageQueue* callback_q,

void* callback_ptr);

Boolean SendAsync(Message *msg,

Uint32 destination,

void (*callback)(Message* response, void* handle, void* parameter),

void* handle,

void* parameter);

Boolean SendForget(Message* msg);

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

Boolean update_service(Uint32 capabilities, Uint32 mask);

Boolean deregister_service();

void find_services(

Uint32 find_service_qid(const char* name);

String name,

Uint32 capabilities,

Uint32 mask,

Array<Uint32>* results);

void enumerate_service(Uint32 queue, message_module* result);

static AsyncOpNode* get_op();

void return_op(AsyncOpNode* op);

static ThreadPool* get_thread_pool();

Uint32 _mask;

AtomicInt _die;

AtomicInt _threads;

Uint32 getIncomingCount() {return _incoming.count(); }

protected:

virtual void _shutdown_incoming_queue();

virtual Boolean accept_async(AsyncOpNode* op);

virtual Boolean messageOK(const Message* msg);

virtual void handleEnqueue() = 0;

virtual void handleEnqueue(Message *) = 0;

Boolean _enqueueResponse(Message *, Message *);

// virtual void _handle_incoming_operation(

// AsyncOpNode* operation,

// Thread* thread,

// MessageQueue* queue);

virtual void _handle_incoming_operation(AsyncOpNode *);

virtual void _handle_async_request(AsyncRequest* req);

virtual void _handle_async_callback(AsyncOpNode* operation);

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

virtual void handle_heartbeat_request(AsyncRequest* req);

virtual void handle_AsyncIoClose(AsyncIoClose* 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* rep);

void _completeAsyncResponse(

AsyncRequest* request,

AsyncReply* reply,

AsyncReply* reply);

Uint32 state,

void _complete_op_node(AsyncOpNode *);

Uint32 flag);

void _complete_op_node(AsyncOpNode *, Uint32, Uint32, Uint32);

static cimom* _meta_dispatcher;

static AtomicInt _service_count;

static Mutex _meta_dispatcher_mutex;

static ThreadPool* _thread_pool;

Boolean _isRunning;

private:

Boolean _sendAsync(AsyncOpNode* op,

Uint32 destination,

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

MessageQueue* callback_q,

void* callback_ptr,

Uint32 flags);

void _removeFromPollingList(MessageQueueService *service);

static ThreadReturnType PEGASUS_THREAD_CDECL polling_routine(void *);

AsyncQueue<AsyncOpNode> _incoming;

Line 161

Line 130

static Semaphore _polling_sem;

static AtomicInt _stop_polling;

typedef List<MessageQueueService, Mutex> PollingList;

typedef List<MessageQueueService, NullLock> PollingList;

static PollingList* _polling_list;

static Mutex _polling_list_mutex;

PollingList* _get_polling_list();

static ThreadReturnType PEGASUS_THREAD_CDECL _req_proc(void *);

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

AtomicInt _incoming_queue_shutdown;

struct timeval _default_op_timeout;

friend class cimom;

};

Legend:

Removed from v.1.62
changed lines
	Added in v.1.78

No CVS admin address has been configured