version 1.3, 2002/03/19 21:03:37
|
version 1.34.2.2, 2002/10/28 15:43:24
|
|
|
//%////-*-c++-*-//////////////////////////////////////////////////////////////// |
//%///////////-*-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 |
|
|
#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> |
|
|
#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> |
|
#include <Pegasus/Common/Linkage.h> |
|
|
|
|
PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
| |
class ModuleController; | class ModuleController; |
|
|
| |
class PEGASUS_COMMON_LINKAGE pegasus_module | class PEGASUS_COMMON_LINKAGE pegasus_module |
{ | { |
class module_rep; |
private: |
|
class module_rep : public pegasus_auth_handle |
|
{ |
public: | public: |
|
typedef pegasus_auth_handle Base; |
| |
pegasus_module(ModuleController *controller, |
module_rep(ModuleController *controller, |
const String &id, |
const String & 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 code, void *)); |
| |
} |
~module_rep(void) ; |
| |
pegasus_module(const pegasus_module & mod) |
Boolean operator == (const module_rep *rep) const |
{ |
{ if (rep == this ) return true; return false; } |
(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 == (void *rep) const |
|
{ if ( (void *)this == rep ) return true; return false; } |
| |
pegasus_module & pegasus_module::operator= (const pegasus_module & mod) |
void reference(void) { _reference_count++; } |
{ |
void dereference(void) { _reference_count--; } |
(mod._rep->_reference_count)++; |
Uint32 reference_count(void) { return _reference_count.value(); } |
if ( ((rep->_reference_count)--) == 0 ) |
const String & get_name(void) const { return _name; } |
delete rep; |
void *get_module_address(void) const { return _module_address; } |
_rep = mod._rep; |
|
return *this; |
|
} |
|
| |
|
Message * module_receive_message(Message *msg); |
| |
Boolean operator == (const pegasus_module *mod) const |
void _send_async_callback(Uint32 msg_handle, Message *msg, void *parm); |
{ |
|
if(mod->_rep == _rep) |
|
return true; |
|
return false; |
|
} |
|
| |
Boolean operator == (const String & mod) const |
void _send_shutdown_notify(void); |
{ |
void lock(void) { _thread_safety.lock(pegasus_thread_self()); } |
if(_rep->_name == mod) |
void unlock(void) { _thread_safety.unlock(); } |
return true; |
|
return false; |
|
} |
|
| |
Boolean operator == (const pegasus_module & mod) const |
Boolean authorized(void) ; |
{ |
Boolean authorized(Uint32); |
if( mod._rep == _rep ) |
Boolean authorized(Uint32, Uint32); |
return true; |
|
return false; |
|
| |
} |
private: |
|
module_rep(void); |
|
module_rep(const module_rep & ); |
|
module_rep & operator= (const module_rep & rep); |
| |
Boolean operator == (const void *mod) const |
|
{ |
|
if ( (reinterpret_cast<pegasus_module *>(mod))->_rep == _rep) |
|
return true; |
|
return false; |
|
} |
|
| |
const String & get_name(void); |
Mutex _thread_safety; |
|
ModuleController *_controller; |
|
String _name; |
|
AtomicInt _reference_count; |
|
AtomicInt _shutting_down; |
|
|
|
void *_module_address; |
|
Message * (*_receive_message)(Message *, void *); |
|
void (*_async_callback)(Uint32, Message *, void *); |
|
void (*_shutdown_notify)(Uint32 code, void *); |
|
|
|
static Message * default_receive_message(Message *msg, void *inst) |
|
{ throw NotImplemented("Module Receive"); return 0; } |
|
|
|
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(); return 0; } |
|
|
|
static void closed_async_callback(Uint32 handle, Message *msg, void *inst) |
|
{ throw ModuleClosed(); } |
|
|
|
friend class ModuleController; |
|
}; |
|
|
|
public: |
|
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(const pegasus_module & mod); |
|
pegasus_module & operator= (const pegasus_module & mod); |
|
|
|
virtual ~pegasus_module(void); |
|
|
|
virtual Boolean authorized(Uint32 operation); |
|
virtual Boolean authorized(void); |
|
|
|
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; |
{ |
void _send_async_callback(Uint32 msg_handle, Message *msg) ; |
} |
|
|
virtual Boolean _shutdown(Uint32) = 0; |
|
| |
virtual Uint32 reference(void) { _reference_count++; } |
Boolean _rcv_msg(Message *) ; |
virtual Uint32 dereference(void) { _reference_count--; } |
Message * _receive_message(Message *msg); |
|
void _send_async_callback(Uint32 msg_handle, Message *msg, void *) ; |
|
void _send_shutdown_notify(void); |
|
Boolean _shutdown(void); |
|
PEGASUS_STD(bitset<32>) _allowed_operations; |
| |
|
void reference(void) { _rep->reference(); } |
|
void dereference(void) { _rep->dereference(); } |
friend class ModuleController; | friend class ModuleController; |
}; | }; |
| |
| |
class PEGASUS_COMMON_LINKAGE pegasus_module::module_rep |
class PEGASUS_COMMON_LINKAGE ModuleController : public MessageQueueService |
{ | { |
|
|
|
|
public: | public: |
module_rep(ModuleController *controller, |
typedef MessageQueueService Base; |
const String & name, |
|
void *module_address, |
static const Uint32 GET_CLIENT_HANDLE; |
void (*async_callback)(Uint32, Message *)) |
static const Uint32 REGISTER_MODULE; |
: _controller(controller), |
static const Uint32 DEREGISTER_MODULE; |
_name(name), |
static const Uint32 FIND_SERVICE; |
_reference_count(1), |
static const Uint32 FIND_MODULE_IN_SERVICE; |
_module_address(module_address), |
static const Uint32 GET_MODULE_REFERENCE; |
_async_callback(async_callback) |
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; |
|
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: |
|
class client_handle : public pegasus_auth_handle |
{ | { |
|
public: |
|
typedef pegasus_auth_handle Base; |
| |
|
client_handle(const pegasus_identity & id) |
|
:Base(id) , |
|
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), |
|
reference_count(1) |
|
{ |
} | } |
| |
virtual ~module_rep(void) |
~client_handle(void) |
{ | { |
|
|
} | } |
| |
Boolean operator == (const module_rep *rep) const |
client_handle & operator=(const client_handle & handle) |
{ | { |
if (rep == this ) |
if(this == &handle) |
return true; |
return *this; |
return false; |
reference_count++; |
|
return *this; |
} | } |
| |
Boolean operator == (const module_rep &rep) const |
|
|
virtual Boolean authorized(Uint32, Uint32); |
|
virtual Boolean authorized(Uint32 operation); |
|
virtual Boolean authorized(void); |
|
PEGASUS_STD(bitset<32>) allowed_operations; |
|
AtomicInt reference_count; |
|
|
|
}; |
|
|
|
class callback_handle |
|
{ |
|
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) |
|
: _module(module), _parm(parm) |
{ | { |
if (rep == *this) |
|
return true; |
|
return false; |
|
} | } |
| |
Boolean operator == (void *rep) const |
~callback_handle() |
{ | { |
if ( (void *)this == rep ) |
if( _module->get_name() == String(PEGASUS_MODULENAME_TEMP) ) |
return true; |
delete _module; |
return false; |
|
} | } |
| |
|
pegasus_module * _module; |
|
void *_parm; |
|
}; |
| |
private: |
|
module_rep(void); |
|
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); */ |
|
|
|
|
|
~ModuleController(void); |
| |
class PEGASUS_COMMON_LINKAGE ModuleController : public MessageQueueService |
|
{ |
|
| |
public: |
|
typedef MesageQueueService Base; |
|
| |
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); |
| |
deregister_module(const String & module_name); |
Boolean deregister_module(const String & module_name) |
|
throw(Permission); |
| |
Uint32 find_service(pegasus_module & handle, String & name); |
Uint32 find_service(const pegasus_module & handle, const String & name) throw(Permission); |
String & find_service(pegasus_module & handle, Uint32 queue_id); |
|
| |
pegasus_module & get_module_reference(pegasus_module & handle, String & name); |
Uint32 find_module_in_service(const pegasus_module & handle, |
|
const String & module_name) |
|
throw(Permission, IPCException); |
|
|
|
|
|
pegasus_module * get_module_reference(const 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(const 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(const pegasus_module & handle, |
Uint32 destination_q, | Uint32 destination_q, |
String & destination_module, |
const 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(const pegasus_module & handle, |
Uint32 msg_handle, | Uint32 msg_handle, |
Uint32 destination_q, | Uint32 destination_q, |
Message *message); |
AsyncRequest *message, |
|
void *callback_parm) 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(const pegasus_module & handle, |
Uint32 msg_handle, | Uint32 msg_handle, |
Uint32 destination_q, | Uint32 destination_q, |
|
const String & destination_module, |
|
AsyncRequest *message, |
|
void *callback_parm) throw(Permission, IPCException); |
|
|
|
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 *), |
|
void *parm) throw(Permission, Deadlock, IPCException); |
|
void async_thread_exec(const pegasus_module & handle, |
|
PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *), |
|
void *parm) throw(Permission, Deadlock, IPCException); |
|
|
|
Boolean verify_handle(pegasus_module *); |
|
|
|
static ModuleController & get_client_handle(const pegasus_identity & id, |
|
client_handle **handle) |
|
throw(IncompatibleTypes); |
|
|
|
static ModuleController & get_client_handle(const 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, | String & destination_module, |
Message *message); |
AsyncRequest *message) |
|
throw(Permission, Deadlock, IPCException); |
| |
Uint32 blocking_thread_exec(pegasus_module & handle, |
// 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 *), | PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *thread_func)(void *), |
void *parm); |
void *parm) |
Uint32 async_thread_exec(pegasus_module & handle, |
throw(Permission, Deadlock, IPCException); |
|
void client_async_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) |
|
throw(Permission, Deadlock, IPCException); |
| |
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; |
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) ; |
}; | }; |
| |
| |
|
|
|
|
|
|
|
|
|
|
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |
| |
| |
#endif // Pegasus_Module_Controller_h |
#endif // Pegasus_Module_Controller_H |