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.39.6.1 and 1.50.12.4

version 1.39.6.1, 2003/10/29 22:10:02

version 1.50.12.4, 2006/06/30 20:25:43

Line 1

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

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

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

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

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

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

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

Line 25

Line 31

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

// Modified By:

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

// (david.dillard@veritas.com)

// Jim Wunderlich (Jim_Wunderlich@prodigy.net)

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

Line 39

Line 47

#include <Pegasus/Common/Thread.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>

PEGASUS_NAMESPACE_BEGIN

Line 48

Line 58

class message_module;

class PEGASUS_COMMON_LINKAGE MessageQueueService : public MessageQueue

class PEGASUS_COMMON_LINKAGE MessageQueueService :

public Linkable, public MessageQueue

{

public:

Line 61

Line 73

message_mask::type_service |

message_mask::ha_request |

message_mask::ha_reply |

message_mask::ha_async,

message_mask::ha_async );

int threads=0) ;

virtual ~MessageQueueService(void);

virtual ~MessageQueueService();

virtual Boolean isAsync(void) { return true; }

virtual Boolean isAsync() const { return true; }

virtual void enqueue(Message *) throw(IPCException);

// enqueue may throw an IPCException

virtual void enqueue(Message *);

AsyncReply *SendWait(AsyncRequest *request);

Boolean SendAsync(AsyncOpNode *op,

Line 83

Line 95

void *handle,

void *parameter);

Uint32 get_pending_callback_count(void);

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(void);

Boolean deregister_service();

virtual void _shutdown_incoming_queue(void);

virtual void _shutdown_incoming_queue();

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

Uint32 get_next_xid();

static AsyncOpNode *get_op(void);

static AsyncOpNode *get_op();

void return_op(AsyncOpNode *op);

Boolean operator ==(const MessageQueueService & svce)

Boolean operator ==(const MessageQueueService & svce) const

{

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

}

Boolean operator ==(const void *svce)

Boolean operator ==(const void *svce) const

{

if((void *)this == svce)

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 int pooled_threads(void)

static ThreadPool *get_thread_pool();

{

return _thread_pool->running_count() + _thread_pool->dead_count() + _thread_pool->pool_count();

}

static ThreadPool *get_thread_pool(void);

static void force_shutdown(Boolean destroy_flag = false);

Uint32 _mask;

AtomicInt _die;

AtomicInt _threads;

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

protected:

virtual Boolean accept_async(AsyncOpNode *op);

virtual Boolean messageOK(const Message *msg) ;

virtual void handleEnqueue(void) = 0;

virtual void handleEnqueue() = 0;

virtual void handleEnqueue(Message *) = 0;

Boolean _enqueueResponse(Message *, Message *);

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

Line 138

Line 147

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_heartbeat_reply(AsyncReply *rep);

Line 159

Line 167

Uint32 flag);

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

static cimom *_meta_dispatcher;

static AtomicInt _service_count;

static Mutex _meta_dispatcher_mutex;

private:

AsyncQueue<AsyncOpNode> _incoming;

AsyncDQueue<AsyncOpNode> _incoming;

DQueue<AsyncOpNode> _callback;

static Thread* _polling_thread;

static Semaphore _polling_sem;

static AtomicInt _stop_polling;

static AtomicInt _check_idle_flag;

static DQueue<MessageQueueService> _polling_list;

typedef List<MessageQueueService, RecursiveMutex> 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 PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL _callback_proc(void *);

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

AtomicInt _incoming_queue_shutdown;

Semaphore _callback_ready;

Thread _req_thread;

Thread _callback_thread;

protected:

static ThreadPool *_thread_pool;

private:

struct timeval _default_op_timeout;

static AtomicInt _xid;

static Mutex _xidMutex;

static Uint32 _xid;

friend class cimom;

friend class CIMServer;

friend class monitor_2;

};

PEGASUS_NAMESPACE_END

#endif /* Pegasus_MessageQueue_Service_h */

Legend:

Removed from v.1.39.6.1
changed lines
	Added in v.1.50.12.4

No CVS admin address has been configured