(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.5 and 1.13

version 1.5, 2002/03/21 16:10:00 version 1.13, 2002/03/29 17:36:41
Line 38 
Line 38 
 #include <Pegasus/Common/Cimom.h> #include <Pegasus/Common/Cimom.h>
 #include <Pegasus/Common/CimomMessage.h> #include <Pegasus/Common/CimomMessage.h>
 #include <Pegasus/Common/MessageQueueService.h> #include <Pegasus/Common/MessageQueueService.h>
   
   #include <bitset>
   
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 class ModuleController; class ModuleController;
  
  
   
 class PEGASUS_COMMON_LINKAGE pegasus_module class PEGASUS_COMMON_LINKAGE pegasus_module
 { {
      private:
       class PEGASUS_COMMON_LINKAGE module_rep       class PEGASUS_COMMON_LINKAGE module_rep
       {       {
          public:          public:
             module_rep(ModuleController *controller,             module_rep(ModuleController *controller,
                        const String & name,                        const String & name,
                        void *module_address,                        void *module_address,
                        Boolean (*receive_message)(Message *),                         Message * (*receive_message)(Message *, void *),
                        void (*async_callback)(Uint32, Message *),                         void (*async_callback)(Uint32, Message *, void *),
                        void (*shutdown_notify)(Uint32 code))                         void (*shutdown_notify)(Uint32 code, void *));
                : _thread_safety(),  
                  _controller(controller),  
                  _name(name),  
                  _reference_count(1),  
                  _module_address(module_address)  
   
             {  
                if(receive_message != NULL)  
                   _receive_message = receive_message;  
                else  
                   _receive_message = default_receive_message;  
                if(async_callback != NULL)  
                   _async_callback = async_callback;  
                else  
                   _async_callback = default_async_callback;  
                if(shutdown_notify != NULL)  
                   _shutdown_notify = shutdown_notify;  
                else  
                   _shutdown_notify = default_shutdown_notify;  
             }  
  
             virtual ~module_rep(void)              ~module_rep(void) ;
             {  
   
             }  
  
  
             Boolean operator == (const module_rep *rep) const             Boolean operator == (const module_rep *rep) const
             {              { if (rep == this ) return true; return false; }
                if (rep == this )  
                   return true;  
                return false;  
             }  
  
             Boolean operator == (const module_rep &rep) const             Boolean operator == (const module_rep &rep) const
             {              { if (rep == *this) return true; return false; }
                if (rep == *this)  
                   return true;  
                return false;  
             }  
  
             Boolean operator == (void *rep) const             Boolean operator == (void *rep) const
             {              { if ( (void *)this == rep ) return true; return false; }
                if ( (void *)this == rep )  
                   return true;  
                return false;  
             }  
  
             void reference(void) { _reference_count++; }             void reference(void) { _reference_count++; }
             void dereference(void) { _reference_count--; }             void dereference(void) { _reference_count--; }
             Uint32 reference_count(void)  { return _reference_count.value(); }             Uint32 reference_count(void)  { return _reference_count.value(); }
             const String & get_name(void) const { return _name; }             const String & get_name(void) const { return _name; }
             void *get_module_address(void) const { return _module_address; }             void *get_module_address(void) const { return _module_address; }
             Boolean module_receive_message(Message *msg)  
             {  
  
                _thread_safety.lock(pegasus_thread_self());              Message * module_receive_message(Message *msg);
                try {  _receive_message(msg); }  
                catch(...) { _thread_safety.unlock(); throw; }  
                _thread_safety.unlock();  
             }  
   
             void _send_async_callback(Uint32 msg_handle, Message *msg)  
             {  
                _thread_safety.lock(pegasus_thread_self());  
                try  { _async_callback(msg_handle, msg); }  
                catch(...) { _thread_safety.unlock(); throw; }  
  
             }              void _send_async_callback(Uint32 msg_handle, Message *msg);
             void _send_shutdown_notify(Uint32 code)  
             {  
                _shutdown_notify(code);  
             }  
             void lock(void)  
             {  
                _thread_safety.lock(pegasus_thread_self());  
             }  
   
             void unlock(void)  
             {  
                _thread_safety.unlock();  
             }  
  
               void _send_shutdown_notify(void);
               void lock(void) { _thread_safety.lock(pegasus_thread_self()); }
               void unlock(void) { _thread_safety.unlock(); }
          private:          private:
             module_rep(void);             module_rep(void);
             module_rep(const module_rep & );             module_rep(const module_rep & );
Line 147 
Line 93 
             ModuleController *_controller;             ModuleController *_controller;
             String _name;             String _name;
             AtomicInt _reference_count;             AtomicInt _reference_count;
               AtomicInt _shutting_down;
   
             void *_module_address;             void *_module_address;
             Boolean (*_receive_message)(Message *);              Message * (*_receive_message)(Message *, void *);
             void (*_async_callback)(Uint32, Message *);              void (*_async_callback)(Uint32, Message *, void *);
             void (*_shutdown_notify)(Uint32 code);              void (*_shutdown_notify)(Uint32 code, void *);
  
             static Boolean default_receive_message(Message *msg)              static Message * default_receive_message(Message *msg, void *inst)
             {              { throw NotImplemented("Module Receive");}
                throw NotImplemented("Module Receive");  
             }  
  
             static void default_async_callback(Uint32 handle, Message *msg)              static void default_async_callback(Uint32 handle, Message *msg, void *inst)
             {              { throw NotImplemented("Module Async Receive"); }
                throw NotImplemented("Module Async Receive");  
             }  
  
             static void default_shutdown_notify(Uint32 code)              static void default_shutdown_notify(Uint32 code, void *inst)
             {              { return; }
                return;  
             }              static Message * closed_receive_message(Message *msg, void *inst)
               { throw ModuleClosed();}
   
               static void closed_async_callback(Uint32 handle, Message *msg, void *inst)
               { throw ModuleClosed(); }
  
             friend class ModuleController;             friend class ModuleController;
       };       };
Line 175 
Line 123 
       pegasus_module(ModuleController *controller,       pegasus_module(ModuleController *controller,
                      const String &id,                      const String &id,
                      void *module_address,                      void *module_address,
                      Boolean (*receive_message)(Message *),                       Message * (*receive_message)(Message *, void *),
                      void (*async_callback)(Uint32, Message *),                       void (*async_callback)(Uint32, Message *, void *),
                      void (*shutdown_notify)(Uint32 code)) ;                       void (*shutdown_notify)(Uint32 code, void *)) ;
  
       virtual ~pegasus_module(void)        ~pegasus_module(void);
       {  
          _rep->dereference();  
          if( 0 == _rep->reference_count())  
             delete _rep;  
       }  
  
       pegasus_module & operator= (const pegasus_module & mod);       pegasus_module & operator= (const pegasus_module & mod);
       Boolean operator == (const pegasus_module *mod) const;       Boolean operator == (const pegasus_module *mod) const;
Line 200 
Line 143 
    private:    private:
  
       module_rep *_rep;       module_rep *_rep;
   
       pegasus_module(void);       pegasus_module(void);
       pegasus_module(const pegasus_module & mod);       pegasus_module(const pegasus_module & mod);
       virtual Boolean _rcv_msg(Message *) ;        Boolean _rcv_msg(Message *) ;
       Boolean _receive_message(Message *msg)        Message * _receive_message(Message *msg);
         void _send_async_callback(Uint32 msg_handle, Message *msg) ;
         void _send_shutdown_notify(void);
         Boolean _shutdown(void);
   
         void reference(void) { _rep->reference(); }
         void dereference(void)  { _rep->dereference(); }
         friend class ModuleController;
   };
   
   
   class PEGASUS_COMMON_LINKAGE ModuleController : public MessageQueueService
       {       {
          _rep->module_receive_message(msg);  
       }  
  
       void _send_async_callback(Uint32 msg_handle, Message *msg)  
      public:
         typedef MessageQueueService Base;
   
         enum
       {       {
          _rep->_send_async_callback(msg_handle, msg);           GET_CLIENT_HANDLE,
       }           REGISTER_MODULE,
       void _send_shutdown_notify(Uint32 code)           DEREGISTER_MODULE,
            FIND_SERVICE,
            FIND_MODULE_IN_SERVICE,
            GET_MODULE_REFERENCE,
            MODULE_SEND_WAIT,
            MODULE_SEND_WAIT_MODULE,
            MODULE_SEND_ASYNC,
            MODULE_SEND_ASYNC_MODULE,
            BLOCKING_THREAD_EXEC,
            ASYNC_THREAD_EXEC,
            NUMBER_OPERATIONS
         } ;
      private:
         class PEGASUS_COMMON_LINKAGE client_handle
         {
            public:
               client_handle(void)
                  : _allowed_operations(0),
                    _allowed_destinations(0),
                    _allowed_sources(0),
                    _identity(NULL)
       {       {
          _rep->_send_shutdown_notify(code);  
       }       }
  
       virtual Boolean _shutdown(Uint32) ;              ~client_handle(void);
       virtual void reference(void) { _rep->reference(); }  
       virtual void dereference(void)  { _rep->dereference(); }  
  
            private:
       friend class ModuleController;       friend class ModuleController;
               client_handle(Uint32 operations,
                             Uint32 destinations,
                             Uint32 sources,
                             void *identity)
                  : _allowed_operations(operations),
                    _allowed_destinations(destinations),
                    _allowed_sources(sources),
                    _identity(identity)
               {
               }
   
               bitset<NUMBER_OPERATIONS>  _allowed_operations;
               bitset<128> _allowed_destinations;
               bitset<128> _allowed_sources;
               void *_identity;
   
               Boolean allowed(Uint32 operation,
                               Uint32 destination,
                               Uint32 source,
                               void *identity)
               {
                  return true;
               }
 }; };
  
      public:
  
  
         ModuleController(const char *name);
         ModuleController(const char *name,
                          Sint16 min_threads,
                          Sint16 max_threads,
                          struct timeval & create_thread,
                          struct timeval & destroy_thread,
                          struct timeval & deadlock);
  
 class PEGASUS_COMMON_LINKAGE ModuleController : public MessageQueueService  
 {  
  
    public:        ~ModuleController(void);
       typedef MessageQueueService Base;  
         static ModuleController & get_client_handle(const String & controller_name,
                                                     void **handle);
  
       ModuleController(const char *name, Uint32 queueID);  
       virtual ~ModuleController(void);  
  
       // module api       // module api
       ModuleController & register_module(const String & module_name,        static ModuleController & register_module(const String & controller_name,
                                                   const String & module_name,
                                          void *module_address,                                          void *module_address,
                                          void (*async_callback)(Uint32, Message *));                                                  Message * (*receive_message)(Message *, void *),
                                                   void (*async_callback)(Uint32, Message *, void *),
                                                   void (*shutdown_notify)(Uint32, void *),
                                                   pegasus_module **instance = NULL)
            throw(AlreadyExists, IncompatibleTypes);
   
         Boolean deregister_module(const String & module_name)
            throw(Permission);
   
         Uint32 find_service(pegasus_module & handle, const String & name) throw(Permission);
  
       Boolean deregister_module(const String & module_name);        Uint32 find_module_in_service(pegasus_module & handle,
                                       const String & module_name)
            throw(Permission, IPCException);
  
       Uint32 find_service(pegasus_module & handle, String & name);  
       String & find_service(pegasus_module & handle, Uint32 queue_id);  
  
       pegasus_module & get_module_reference(pegasus_module & handle, String & name);        pegasus_module * get_module_reference(pegasus_module & my_handle,
                                               const String & module_name)
            throw(Permission);
  
       // send a message to another service       // send a message to another service
       Message *ModuleSendWait(pegasus_module & handle,        AsyncReply *ModuleSendWait(pegasus_module & handle,
                               Uint32 destination_q,                               Uint32 destination_q,
                               Message *message);                                AsyncRequest *request) throw(Permission, IPCException);
  
       // send a message to another module via another service       // send a message to another module via another service
       Message *ModuleSendWait(pegasus_module & handle,        AsyncReply *ModuleSendWait(pegasus_module & handle,
                               Uint32 destination_q,                               Uint32 destination_q,
                               String & destination_module,                               String & destination_module,
                               Message *message);                                AsyncRequest *message) throw(Permission, Deadlock, IPCException);
  
       // send a message to another service        // send an async message to another service
       Boolean ModuleSendAsync(pegasus_module & handle,       Boolean ModuleSendAsync(pegasus_module & handle,
                               Uint32 msg_handle,                               Uint32 msg_handle,
                               Uint32 destination_q,                               Uint32 destination_q,
                               Message *message);                                AsyncRequest *message) throw(Permission, IPCException);
  
       // send a message to another module via another service        // send an async message to another module via another service
       Boolean ModuleSendAsync(pegasus_module & handle,       Boolean ModuleSendAsync(pegasus_module & handle,
                               Uint32 msg_handle,                               Uint32 msg_handle,
                               Uint32 destination_q,                               Uint32 destination_q,
                               String & destination_module,                               String & destination_module,
                               Message *message);                                AsyncRequest *message) throw(Permission, IPCException);
  
       Uint32 blocking_thread_exec(pegasus_module & handle,        void blocking_thread_exec(pegasus_module & handle,
                                   PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),                                   PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),
                                   void *parm);                                  void *parm) throw(Permission, Deadlock, IPCException);
       Uint32 async_thread_exec(pegasus_module & handle,        void async_thread_exec(pegasus_module & handle,
                                PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),                                PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),
                                void *parm);                               void *parm) throw(Permission, Deadlock, IPCException);
         Boolean verify_handle(pegasus_module *);
    protected:    protected:
         // ATTN-RK-P2-20010322:  These methods are pure virtual in superclass
         virtual void handleEnqueue(void) {}
         virtual void handleEnqueue(Message *) {}
         virtual void _handle_async_request(AsyncRequest *rq);
         virtual void _handle_async_callback(AsyncOpNode *op);
  
    private:    private:
         static void _async_handleEnqueue(AsyncOpNode *h, MessageQueue *q, void *parm);
       DQueue<pegasus_module> _modules;       DQueue<pegasus_module> _modules;
       ThreadPool _thread_pool;       ThreadPool _thread_pool;
 }; };

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