(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.16 and 1.28

version 1.16, 2002/04/01 19:25:43 version 1.28, 2002/06/01 00:56:36
Line 1 
Line 1 
 //%////-*-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 30 
Line 31 
 #define Pegasus_Module_Controller_h #define Pegasus_Module_Controller_h
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
   #include <Pegasus/Common/Constants.h>
 #include <Pegasus/Common/Message.h> #include <Pegasus/Common/Message.h>
 #include <Pegasus/Common/Exception.h> #include <Pegasus/Common/Exception.h>
 #include <Pegasus/Common/IPC.h> #include <Pegasus/Common/IPC.h>
Line 46 
Line 48 
 class ModuleController; class ModuleController;
  
  
 class PEGASUS_COMMON_LINKAGE pegasus_module : pegasus_authorization_handle  class PEGASUS_COMMON_LINKAGE pegasus_module
 { {
    private:    private:
       class module_rep        class module_rep : public pegasus_auth_handle
       {       {
          public:          public:
               typedef pegasus_auth_handle Base;
   
             module_rep(ModuleController *controller,             module_rep(ModuleController *controller,
                        const String & name,                        const String & name,
                        void *module_address,                        void *module_address,
Line 61 
Line 65 
  
             ~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; }
  
Line 79 
Line 82 
  
             Message * module_receive_message(Message *msg);             Message * module_receive_message(Message *msg);
  
             void _send_async_callback(Uint32 msg_handle, Message *msg);              void _send_async_callback(Uint32 msg_handle, Message *msg, void *parm);
  
             void _send_shutdown_notify(void);             void _send_shutdown_notify(void);
             void lock(void) { _thread_safety.lock(pegasus_thread_self()); }             void lock(void) { _thread_safety.lock(pegasus_thread_self()); }
             void unlock(void) { _thread_safety.unlock(); }             void unlock(void) { _thread_safety.unlock(); }
   
               Boolean authorized(void) ;
               Boolean authorized(Uint32);
               Boolean authorized(Uint32, Uint32);
   
          private:          private:
             module_rep(void);             module_rep(void);
             module_rep(const module_rep & );             module_rep(const module_rep & );
             module_rep& operator= (const module_rep & 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;
Line 118 
Line 110 
             void (*_shutdown_notify)(Uint32 code, void *);             void (*_shutdown_notify)(Uint32 code, void *);
  
             static Message * default_receive_message(Message *msg, void *inst)             static Message * default_receive_message(Message *msg, void *inst)
             { throw NotImplemented("Module Receive");}              { throw NotImplemented("Module Receive"); return 0; }
  
             static void default_async_callback(Uint32 handle, Message *msg, void *inst)             static void default_async_callback(Uint32 handle, Message *msg, void *inst)
             { throw NotImplemented("Module Async Receive"); }             { throw NotImplemented("Module Async Receive"); }
Line 127 
Line 119 
             { return; }             { return; }
  
             static Message * closed_receive_message(Message *msg, void *inst)             static Message * closed_receive_message(Message *msg, void *inst)
             { throw ModuleClosed();}              { throw ModuleClosed(); return 0; }
  
             static void closed_async_callback(Uint32 handle, Message *msg, void *inst)             static void closed_async_callback(Uint32 handle, Message *msg, void *inst)
             { throw ModuleClosed(); }             { throw ModuleClosed(); }
Line 136 
Line 128 
       };       };
  
    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,
Line 145 
Line 135 
                      void (*async_callback)(Uint32, Message *, void *),                      void (*async_callback)(Uint32, Message *, void *),
                      void (*shutdown_notify)(Uint32 code, void *)) ;                      void (*shutdown_notify)(Uint32 code, void *)) ;
  
       ~pegasus_module(void);        pegasus_module(const pegasus_module & mod);
         pegasus_module & operator= (const pegasus_module & mod);
   
         virtual ~pegasus_module(void);
  
       virtual Boolean authorized(Uint32 operation);       virtual Boolean authorized(Uint32 operation);
       virtual Boolean authorized(void);       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 pegasus_module & mod) const ;
       Boolean operator == (const String &  mod) const;       Boolean operator == (const String &  mod) const;
       Boolean operator == (const void *mod) const;       Boolean operator == (const void *mod) const;
Line 167 
Line 156 
    private:    private:
  
       module_rep *_rep;       module_rep *_rep;
       pegasus_module(void);  
       pegasus_module(const pegasus_module & mod);        pegasus_module(void)
         {
         }
   
       Boolean _rcv_msg(Message *) ;       Boolean _rcv_msg(Message *) ;
       Message * _receive_message(Message *msg);       Message * _receive_message(Message *msg);
       void _send_async_callback(Uint32 msg_handle, Message *msg) ;        void _send_async_callback(Uint32 msg_handle, Message *msg, void *) ;
       void _send_shutdown_notify(void);       void _send_shutdown_notify(void);
       Boolean _shutdown(void);       Boolean _shutdown(void);
       bitset<32> _allowed_operations;        PEGASUS_STD(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 207 
Line 199 
       static const Uint32 CLIENT_SEND_ASYNC_MODULE;       static const Uint32 CLIENT_SEND_ASYNC_MODULE;
       static const Uint32 CLIENT_BLOCKING_THREAD_EXEC;       static const Uint32 CLIENT_BLOCKING_THREAD_EXEC;
       static const Uint32 CLIENT_ASYNC_THREAD_EXEC;       static const Uint32 CLIENT_ASYNC_THREAD_EXEC;
         static const Uint32 CLIENT_SEND_FORGET;
         static const Uint32 CLIENT_SEND_FORGET_MODULE;
         static const Uint32 MODULE_SEND_FORGET;
         static const Uint32 MODULE_SEND_FORGET_MODULE;
  
   // ATTN-DME-P2-20020406 Removed private declaration.  client_handle is
   //          currently used in Pegasus/Provider/CIMOMHandle.cpp
  
    private:  //   private:
       class client_handle : pegasus_authorization_handle        class client_handle : public pegasus_auth_handle
       {       {
          public:          public:
             typedef pegasus_authorization_handle Base;              typedef pegasus_auth_handle Base;
  
             client_handle(void)              client_handle(const pegasus_identity & id)
                :Base(new pegasus_internal_identity(peg_credential_types::SERVICE)),                 :Base(id) ,
                 allowed_operations( GET_CLIENT_HANDLE |                 allowed_operations( GET_CLIENT_HANDLE |
                                     FIND_SERVICE |                                     FIND_SERVICE |
                                     FIND_MODULE_IN_SERVICE |                                     FIND_MODULE_IN_SERVICE |
Line 228 
Line 226 
                                     CLIENT_BLOCKING_THREAD_EXEC |                                     CLIENT_BLOCKING_THREAD_EXEC |
                                     CLIENT_ASYNC_THREAD_EXEC)                                     CLIENT_ASYNC_THREAD_EXEC)
             {             {
   
             }             }
  
             client_handle(pegasus_base_identity *id)              ~client_handle(void)
                :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;  
                }                }
  
             }              virtual Boolean authorized(Uint32, Uint32);
             ~client_handle(void);  
             virtual Boolean authorized(Uint32 operation);             virtual Boolean authorized(Uint32 operation);
             virtual Boolean authorized(void);             virtual Boolean authorized(void);
               PEGASUS_STD(bitset<32>) allowed_operations;
         };
  
         class callback_handle
         {
            public:
               static void * operator new(size_t );
               static void operator delete(void *, size_t);
          private:          private:
             bitset<64> allowed_operations;              static callback_handle *_head;
               static const int BLOCK_SIZE;
               static Mutex _alloc_mut;
   
            public:
               callback_handle(pegasus_module * module, void *parm)
                  : _module(module), _parm(parm)
               {
               }
   
               ~callback_handle()
               {
                  if( _module->get_name() == String(PEGASUS_MODULENAME_TEMP) )
                     delete _module;
               }
   
               pegasus_module * _module;
               void *_parm;
       };       };
  
   
    public:    public:
  
  
Line 270 
Line 279 
  
       ~ModuleController(void);       ~ModuleController(void);
  
       static ModuleController & get_client_handle(const String & controller_name,  
                                                   void **handle);  
  
  
       // module api       // module api
Line 282 
Line 290 
                                                 void (*async_callback)(Uint32, Message *, void *),                                                 void (*async_callback)(Uint32, Message *, void *),
                                                 void (*shutdown_notify)(Uint32, void *),                                                 void (*shutdown_notify)(Uint32, void *),
                                                 pegasus_module **instance = NULL)                                                 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);          throw(Permission);
  
       Uint32 find_service(pegasus_module & handle, const String & name) throw(Permission);        Uint32 find_service(const pegasus_module & handle, const String & name) throw(Permission);
  
       Uint32 find_module_in_service(pegasus_module & handle,        Uint32 find_module_in_service(const pegasus_module & handle,
                                     const String & module_name)                                     const String & module_name)
          throw(Permission, IPCException);          throw(Permission, IPCException);
  
  
       pegasus_module * get_module_reference(pegasus_module & my_handle,        pegasus_module * get_module_reference(const pegasus_module & my_handle,
                                             const String & module_name)                                             const String & module_name)
          throw(Permission);          throw(Permission);
  
       // send a message to another service       // send a message to another service
       AsyncReply *ModuleSendWait(pegasus_module & handle,        AsyncReply *ModuleSendWait(const pegasus_module & handle,
                               Uint32 destination_q,                               Uint32 destination_q,
                               AsyncRequest *request) throw(Permission, IPCException);                               AsyncRequest *request) throw(Permission, IPCException);
  
       // send a message to another module via another service       // send a message to another module via another service
       AsyncReply *ModuleSendWait(pegasus_module & handle,        AsyncReply *ModuleSendWait(const pegasus_module & handle,
                               Uint32 destination_q,                               Uint32 destination_q,
                               String & destination_module,                                   const String & destination_module,
                               AsyncRequest *message) throw(Permission, Deadlock, IPCException);                               AsyncRequest *message) throw(Permission, Deadlock, IPCException);
  
       // send an async message to another service       // send an async message to another service
       Boolean ModuleSendAsync(pegasus_module & handle,        Boolean ModuleSendAsync(const pegasus_module & handle,
                               Uint32 msg_handle,                               Uint32 msg_handle,
                               Uint32 destination_q,                               Uint32 destination_q,
                               AsyncRequest *message) throw(Permission, IPCException);                                AsyncRequest *message,
                                 void *callback_parm) throw(Permission, IPCException);
  
       // send an async message to another module via another service       // send an async message to another module via another service
       Boolean ModuleSendAsync(pegasus_module & handle,        Boolean ModuleSendAsync(const pegasus_module & handle,
                               Uint32 msg_handle,                               Uint32 msg_handle,
                               Uint32 destination_q,                               Uint32 destination_q,
                               String & destination_module,                                const String & destination_module,
                               AsyncRequest *message) throw(Permission, IPCException);                                AsyncRequest *message,
                                 void *callback_parm) throw(Permission, IPCException);
  
       void blocking_thread_exec(pegasus_module & handle,        Boolean ModuleSendForget(const pegasus_module & handle,
                                  Uint32 destination_q,
                                  AsyncRequest *message)
            throw(Permission, IPCException);
   
         Boolean ModuleSendForget(const pegasus_module & handle,
                                  Uint32 destination_q,
                                  const String & destination_module,
                                  AsyncRequest *message)
            throw(Permission, IPCException);
   
         void blocking_thread_exec(const 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);
       void async_thread_exec(pegasus_module & handle,        void async_thread_exec(const 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 *);
   
         static ModuleController & get_client_handle(const pegasus_identity & id,
                                                     client_handle **handle)
            throw(IncompatibleTypes);
   
         static ModuleController & get_client_handle(char *controller,
                                                     const pegasus_identity & id,
                                                     client_handle **handle)
            throw(IncompatibleTypes);
   
   
         void return_client_handle(client_handle *handle);
   
         // send a message to another service
         AsyncReply *ClientSendWait(const client_handle & handle,
                                    Uint32 destination_q,
                                    AsyncRequest *request)
            throw(Permission, IPCException);
   
         // send a message to another module via another service
         AsyncReply *ClientSendWait(const client_handle & handle,
                                    Uint32 destination_q,
                                    String & destination_module,
                                    AsyncRequest *message)
            throw(Permission, Deadlock, IPCException);
   
         // send an async message to another service
         Boolean ClientSendAsync(const client_handle & handle,
                                 Uint32 msg_handle,
                                 Uint32 destination_q,
                                 AsyncRequest *message,
                                 void (*async_callback)(Uint32, Message *, void *) ,
                                 void *callback_parm)
            throw(Permission, IPCException);
   
         // send an async message to another module via another service
         Boolean ClientSendAsync(const client_handle & handle,
                                 Uint32 msg_handle,
                                 Uint32 destination_q,
                                 const String & destination_module,
                                 AsyncRequest *message,
                                 void (*async_callback)(Uint32, Message *, void *),
                                 void *callback_parm )
            throw(Permission, IPCException);
   
         Boolean ClientSendForget(const client_handle & handle,
                                  Uint32 destination_q,
                                  AsyncRequest *message)
            throw(Permission, IPCException);
   
         Boolean ClientSendForget(const client_handle & handle,
                                  Uint32 destination_q,
                                  const String & destination_module,
                                  AsyncRequest *message)
            throw(Permission, IPCException);
   
         void client_blocking_thread_exec(const client_handle & handle,
                                          PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),
                                          void *parm)
            throw(Permission, Deadlock, IPCException);
         void client_async_thread_exec(const client_handle & handle,
                                       PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),
                                       void *parm)
            throw(Permission, Deadlock, IPCException);
   
    protected:    protected:
       // ATTN-RK-P2-20010322:  These methods are pure virtual in superclass       // ATTN-RK-P2-20010322:  These methods are pure virtual in superclass
       virtual void handleEnqueue(void) {}       virtual void handleEnqueue(void) {}
Line 337 
Line 424 
       virtual void _handle_async_request(AsyncRequest *rq);       virtual void _handle_async_request(AsyncRequest *rq);
       virtual void _handle_async_callback(AsyncOpNode *op);       virtual void _handle_async_callback(AsyncOpNode *op);
  
   
   
   
    private:    private:
       static void _async_handleEnqueue(AsyncOpNode *h, MessageQueue *q, void *parm);       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_module _internal_module;
         AsyncReply *_send_wait(Uint32, AsyncRequest *);
         AsyncReply *_send_wait(Uint32, const String &, AsyncRequest *);
         Boolean _send_forget(Uint32, AsyncRequest *) throw(IPCException);
         Boolean _send_forget(Uint32, const String &, AsyncRequest *) throw(IPCException);
   
         void _blocking_thread_exec(
            PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),
            void *parm) ;
         void _async_thread_exec(
            PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),
            void *parm) ;
 }; };
  
  

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