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.50.12.5 and 1.62

version 1.50.12.5, 2006/06/30 22:37:52

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

Line 29

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

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

// Modified By: David Dillard, VERITAS Software Corp.

// (david.dillard@veritas.com)

// Jim Wunderlich (Jim_Wunderlich@prodigy.net)

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

#ifndef Pegasus_MessageQueue_Service_h

Line 43

Line 37

#include <Pegasus/Common/Config.h>

#include <Pegasus/Common/Message.h>

#include <Pegasus/Common/InternalException.h>

#include <Pegasus/Common/IPC.h>

#include <Pegasus/Common/Thread.h>

#include <Pegasus/Common/ThreadPool.h>

#include <Pegasus/Common/AsyncOpNode.h>

#include <Pegasus/Common/Cimom.h>

#include <Pegasus/Common/Mutex.h>

#include <Pegasus/Common/CimomMessage.h>

#include <Pegasus/Common/Linkage.h>

#include <Pegasus/Common/RecursiveMutex.h>

#include <Pegasus/Common/Mutex.h>

#include <Pegasus/Common/IDFactory.h>

PEGASUS_NAMESPACE_BEGIN

extern const Uint32 CIMOM_Q_ID;

class message_module;

class cimom;

class PEGASUS_COMMON_LINKAGE MessageQueueService :

Line 67

Line 61

typedef MessageQueue Base;

MessageQueueService(const char *name,

MessageQueueService(

const char* name,

Uint32 queueID = MessageQueue::getNextQueueId(),

Uint32 capabilities = 0,

Uint32 mask = message_mask::type_cimom |

Uint32 mask = MessageMask::ha_request |

message_mask::type_service |

MessageMask::ha_reply |

message_mask::ha_request |

MessageMask::ha_async);

message_mask::ha_reply |

message_mask::ha_async );

virtual ~MessageQueueService();

Line 97

Line 90

void *parameter);

Boolean SendForget(Message *msg);

Boolean ForwardOp(AsyncOpNode *, Uint32 destination);

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

Boolean update_service(Uint32 capabilities, Uint32 mask);

Boolean deregister_service();

virtual void _shutdown_incoming_queue();

void find_services(String name,

void find_services(

String name,

Uint32 capabilities,

Uint32 mask,

Array<Uint32> *results);

void enumerate_service(Uint32 queue, message_module *result);

Uint32 get_next_xid();

static AsyncOpNode *get_op();

void return_op(AsyncOpNode *op);

Boolean operator ==(const MessageQueueService & svce) const

{

return operator==((const void *)&svce);

}

Boolean operator ==(const void *svce) const

{

if((const void *)this == svce)

return true;

return false;

}

static PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL polling_routine(void *);

static PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL kill_idle_threads(void *);

static ThreadPool *get_thread_pool();

Uint32 _mask;

Line 136

Line 113

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* operation,

// Thread* thread,

// MessageQueue* queue);

virtual void _handle_incoming_operation(AsyncOpNode *);

virtual void _handle_async_request(AsyncRequest *req);

Line 159

Line 140

virtual void handle_AsyncOperationStart(AsyncOperationStart *req);

virtual void handle_AsyncOperationResult(AsyncOperationResult *rep);

virtual void handle_AsyncLegacyOperationStart(AsyncLegacyOperationStart *req);

virtual void handle_AsyncLegacyOperationResult(AsyncLegacyOperationResult *rep);

void _completeAsyncResponse(AsyncRequest *request,

void _completeAsyncResponse(

AsyncRequest* request,

AsyncReply *reply,

Uint32 state,

Uint32 flag);

Line 171

Line 151

static cimom *_meta_dispatcher;

static AtomicInt _service_count;

static Mutex _meta_dispatcher_mutex;

static ThreadPool* _thread_pool;

private:

static ThreadReturnType PEGASUS_THREAD_CDECL polling_routine(void *);

AsyncQueue<AsyncOpNode> _incoming;

static Thread* _polling_thread;

static Semaphore _polling_sem;

static AtomicInt _stop_polling;

static AtomicInt _check_idle_flag;

typedef List<MessageQueueService, RecursiveMutex> PollingList;

typedef List<MessageQueueService, Mutex> PollingList;

static PollingList* _polling_list;

static Mutex _polling_list_mutex;

PollingList* _get_polling_list();

static PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL _req_proc(void *);

static ThreadReturnType PEGASUS_THREAD_CDECL _req_proc(void *);

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

AtomicInt _incoming_queue_shutdown;

protected:

static ThreadPool *_thread_pool;

private:

struct timeval _default_op_timeout;

static IDFactory _xidFactory;

friend class cimom;

friend class CIMServer;

};

PEGASUS_NAMESPACE_END

Legend:

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

No CVS admin address has been configured