(file) Return to MessageQueueService.h CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/MessageQueueService.h between version 1.18 and 1.36

version 1.18, 2002/03/07 01:17:56 version 1.36, 2003/04/07 20:29:23
Line 1 
Line 1 
 //%////-*-c++-*-//////////////////////////////////////////////////////////////// //%////-*-c++-*-////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,
   // The Open Group, Tivoli Systems
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 31 
Line 32 
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <Pegasus/Common/Message.h> #include <Pegasus/Common/Message.h>
 #include <Pegasus/Common/Exception.h>  #include <Pegasus/Common/InternalException.h>
 #include <Pegasus/Common/IPC.h> #include <Pegasus/Common/IPC.h>
 #include <Pegasus/Common/Thread.h> #include <Pegasus/Common/Thread.h>
 #include <Pegasus/Common/AsyncOpNode.h> #include <Pegasus/Common/AsyncOpNode.h>
 #include <Pegasus/Common/Cimom.h> #include <Pegasus/Common/Cimom.h>
 #include <Pegasus/Common/CimomMessage.h> #include <Pegasus/Common/CimomMessage.h>
   #include <Pegasus/Common/Linkage.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 50 
Line 52 
  
       typedef MessageQueue Base;       typedef MessageQueue Base;
  
       MessageQueueService(const char *name, Uint32 queueID,        MessageQueueService(const char *name,
                             Uint32 queueID = MessageQueue::getNextQueueId(),
                           Uint32 capabilities = 0,                           Uint32 capabilities = 0,
                           Uint32 mask = message_mask::type_cimom |                           Uint32 mask = message_mask::type_cimom |
                           message_mask::type_service |                           message_mask::type_service |
Line 60 
Line 63 
  
       virtual ~MessageQueueService(void);       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 *rep);  
       virtual void handle_AsyncLegacyOperationStart(AsyncLegacyOperationStart *req);  
       virtual void handle_AsyncLegacyOperationResult(AsyncLegacyOperationResult *rep);  
   
       virtual Boolean isAsync(void) {  return true;  }       virtual Boolean isAsync(void) {  return true;  }
  
       virtual Boolean accept_async(AsyncOpNode *op);  
       virtual Boolean messageOK(const Message *msg) ;  
   
       virtual void enqueue(Message *) throw(IPCException);       virtual void enqueue(Message *) throw(IPCException);
  
       AsyncReply *SendWait(AsyncRequest *request);       AsyncReply *SendWait(AsyncRequest *request);
Line 87 
Line 73 
                         void (*callback)(AsyncOpNode *, MessageQueue *, void *),                         void (*callback)(AsyncOpNode *, MessageQueue *, void *),
                         MessageQueue *callback_q,                         MessageQueue *callback_q,
                         void *callback_ptr);                         void *callback_ptr);
   
         Boolean SendAsync(Message *msg,
                           Uint32 destination,
                           void (*callback)(Message *response, void *handle, void *parameter),
                           void *handle,
                           void *parameter);
   
         Uint32 get_pending_callback_count(void);
   
       Boolean  SendForget(Message *msg);       Boolean  SendForget(Message *msg);
       Boolean ForwardOp(AsyncOpNode *, Uint32 destination);       Boolean ForwardOp(AsyncOpNode *, Uint32 destination);
  
       void _completeAsyncResponse(AsyncRequest *request,  
                                  AsyncReply *reply,  
                                  Uint32 state,  
                                  Uint32 flag);  
       Boolean register_service(String name, Uint32 capabilities, Uint32 mask);       Boolean register_service(String name, Uint32 capabilities, Uint32 mask);
       Boolean update_service(Uint32 capabilities, Uint32 mask);       Boolean update_service(Uint32 capabilities, Uint32 mask);
       Boolean deregister_service(void);       Boolean deregister_service(void);
       virtual void _shutdown_incoming_queue(void);       virtual void _shutdown_incoming_queue(void);
   
       void find_services(String name,       void find_services(String name,
                          Uint32 capabilities,                          Uint32 capabilities,
                          Uint32 mask,                          Uint32 mask,
                          Array<Uint32> *results);                          Array<Uint32> *results);
       void enumerate_service(Uint32 queue, message_module *result);       void enumerate_service(Uint32 queue, message_module *result);
       Uint32 get_next_xid(void);       Uint32 get_next_xid(void);
       AsyncOpNode *get_op(void);        static AsyncOpNode *get_op(void);
       void return_op(AsyncOpNode *op);       void return_op(AsyncOpNode *op);
  
         Boolean operator ==(const MessageQueueService & svce)
         {
            return operator==((const void *)&svce);
         }
         Boolean operator ==(const void *svce)
         {
            if((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)
         {
            return _thread_pool->running_count() + _thread_pool->dead_count() + _thread_pool->pool_count();
         }
         static ThreadPool *get_thread_pool(void);
         static void force_shutdown(void);
   
       Uint32 _mask;       Uint32 _mask;
       AtomicInt _die;       AtomicInt _die;
    protected:    protected:
         virtual Boolean accept_async(AsyncOpNode *op);
         virtual Boolean messageOK(const Message *msg) ;
       virtual void handleEnqueue(void) = 0;       virtual void handleEnqueue(void) = 0;
       virtual void handleEnqueue(Message *) = 0;       virtual void handleEnqueue(Message *) = 0;
       Boolean _enqueueResponse(Message *, Message *);       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);       virtual void _handle_async_request(AsyncRequest *req);
       virtual void _handle_async_callback(AsyncOpNode *operation);       virtual void _handle_async_callback(AsyncOpNode *operation);
       virtual void _make_response(Message *req, Uint32 code);       virtual void _make_response(Message *req, Uint32 code);
  
   
         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 *rep);
         virtual void handle_AsyncLegacyOperationStart(AsyncLegacyOperationStart *req);
         virtual void handle_AsyncLegacyOperationResult(AsyncLegacyOperationResult *rep);
   
         void _completeAsyncResponse(AsyncRequest *request,
                                    AsyncReply *reply,
                                    Uint32 state,
                                    Uint32 flag);
         void _complete_op_node(AsyncOpNode *, Uint32, Uint32, Uint32);
   
   
       static cimom *_meta_dispatcher;       static cimom *_meta_dispatcher;
       static AtomicInt _service_count;       static AtomicInt _service_count;
       static Mutex _meta_dispatcher_mutex;       static Mutex _meta_dispatcher_mutex;
  
   
    private:    private:
  
       DQueue<AsyncOpNode> _pending;  
       AsyncDQueue<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;
  
       static PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL _req_proc(void *);       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;       AtomicInt _incoming_queue_shutdown;
         Semaphore _callback_ready;
  
       Thread _req_thread;       Thread _req_thread;
         Thread _callback_thread;
      protected:
         static ThreadPool *_thread_pool;
      private:
       struct timeval _default_op_timeout;       struct timeval _default_op_timeout;
   
       static AtomicInt _xid;       static AtomicInt _xid;
         friend class cimom;
         friend class CIMServer;
   
   
 }; };
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

Legend:
Removed from v.1.18  
changed lines
  Added in v.1.36
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2