version 1.23, 2002/04/22 22:42:17
|
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 |
|
|
#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> |
| |
| |
PEGASUS_NAMESPACE_BEGIN | PEGASUS_NAMESPACE_BEGIN |
|
|
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(); } |
|
|
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) |
{ | { |
|
|
| |
| |
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); |
|
|
client_handle **handle) | client_handle **handle) |
throw(IncompatibleTypes); | 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); | void return_client_handle(client_handle *handle); |
| |
// send a message to another service | // send a message to another service |
|
|
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 ) |
|
|
| |
Boolean ClientSendForget(const client_handle & handle, | Boolean ClientSendForget(const client_handle & handle, |
Uint32 destination_q, | Uint32 destination_q, |
String & destination_module, |
const String & destination_module, |
AsyncRequest *message) | AsyncRequest *message) |
throw(Permission, IPCException); | throw(Permission, IPCException); |
| |
|
|
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; |
|
pegasus_module _internal_module; | pegasus_module _internal_module; |
AsyncReply *_send_wait(Uint32, AsyncRequest *); | AsyncReply *_send_wait(Uint32, AsyncRequest *); |
AsyncReply *_send_wait(Uint32, const String &, AsyncRequest *); | AsyncReply *_send_wait(Uint32, const String &, AsyncRequest *); |