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

version 1.9, 2002/03/26 21:39:06 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:    private:
       class PEGASUS_COMMON_LINKAGE module_rep        class module_rep
       {       {
          public:          public:
             module_rep(ModuleController *controller,             module_rep(ModuleController *controller,
                        const String & name,                        const String & name,
                        void *module_address,                        void *module_address,
                        Message * (*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 *));
  
             ~module_rep(void) ;             ~module_rep(void) ;
  
Line 84 
Line 87 
          private:          private:
             module_rep(void);             module_rep(void);
             module_rep(const module_rep & );             module_rep(const module_rep & );
             module_rep& operator= (const module_rep & );              module_rep& operator= (const module_rep & rep)
               {
                  if( this != &rep )
                  {
                     _reference_count++;
                  }
                  return *this;
               }
   
               module_rep *operator=(const module_rep *rep)
               {
                  if( this != rep)
                  {
                     _reference_count++;
                  }
                  return this;
               }
   
  
             Mutex _thread_safety;             Mutex _thread_safety;
             ModuleController *_controller;             ModuleController *_controller;
Line 93 
Line 113 
             AtomicInt _shutting_down;             AtomicInt _shutting_down;
  
             void *_module_address;             void *_module_address;
             Message * (*_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 Message * 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)              static Message * closed_receive_message(Message *msg, void *inst)
             { throw ModuleClosed();}             { throw ModuleClosed();}
  
             static void closed_async_callback(Uint32 handle, Message *msg)              static void closed_async_callback(Uint32 handle, Message *msg, void *inst)
             { throw ModuleClosed(); }             { throw ModuleClosed(); }
  
             friend class ModuleController;             friend class ModuleController;
       };       };
  
    public:    public:
         typedef pegasus_authorization_handle Base;
  
       pegasus_module(ModuleController *controller,       pegasus_module(ModuleController *controller,
                      const String &id,                      const String &id,
                      void *module_address,                      void *module_address,
                      Message * (*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 *)) ;
  
       ~pegasus_module(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);
         pegasus_module * operator= (const pegasus_module * mod);
   
       Boolean operator == (const pegasus_module *mod) const;       Boolean operator == (const pegasus_module *mod) const;
       Boolean operator == (const pegasus_module & mod) const ;       Boolean operator == (const pegasus_module & mod) const ;
       Boolean operator == (const String &  mod) const;       Boolean operator == (const String &  mod) const;
Line 137 
Line 163 
       // introspection interface       // introspection interface
       Boolean query_interface(const String & class_id, void **object_ptr) const;       Boolean query_interface(const String & class_id, void **object_ptr) const;
  
   
    private:    private:
  
       module_rep *_rep;       module_rep *_rep;
Line 147 
Line 174 
       void _send_async_callback(Uint32 msg_handle, Message *msg) ;       void _send_async_callback(Uint32 msg_handle, Message *msg) ;
       void _send_shutdown_notify(void);       void _send_shutdown_notify(void);
       Boolean _shutdown(void);       Boolean _shutdown(void);
         bitset<32> _allowed_operations;
  
       void reference(void) { _rep->reference(); }       void reference(void) { _rep->reference(); }
       void dereference(void)  { _rep->dereference(); }       void dereference(void)  { _rep->dereference(); }
Line 157 
Line 185 
 class PEGASUS_COMMON_LINKAGE ModuleController : public MessageQueueService class PEGASUS_COMMON_LINKAGE ModuleController : public MessageQueueService
 { {
  
   
    public:    public:
       typedef MessageQueueService Base;       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;
   
   
      private:
         class client_handle : pegasus_authorization_handle
         {
            public:
               typedef pegasus_authorization_handle Base;
   
               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)
               {
   
               }
   
               client_handle(pegasus_base_identity *id)
                  :Base(id)
               {
                  if( id && (id->get_base_id_type() == peg_identity_types::INTERNAL ))
                  {
                     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:
               bitset<64> allowed_operations;
         };
   
      public:
   
   
       ModuleController(const char *name);       ModuleController(const char *name);
       ModuleController(const char *name,       ModuleController(const char *name,
                        Sint16 min_threads,                        Sint16 min_threads,
Line 171 
Line 270 
  
       ~ModuleController(void);       ~ModuleController(void);
  
         static ModuleController & get_client_handle(const String & controller_name,
                                                     void **handle);
   
   
       // module api       // module api
       static ModuleController & register_module(const String & controller_name,       static ModuleController & register_module(const String & controller_name,
                                                 const String & module_name,                                                 const String & module_name,
                                                 void *module_address,                                                 void *module_address,
                                                 Message * (*receive_message)(Message *),                                                  Message * (*receive_message)(Message *, void *),
                                                 void (*async_callback)(Uint32, Message *),                                                  void (*async_callback)(Uint32, Message *, void *),
                                                 void (*shutdown_notify)(Uint32))                                                  void (*shutdown_notify)(Uint32, void *),
                                                   pegasus_module **instance = NULL)
          throw(AlreadyExists, IncompatibleTypes);          throw(AlreadyExists, IncompatibleTypes);
  
       Boolean deregister_module(const String & module_name);        Boolean deregister_module(const String & module_name)
            throw(Permission);
  
       Uint32 find_service(pegasus_module & handle, const String & name) throw(Permission);       Uint32 find_service(pegasus_module & handle, const String & name) throw(Permission);
  
Line 204 
Line 309 
                               String & destination_module,                               String & destination_module,
                               AsyncRequest *message) throw(Permission, Deadlock, IPCException);                               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,
                               AsyncRequest *message) throw(Permission, IPCException);                               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,
Line 223 
Line 328 
       void 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) throw(Permission, Deadlock, IPCException);                              void *parm) throw(Permission, Deadlock, IPCException);
   
       Boolean verify_handle(pegasus_module *);       Boolean verify_handle(pegasus_module *);
    protected:    protected:
       // ATTN-RK-P2-20010322:  These methods are pure virtual in superclass       // ATTN-RK-P2-20010322:  These methods are pure virtual in superclass

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