(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.3 and 1.16

version 1.3, 2002/03/19 21:03:37 version 1.16, 2002/04/01 19:25:43
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 <Pegasus/Common/peg_authorization.h>
   
   
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 class ModuleController; class ModuleController;
  
  
 class PEGASUS_COMMON_LINKAGE pegasus_module  class PEGASUS_COMMON_LINKAGE pegasus_module : pegasus_authorization_handle
   {
      private:
         class module_rep
 { {
       class  module_rep;  
   
    public:    public:
               module_rep(ModuleController *controller,
       pegasus_module(ModuleController *controller,                         const String & name,
                      const String &id,  
                      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 code, void *));
  
       }              ~module_rep(void) ;
  
       pegasus_module(const pegasus_module & mod)  
       {  
          (mod._rep->_reference_count)++;  
          _rep = mod._rep;  
       }  
  
       virtual ~pegasus_module()              Boolean operator == (const module_rep *rep) const
       {              { if (rep == this ) return true; return false; }
          if( 0 == (_rep->_reference_count.value()))  
             delete _rep;  
  
       }              Boolean operator == (const module_rep &rep) const
               { if (rep == *this) return true; return false; }
  
       pegasus_module & pegasus_module::operator= (const pegasus_module & mod)              Boolean operator == (void *rep) const
       {              { if ( (void *)this == rep ) return true; return false; }
          (mod._rep->_reference_count)++;  
          if ( ((rep->_reference_count)--) == 0 )              void reference(void) { _reference_count++; }
             delete rep;              void dereference(void) { _reference_count--; }
          _rep = mod._rep;              Uint32 reference_count(void)  { return _reference_count.value(); }
          return *this;              const String & get_name(void) const { return _name; }
       }              void *get_module_address(void) const { return _module_address; }
   
               Message * module_receive_message(Message *msg);
  
               void _send_async_callback(Uint32 msg_handle, Message *msg);
  
       Boolean operator == (const pegasus_module *mod) const              void _send_shutdown_notify(void);
               void lock(void) { _thread_safety.lock(pegasus_thread_self()); }
               void unlock(void) { _thread_safety.unlock(); }
            private:
               module_rep(void);
               module_rep(const module_rep & );
               module_rep& operator= (const module_rep & rep)
               {
                  if( this != &rep )
       {       {
          if(mod->_rep == _rep)                    _reference_count++;
             return true;                 }
          return false;                 return *this;
       }       }
  
       Boolean operator == (const String &  mod) const              module_rep *operator=(const module_rep *rep)
       {       {
          if(_rep->_name == mod)                 if( this != rep)
             return true;                 {
          return false;                    _reference_count++;
                  }
                  return this;
       }       }
  
       Boolean operator == (const pegasus_module & mod) const  
       {  
          if( mod._rep == _rep )  
             return true;  
          return false;  
  
       }              Mutex _thread_safety;
               ModuleController *_controller;
               String _name;
               AtomicInt _reference_count;
               AtomicInt _shutting_down;
  
       Boolean operator == (const void *mod) const              void *_module_address;
       {              Message * (*_receive_message)(Message *, void *);
          if ( (reinterpret_cast<pegasus_module *>(mod))->_rep == _rep)              void (*_async_callback)(Uint32, Message *, void *);
             return true;              void (*_shutdown_notify)(Uint32 code, void *);
          return false;  
       }  
  
       const String & get_name(void);              static Message * default_receive_message(Message *msg, void *inst)
               { throw NotImplemented("Module Receive");}
   
               static void default_async_callback(Uint32 handle, Message *msg, void *inst)
               { throw NotImplemented("Module Async Receive"); }
   
               static void default_shutdown_notify(Uint32 code, void *inst)
               { 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;
         };
   
      public:
         typedef pegasus_authorization_handle Base;
   
         pegasus_module(ModuleController *controller,
                        const String &id,
                        void *module_address,
                        Message * (*receive_message)(Message *, void *),
                        void (*async_callback)(Uint32, Message *, void *),
                        void (*shutdown_notify)(Uint32 code, void *)) ;
   
         ~pegasus_module(void);
   
         virtual Boolean authorized(Uint32 operation);
         virtual Boolean authorized(void);
   
         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 ;
         Boolean operator == (const String &  mod) const;
         Boolean operator == (const void *mod) const;
   
         const String & get_name(void) const;
  
       // introspection interface       // introspection interface
       Boolean query_interface(String & class_id, void **object_ptr) ;        Boolean query_interface(const String & class_id, void **object_ptr) const;
   
  
    private:    private:
  
       module_rep *_rep;       module_rep *_rep;
   
       pegasus_module(void);       pegasus_module(void);
       virtual Boolean _rcv_msg(Message *) = 0;        pegasus_module(const pegasus_module & mod);
         Boolean _rcv_msg(Message *) ;
         Message * _receive_message(Message *msg);
       void _send_async_callback(Uint32 msg_handle, Message *msg) ;       void _send_async_callback(Uint32 msg_handle, Message *msg) ;
         void _send_shutdown_notify(void);
         Boolean _shutdown(void);
         bitset<32> _allowed_operations;
  
       virtual Boolean _shutdown(Uint32) = 0;        void reference(void) { _rep->reference(); }
         void dereference(void)  { _rep->dereference(); }
       virtual Uint32 reference(void) { _reference_count++; }  
       virtual Uint32 dereference(void)  { _reference_count--; }  
   
       friend class ModuleController;       friend class ModuleController;
 }; };
  
  
 class PEGASUS_COMMON_LINKAGE pegasus_module::module_rep  class PEGASUS_COMMON_LINKAGE ModuleController : public MessageQueueService
 {  
    public:  
       module_rep(ModuleController *controller,  
                  const String & name,  
                  void *module_address,  
                  void (*async_callback)(Uint32, Message *))  
          : _controller(controller),  
            _name(name),  
            _reference_count(1),  
            _module_address(module_address),  
            _async_callback(async_callback)  
       {       {
  
       }  
  
       virtual ~module_rep(void)     public:
       {        typedef MessageQueueService Base;
  
       }        static const Uint32 GET_CLIENT_HANDLE;
         static const Uint32 REGISTER_MODULE;
         static const Uint32 DEREGISTER_MODULE;
         static const Uint32 FIND_SERVICE;
         static const Uint32 FIND_MODULE_IN_SERVICE;
         static const Uint32 GET_MODULE_REFERENCE;
         static const Uint32 MODULE_SEND_WAIT;
         static const Uint32 MODULE_SEND_WAIT_MODULE;
         static const Uint32 MODULE_SEND_ASYNC;
         static const Uint32 MODULE_SEND_ASYNC_MODULE;
         static const Uint32 BLOCKING_THREAD_EXEC;
         static const Uint32 ASYNC_THREAD_EXEC;
         static const Uint32 CLIENT_SEND_WAIT;
         static const Uint32 CLIENT_SEND_WAIT_MODULE;
         static const Uint32 CLIENT_SEND_ASYNC;
         static const Uint32 CLIENT_SEND_ASYNC_MODULE;
         static const Uint32 CLIENT_BLOCKING_THREAD_EXEC;
         static const Uint32 CLIENT_ASYNC_THREAD_EXEC;
  
       Boolean operator == (const module_rep *rep) const  
      private:
         class client_handle : pegasus_authorization_handle
       {       {
          if (rep == this )           public:
             return true;              typedef pegasus_authorization_handle Base;
          return false;  
       }  
  
       Boolean operator == (const module_rep &rep) const              client_handle(void)
                  :Base(new pegasus_internal_identity(peg_credential_types::SERVICE)),
                   allowed_operations( GET_CLIENT_HANDLE |
                                       FIND_SERVICE |
                                       FIND_MODULE_IN_SERVICE |
                                       GET_MODULE_REFERENCE |
                                       CLIENT_SEND_WAIT |
                                       CLIENT_SEND_WAIT_MODULE |
                                       CLIENT_SEND_ASYNC |
                                       CLIENT_SEND_ASYNC_MODULE |
                                       CLIENT_BLOCKING_THREAD_EXEC |
                                       CLIENT_ASYNC_THREAD_EXEC)
       {       {
          if (rep == *this)  
             return true;  
          return false;  
       }       }
  
       Boolean operator == (void *rep) const              client_handle(pegasus_base_identity *id)
                  :Base(id)
       {       {
          if ( (void *)this == rep )                 if( id && (id->get_base_id_type() == peg_identity_types::INTERNAL ))
             return true;                 {
          return false;                    if (id->get_base_cred_type() == peg_credential_types::SERVICE )
                        allowed_operations = ModuleController::CLIENT_SEND_WAIT |
                                             ModuleController::CLIENT_SEND_WAIT_MODULE |
                                             ModuleController::CLIENT_SEND_ASYNC |
                                             ModuleController::CLIENT_SEND_ASYNC_MODULE |
                                             ModuleController::CLIENT_BLOCKING_THREAD_EXEC |
                                             ModuleController::CLIENT_ASYNC_THREAD_EXEC;
                     else
                        allowed_operations = 0;
       }       }
  
               }
               ~client_handle(void);
               virtual Boolean authorized(Uint32 operation);
               virtual Boolean authorized(void);
  
    private:    private:
       module_rep(void);              bitset<64> allowed_operations;
       module_rep(const module_rep & );        };
       module_rep& operator= (const module_rep & );  
  
      public:
  
       ModuleController *_controller;  
       String _name;  
       AtomicInt _reference_count;  
       void *_module_address;  
       void (*_async_callback)(Uint32, Message *);  
       friend class ModuleController;  
 };  
  
         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 MesageQueueService 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);
  
       deregister_module(const String & module_name);        Uint32 find_service(pegasus_module & handle, const String & name) throw(Permission);
  
       Uint32 find_service(pegasus_module & handle, String & name);        Uint32 find_module_in_service(pegasus_module & handle,
       String & find_service(pegasus_module & handle, Uint32 queue_id);                                      const String & module_name)
            throw(Permission, IPCException);
  
       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;
 }; };
  
  
   
   
   
   
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
  
  
 #endif // Pegasus_Module_Controller_h  #endif // Pegasus_Module_Controller_H

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