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

Diff for /pegasus/src/Pegasus/Common/ModuleController.h between version 1.2 and 1.52

version 1.2, 2002/03/14 23:28:56 version 1.52, 2008/08/14 17:44:27
Line 1 
Line 1 
 //%////-*-c++-*-////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
   // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
 // //
 // 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 20 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Day (mdday@us.ibm.com) <<< Wed Mar 13 20:49:40 2002 mdd >>>  
 //  
 // Modified By:  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #ifndef Pegasus_Module_Controller_h  #ifndef Pegasus_ModuleController_h
 #define Pegasus_Module_Controller_h  #define Pegasus_ModuleController_h
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
   #include <Pegasus/Common/Linkage.h>
   #include <Pegasus/Common/Constants.h>
   #include <Pegasus/Common/List.h>
 #include <Pegasus/Common/Message.h> #include <Pegasus/Common/Message.h>
 #include <Pegasus/Common/Exception.h>  
 #include <Pegasus/Common/IPC.h>  
 #include <Pegasus/Common/Thread.h>  
 #include <Pegasus/Common/AsyncOpNode.h>  
 #include <Pegasus/Common/Cimom.h>  
 #include <Pegasus/Common/CimomMessage.h>  
 #include <Pegasus/Common/MessageQueueService.h> #include <Pegasus/Common/MessageQueueService.h>
   #include <Pegasus/Common/AsyncOpNode.h>
   #include <Pegasus/Common/AutoPtr.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 class ModuleController;  class PEGASUS_COMMON_LINKAGE RegisteredModuleHandle : public Linkable
   
   
 class PEGASUS_COMMON_LINKAGE pegasus_module  
 { {
    public:    public:
       RegisteredModuleHandle(
           const String& name,
           void* module_address,
           Message* (*receive_message)(Message *, void *),
           void (*async_callback)(Uint32, Message *, void *));
  
       pegasus_module()      virtual ~RegisteredModuleHandle();
       {  
       }  
   
       virtual ~pegasus_module()  
       {  
       }  
  
       Boolean operator == (const service_module *) const;      const String& get_name() const;
       Boolean operator == (const String &  ) const ;  
       Boolean operator == (const service_module & ) const ;  
       Boolean operator == (const void *) const;  
   
       String & get_name(void);  
   
       // introspection interface  
       virtual Boolean query_interface(String & class_id,  
                                       void **object_ptr) = 0;  
       virtual Uint32 reference(void) { _reference_count++; }  
       virtual Uint32 dereference(void)  { _reference_count--; }  
  
    private:    private:
       virtual Boolean _rcv_msg(Message *) = 0;  
       virtual void _send_async_callback(Uint32 msg_handle, Message *msg) = 0;  
  
       virtual Boolean _shutdown(Uint32) = 0;      RegisteredModuleHandle();
       ModuleController *_controller;      RegisteredModuleHandle(const RegisteredModuleHandle&);
       RegisteredModuleHandle& operator=(const RegisteredModuleHandle&);
   
       Message* _receive_message(Message* msg);
       void _send_async_callback(Uint32 msg_handle, Message* msg, void* parm);
   
       String _name;       String _name;
       AtomicInt _reference_count;      void* _module_address;
       Message* (*_module_receive_message)(Message *, void *);
       void (*_async_callback)(Uint32, Message *, void *);
  
       friend class ModuleController;       friend class ModuleController;
 }; };
Line 84 
Line 78 
  
 class PEGASUS_COMMON_LINKAGE ModuleController : public MessageQueueService class PEGASUS_COMMON_LINKAGE ModuleController : public MessageQueueService
 { {
   public:
       typedef MessageQueueService Base;
  
       class callback_handle
       {
    public:    public:
       typedef MesageQueueService Base;          callback_handle(RegisteredModuleHandle* module, void* parm)
              : _module(module), _parm(parm)
           {
           }
   
           ~callback_handle()
           {
               if (_module->get_name() == String(PEGASUS_MODULENAME_TEMP))
                   _module.reset();
           }
  
       ModuleController(const char *name, Uint32 queueID);          AutoPtr<RegisteredModuleHandle> _module;
       ~ModuleController(void);          void* _parm;
       };
  
   public:
       ModuleController(const char *name);
  
       ~ModuleController();
  
       // module api       // module api
       ModuleController & register_module(pegasus_module *);      // @exception AlreadyExistsException
       deregister_module(pegasus_module *);      // @exception IncompatibleTypesException
       static ModuleController& register_module(
           const String & controller_name,
           const String& module_name,
           void* module_address,
           Message* (*receive_message)(Message *, void *),
           void (*async_callback)(Uint32, Message *, void *),
           RegisteredModuleHandle** instance = 0);
   
       // @exception Permission
       Boolean deregister_module(const String& module_name);
   
       // @exception Permission
       Uint32 find_service(
           const RegisteredModuleHandle& handle,
           const String& name);
   
       // @exception Permission
       // @exception IPCException
       Uint32 find_module_in_service(
           const RegisteredModuleHandle& handle,
           const String& module_name);
  
       Uint32 find_service(pegasus_module & handle, String & name);      // send a message to another service
       String & find_service(pegasus_module & handle, Uint32 queue_id);      // @exception Permission
       // @exception IPCException
       AsyncReply* ModuleSendWait(
           const RegisteredModuleHandle& handle,
           Uint32 destination_q,
           AsyncRequest* request);
  
       pegasus_module & get_module_reference(pegasus_module & handle, String & name);      // send a message to another module via another service
       // @exception Permission
       // @exception Deadlock
       // @exception IPCException
       AsyncReply* ModuleSendWait(
           const RegisteredModuleHandle& handle,
           Uint32 destination_q,
           const String& destination_module,
           AsyncRequest* message);
  
       // send an async message to another service
       // @exception Permission
       // @exception Deadlock
       // @exception IPCException
       Boolean ModuleSendAsync(
           const RegisteredModuleHandle& handle,
           Uint32 msg_handle,
           Uint32 destination_q,
           AsyncRequest* message,
           void* callback_parm);
  
       // send a message to another service      // send an async message to another module via another service
       Message *ModuleSendWait(pegasus_module & handle,      // @exception Permission
       // @exception IPCException
       Boolean ModuleSendAsync(
           const RegisteredModuleHandle& handle,
           Uint32 msg_handle,
           Uint32 destination_q,
           const String& destination_module,
           AsyncRequest* message,
           void* callback_parm);
   
       // @exception Permission
       // @exception IPCException
       Boolean ModuleSendForget(
           const RegisteredModuleHandle& handle,
                               Uint32 destination_q,                               Uint32 destination_q,
                               Message *message);          AsyncRequest* message);
  
       // send a message to another module via another service      // @exception Permission
       Message *ModuleSendWait(pegasus_module & handle,      // @exception IPCException
       Boolean ModuleSendForget(
           const RegisteredModuleHandle & handle,
                               Uint32 destination_q,                               Uint32 destination_q,
                               String & destination_module,          const String & destination_module,
                               Message *message);          AsyncRequest* message);
   
       Boolean verify_handle(RegisteredModuleHandle *);
   
       static ModuleController* getModuleController();
  
       // send a message to another service       // send a message to another service
       Boolean ModuleSendAsync(pegasus_module & handle,      // @exception Permission
                               Uint32 msg_handle,      // @exception IPCException
       AsyncReply* ClientSendWait(
                               Uint32 destination_q,                               Uint32 destination_q,
                               Message *message);          AsyncRequest* request);
  
       // send a message to another module via another service       // send a message to another module via another service
       Boolean ModuleSendAsync(pegasus_module & handle,      // @exception Permission
                               Uint32 msg_handle,      // @exception Deadlock
       // @exception IPCException
       AsyncReply* ClientSendWait(
                               Uint32 destination_q,                               Uint32 destination_q,
                               String & destination_module,                               String & destination_module,
                               Message *message);          AsyncRequest* message);
  
       Uint32 blocking_thread_exec(pegasus_module & handle,      // send an async message to another service
                                   PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),      // @exception Permission
                                   void *parm);      // @exception IPCException
       Uint32 async_thread_exec(pegasus_module & handle,      Boolean ClientSendAsync(
                                PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),          Uint32 msg_handle,
                                void *parm);          Uint32 destination_q,
           AsyncRequest* message,
           void (*async_callback)(Uint32, Message *, void *),
           void* callback_parm);
   
       // send an async message to another module via another service
       // @exception Permission
       // @exception IPCException
       Boolean ClientSendAsync(
           Uint32 msg_handle,
           Uint32 destination_q,
           const String& destination_module,
           AsyncRequest* message,
           void (*async_callback)(Uint32, Message *, void *),
           void* callback_parm);
   
       // @exception Permission
       // @exception IPCException
       Boolean ClientSendForget(
           Uint32 destination_q,
           AsyncRequest* message);
  
       // << Thu Mar 14 09:52:56 2002 mdd >>      // @exception Permission
       // need to add a blocking semaphore to ThreadPool for "joinable" threads      // @exception IPCException
       // need to define a special message type for sending messages to modules      Boolean ClientSendForget(
       //          Uint32 destination_q,
           const String& destination_module,
           AsyncRequest* message);
  
    protected:    protected:
       // ATTN-RK-P2-20010322:  These methods are pure virtual in superclass
       virtual void handleEnqueue() {}
       virtual void handleEnqueue(Message *) {}
       virtual void _handle_async_request(AsyncRequest *rq);
       virtual void _handle_async_callback(AsyncOpNode *op);
  
    private:    private:
       class _module_lock
       {
       public:
           _module_lock(List<RegisteredModuleHandle, Mutex> * list)
              :_list(list)
           {
              _list->lock();
           }
  
       DQueue<pegasus_module> _modules;          ~_module_lock()
       ThreadPool _thread_pool;          {
              _list->unlock();
           }
   
       private:
           _module_lock();
           List<RegisteredModuleHandle, Mutex> * _list;
 }; };
  
  
 PEGASUS_NAMESPACE_END      static void _async_handleEnqueue(
           AsyncOpNode* h,
           MessageQueue* q,
           void* parm);
   
       List<RegisteredModuleHandle, Mutex> _modules;
       AsyncReply *_send_wait(Uint32, AsyncRequest *);
       AsyncReply *_send_wait(Uint32, const String &, AsyncRequest *);
   
       // @exception IPCException
       Boolean _send_forget(Uint32, AsyncRequest *);
  
       // @exception IPCException
       Boolean _send_forget(Uint32, const String &, AsyncRequest *);
   };
   
   PEGASUS_NAMESPACE_END
  
 #endif // Pegasus_Module_Controller_h  #endif // Pegasus_ModuleController_h

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