(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.19 and 1.37

version 1.19, 2002/04/05 20:10:09 version 1.37, 2004/05/18 11:03:38
Line 1 
Line 1 
 //%////-*-c++-*-////////////////////////////////////////////////////////////////  //%2003////////////////////////////////////////////////////////////////////////
 // //
 // 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.
 // //
 // 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 22 
Line 25 
 // //
 // Author: Mike Day (mdday@us.ibm.com) <<< Wed Mar 13 20:49:40 2002 mdd >>> // Author: Mike Day (mdday@us.ibm.com) <<< Wed Mar 13 20:49:40 2002 mdd >>>
 // //
 // Modified By:  // Modified By: Amit K Arora, IBM (amita@in.ibm.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
Line 32 
Line 35 
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <Pegasus/Common/Constants.h> #include <Pegasus/Common/Constants.h>
 #include <Pegasus/Common/Message.h> #include <Pegasus/Common/Message.h>
 #include <Pegasus/Common/Exception.h>  #include <Pegasus/Common/InternalException.h>
 #include <Pegasus/Common/IPC.h> #include <Pegasus/Common/IPC.h>
 #include <Pegasus/Common/Thread.h> #include <Pegasus/Common/Thread.h>
 #include <Pegasus/Common/AsyncOpNode.h> #include <Pegasus/Common/AsyncOpNode.h>
Line 40 
Line 43 
 #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> #include <Pegasus/Common/peg_authorization.h>
   #include <Pegasus/Common/Linkage.h>
   #include <Pegasus/Common/AutoPtr.h>
  
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
Line 98 
Line 103 
  
  
             Mutex _thread_safety;             Mutex _thread_safety;
             ModuleController *_controller;              AutoPtr<ModuleController> _controller;//PEP101
             String _name;             String _name;
             AtomicInt _reference_count;             AtomicInt _reference_count;
             AtomicInt _shutting_down;             AtomicInt _shutting_down;
Line 109 
Line 114 
             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 118 
Line 123 
             { 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 154 
Line 159 
  
    private:    private:
  
       module_rep *_rep;        AutoPtr<module_rep> _rep;//PEP101
  
       pegasus_module(void)       pegasus_module(void)
       {       {
Line 165 
Line 170 
       void _send_async_callback(Uint32 msg_handle, Message *msg, void *) ;       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 198 
Line 203 
       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 : public pegasus_auth_handle       class client_handle : public pegasus_auth_handle
       {       {
          public:          public:
Line 217 
Line 228 
                                     CLIENT_SEND_ASYNC |                                     CLIENT_SEND_ASYNC |
                                     CLIENT_SEND_ASYNC_MODULE |                                     CLIENT_SEND_ASYNC_MODULE |
                                     CLIENT_BLOCKING_THREAD_EXEC |                                     CLIENT_BLOCKING_THREAD_EXEC |
                                     CLIENT_ASYNC_THREAD_EXEC)                                      CLIENT_ASYNC_THREAD_EXEC),
                   reference_count(1)
             {             {
   
             }             }
  
             ~client_handle(void)             ~client_handle(void)
             {             {
             }             }
  
               client_handle & operator=(const client_handle & handle)
               {
                  if(this == &handle)
                     return *this;
                  reference_count++;
                  return *this;
               }
   
   
             virtual Boolean authorized(Uint32, Uint32);             virtual Boolean authorized(Uint32, Uint32);
             virtual Boolean authorized(Uint32 operation);             virtual Boolean authorized(Uint32 operation);
             virtual Boolean authorized(void);             virtual Boolean authorized(void);
             bitset<32> allowed_operations;              PEGASUS_STD(bitset<32>) allowed_operations;
               AtomicInt reference_count;
  
       };       };
  
       class callback_handle       class callback_handle
       {       {
          public:          public:
               static void * operator new(size_t );
               static void operator delete(void *, size_t);
            private:
               static callback_handle *_head;
               static const int BLOCK_SIZE;
               static Mutex _alloc_mut;
   
            public:
             callback_handle(pegasus_module * module, void *parm)             callback_handle(pegasus_module * module, void *parm)
                : _module(module), _parm(parm)                : _module(module), _parm(parm)
             {             {
Line 243 
Line 272 
  
             ~callback_handle()             ~callback_handle()
             {             {
                if( _module->get_name() == String(PEGASUS_CONTROL_TEMP_MODULE) )                 if( _module->get_name() == String(PEGASUS_MODULENAME_TEMP) )
                   delete _module;                   // delete _module;
                    _module.reset();
             }             }
  
             pegasus_module * _module;              AutoPtr<pegasus_module> _module;//PEP101
             void *_parm;             void *_parm;
       };       };
  
Line 256 
Line 286 
  
  
       ModuleController(const char *name);       ModuleController(const char *name);
       ModuleController(const char *name,  /*       ModuleController(const char *name,  */
                        Sint16 min_threads,  /*                     Sint16 min_threads,  */
                        Sint16 max_threads,  /*                     Sint16 max_threads, */
                        struct timeval & create_thread,  /*                     struct timeval & create_thread, */
                        struct timeval & destroy_thread,  /*                     struct timeval & destroy_thread, */
                        struct timeval & deadlock);  /*                     struct timeval & deadlock); */
  
  
       ~ModuleController(void);       ~ModuleController(void);
Line 278 
Line 308 
                                                 void (*shutdown_notify)(Uint32, void *),                                                 void (*shutdown_notify)(Uint32, void *),
                                                 pegasus_module **instance = NULL)                                                 pegasus_module **instance = NULL)
  
          throw(AlreadyExists, IncompatibleTypes);           throw(AlreadyExistsException, IncompatibleTypesException);
  
       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,                               AsyncRequest *message,
                               void *callback_parm) throw(Permission, IPCException);                               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,                               AsyncRequest *message,
                               void *callback_parm) throw(Permission, IPCException);                               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);
  
Line 331 
Line 372 
  
       static ModuleController & get_client_handle(const pegasus_identity & id,       static ModuleController & get_client_handle(const pegasus_identity & id,
                                                   client_handle **handle)                                                   client_handle **handle)
          throw(IncompatibleTypes);           throw(IncompatibleTypesException);
   
         static ModuleController & get_client_handle(const char *controller,
                                                     const pegasus_identity & id,
                                                     client_handle **handle)
            throw(IncompatibleTypesException);
   
  
       void return_client_handle(client_handle *handle);       void return_client_handle(client_handle *handle);
  
Line 361 
Line 408 
       Boolean ClientSendAsync(const client_handle & handle,       Boolean ClientSendAsync(const client_handle & handle,
                               Uint32 msg_handle,                               Uint32 msg_handle,
                               Uint32 destination_q,                               Uint32 destination_q,
                               String & destination_module,                                const String & destination_module,
                               AsyncRequest *message,                               AsyncRequest *message,
                               void (*async_callback)(Uint32, Message *, void *),                               void (*async_callback)(Uint32, Message *, void *),
                               void *callback_parm )                               void *callback_parm )
          throw(Permission, IPCException);          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,       void client_blocking_thread_exec(const client_handle & handle,
                                        PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),                                        PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),
                                        void *parm)                                        void *parm)
Line 383 
Line 441 
       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:
   
   
         class _module_lock
         {
            public:
               _module_lock(DQueue<pegasus_module> * list)
                  :_list(list)
               {
                  _list->lock();
  
               }
               ~_module_lock(void)
               {
                  _list->unlock();
               }
  
  
    private:    private:
               _module_lock();
               DQueue<pegasus_module> * _list;
         };
   
   
   
       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;  
       pegasus_module _internal_module;       pegasus_module _internal_module;
       AsyncReply *_send_wait(Uint32, AsyncRequest *);       AsyncReply *_send_wait(Uint32, AsyncRequest *);
       AsyncReply *_send_wait(Uint32, String &, 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(       void _blocking_thread_exec(
          PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),          PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),
          void *parm) ;          void *parm) ;
       void _async_thread_exec(       void _async_thread_exec(
          PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),          PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *),
          void *parm) ;          void *parm) ;
   
 }; };
  
  
Line 408 
Line 488 
  
  
  
   
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
  
  

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