class CAVERNnet_perfDaemon_c

CAVERN performance monitoring daemon class

Public Methods

CAVERNnet_perfDaemon_c (FILE* File = NULL)
Constructor of performance monitoring daemon class
int init (int incomingPort=PERF_DAEMON_DEFAULT_PORT, int maxClients = 64)
Initialize the reflector
int process ()
Call this within a while loop to let the reflector continuously do its processing
int checkForNewClients ()
Call this as often as you wish to check for new clients
void intercept (int (*callback) (CAVERNnet_perfDaemonClient_c *client, char** buffer, int *bufferSize, void *userData), void* userData)
Intercept incoming messages and call a user-defined callback function
void interceptNewConnection (void (*callback) (CAVERNnet_perfDaemonClient_c *newClient, void* userData), void *userData)
Intercept any new connections that are formed

Public


static const int OK
Status ok.
static const int FAILED
Status failed.
static const int MEM_ALLOC_ERR
Memory allocation error.
static const int NEW_CONNECTION_ESTABLISHED
New client has been connected.
static const int TOO_MANY_CLIENTS
Reflector cannot handle any more connections
static const int NO_NEW_CONNECTION
No new connection.
static const int NON_BLOCKING_HAS_NO_DATA
A non-blocking read had no data available to read.
static const int SKIP_DISTRIBUTION
Skip the data distribution process. Used in user callback. See intercept().

Documentation

CAVERN performance monitoring daemon class. This class treats TCP streams as discrete packets/messages that can be reflected to multiple connected performance monitoring clients. Clients must be created using CAVERNnet_perfDaemonClient_c. Hence do NOT attempt to use CAVERNnet_tcpClient_c to connect to a perf daemon class. This class has 2 main functions: checkForNewClients() and process(). checkForNewClients, as the name suggests, checks to see if any new clients wish to connect to the reflector. Process() does the actual work of data reflection.

checkForNewClients is called everytime process() is called. If you want the check to be done more frequently you need to do it yourself. Similarly if you want the process() call done more frequently it is up to you to do it. I recommend threading those two off and setting up a mutex so that you do not do process() and checkForNewClients() at the same time.

CAVERNnet_perfDaemon_c(FILE* File = NULL)
Constructor of performance monitoring daemon class.

Parameters:
File - Optional parameter. If file pointer is given here, it will be used to save all log information.
int init(int incomingPort=PERF_DAEMON_DEFAULT_PORT, int maxClients = 64)
Initialize the reflector
Returns:
Either CAVERNnet_perfDaemon_c::OK,FAILED,MEM_ALLOC_ERR.
Parameters:
incomingPort - is listening port for incoming connections. Default is 7000.
maxClients - is the max number of clients the reflector will manage.

int process()
Call this within a while loop to let the reflector continuously do its processing
Returns:
Either CAVERNnet_perfDaemon_c::OK,MEM_ALLOC_ERR

int checkForNewClients()
Call this as often as you wish to check for new clients. Note. If you do this in a separate thread then you must set up a mutex so that you do not call the proces() call and this call at the same time. The process() call itself has imbedded in it 1 check for each time you call it.
Returns:
Either CAVERNnet_perfDaemon_c::NEW_CONNECTION_ESTABLISHED, NO_NEW_CONNECTION, TOO_MANY_CLIENTS.

void intercept(int (*callback) (CAVERNnet_perfDaemonClient_c *client, char** buffer, int *bufferSize, void *userData), void* userData)
Intercept incoming messages and call a user-defined callback function. If you want you can also alter the buffer completely so that the reflector will reflect an entirely different message. You can do this by changing the contents of the buffer or by replacing the buffer entirely by allocating memory for a new buffer and stuffing it with your own data. If you choose to allocate a totally new buffer you must remember to deallocate memory for the original buffer before substituting it with yours.

If after your callback function exits you do not wish the reflector to forward the contents of the buffer, return with CAVERN_tcpReflector_c::SKIP_DISTRIBUTION. Otherwise just return CAVERN_tcpReflector_c::OK.

Note also that the callback function will also be given a pointer to a CAVERNnet_perfDaemonClient_c object that can then be used to send data directly to the client that originally sent the message.

void interceptNewConnection(void (*callback) (CAVERNnet_perfDaemonClient_c *newClient, void* userData), void *userData)
Intercept any new connections that are formed. This allows you to send private data to the newly formed connection before it assumes its data reflection duties. Callback function will be given a pointer to the CAVERNnet_perfDaemonClient_c object that can then be used to send data directly to the client.

This class has no child classes.
Author:
cavern@evl.uic.edu
Version:
3/28/2000

alphabetic index hierarchy of classes

this page has been generated automatically by doc++

(c)opyright by Malte Zöckler, Roland Wunderling
contact: doc++@zib.de