Grid Application Toolkit A simple API for Grid Applications

Menu Home API-Specification API-Overview Status C Reference Manual Download Java Java-Reference General GridLab - WP-1 Links

pipe.c Go to the documentation of this file. /** @file adaptor.c * Main file for the pipe adaptor. * * Test adaptor to check the GATPipe API. Provides a simple * file GATPipeCPI implementation. * * @date $Date: 2004/05/13 09:52:23 $ * * @version $Header: /export/cvs-gridlab/GridLabWeb/WorkPackages/wp-1/Doc/C-Reference/pipe_8c-source.html,v 1.6 2004/05/13 09:52:23 merzky Exp $ * * Copyright (C) Kelly Davis * This file is part of the GAT Engine. * Contributed by Kelly Davis <kdavis@aei.mpg.de>. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * The GNU C Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with the GNU C Library; if not, write to the Free * Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA * 02111-1307 USA. Copyright notice. */ static const char *rcsid = "$Header: /export/cvs-gridlab/GridLabWeb/WorkPackages/wp-1/Doc/C-Reference/pipe_8c-source.html,v 1.6 2004/05/13 09:52:23 merzky Exp $"; /* System Header Files */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #if !defined(WIN32) #include <arpa/inet.h> #endif #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> /* GAT Header Files */ #include <GATCPI.h> /* Adaptor Header Files */ #include "pipe.h" #include "Common.h" /* Macros */ #define __countof(x) (sizeof(x)/sizeof(x[0])) /* Structures, unions and enums */ /* Instance data */ /* Static function prototypes */ static void pipe_adaptor_PipeCPI_Destroy(void *data); /* instance specific functions */ GATResult pipe_adaptor_PipeCPI_CreateInstance(void *adaptor_data, GATPipeCPI_Instance *data, void *information); void pipe_adaptor_PipeCPI_DestroyInstance(void *adaptor_data, GATPipeCPI_Instance *data); GATResult pipe_adaptor_PipeCPI_CloneInstance(void *adaptor_data, GATPipeCPI_Instance const *data, GATPipeCPI_Instance *new_data); GATResult pipe_adaptor_PipeCPI_EqualsInstance(void *adaptor_data, GATPipeCPI_Instance const *lhs, GATPipeCPI_Instance const *rhs, GATBool *isequal); /* Streamable functions */ static GATResult pipe_adaptor_PipeCPI_Read(void *data, GATPipeCPI_Instance const *instance_data, void *buffer, GATuint32 size, GATuint32 *readBytes); static GATResult pipe_adaptor_PipeCPI_Write(void *data, GATPipeCPI_Instance const *instance_data, void const *buffer, GATuint32 size, GATuint32 *writtenBytes); static GATResult pipe_adaptor_PipeCPI_Seek(void *data, GATPipeCPI_Instance const *instance_data, GATOrigin origin, GATint32 offset, GATuint32 *new_position); static GATResult pipe_adaptor_PipeCPI_Close(void *data, GATPipeCPI_Instance const *instance_data); /* Execute a GATPipe get_metrics operation */ static GATResult pipe_adaptor_PipeCPI_GetMetrics(void *data, GATPipeCPI_Instance const *instance_data, GATList_GATMetric *metrics); /* Execute a GATPipe get_metric_event operation */ static GATResult pipe_adaptor_PipeCPI_GetMetricEvent(void *data, GATPipeCPI_Instance const *instance_data, GATMetric metric, GATMetricEvent *event); /* local helper functions */ static GATResult pipe_adaptor_PipeCPI_CreateServerInstance(void *adaptor_data, GATPipeCPI_Instance *data, int clientSocket); static GATResult pipe_adaptor_PipeCPI_CreateClientInstance(void *adaptor_data, GATPipeCPI_Instance *data, int clientSocket); static GATResult pipe_adaptor_FireReadEvent(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name); static GATResult pipe_adaptor_FireWriteEvent(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name); static GATResult pipe_adaptor_FireSeekEvent(GATMonitorable_Impl monitorable, GATObject_const source, char const *name); static GATResult pipe_adaptor_FireCloseEvent(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name); /* File scope variables */ static GATStaticMetric metric_data[] = { /* pipe.read event */ { "pipe.read", /* name */ GATMeasurementType_EventLike, /* type */ GATType_String, /* data type */ "", /* unit */ 0, /* parameter count */ 0 /* parameters */ }, /* pipe.write event */ { "pipe.write", /* name */ GATMeasurementType_EventLike, /* type */ GATType_String, /* data type */ "", /* unit */ 0, /* parameter count */ 0 /* parameters */ }, /* pipe.seek event */ { "pipe.seek", /* name */ GATMeasurementType_EventLike, /* type */ GATType_String, /* data type */ "", /* unit */ 0, /* parameter count */ 0 /* parameters */ }, /* pipe.close event */ { "pipe.close", /* name */ GATMeasurementType_EventLike, /* type */ GATType_String, /* data type */ "", /* unit */ 0, /* parameter count */ 0 /* parameters */ }, }; /* symbolic constants for the metric positions inside the metric_data array */ #define METRIC_PIPE_READ 0 #define METRIC_PIPE_WRITE 1 #define METRIC_PIPE_SEEK 2 #define METRIC_PIPE_CLOSE 3 /* External functions */ /** pipe_adaptor_register * Registers all CPIs this adaptor provides. * This function is invoked by the loader in the GATEngine when * an instance of this adaptor is loaded. Each instance has its * own private configuration table. * * For every CPI provided the adapter has to hand all the corresponding * function pointers to the engine to allow to be called back under certain * circumstances. Additionally the adaptor may allocate some private data for * every loaded instance. This data is handed back to the adaptor as the first * parameter to each of the subsequently called functions. * * @param registry The registry the adaptor should register its CPIs with. * @param system_config The system configuration table. * @param instance_config The configuration table for this instance. * @param token An arbitrary token used by the loader to identify this adaptor * instance * * @return An error code. */ GATResult pipe_adaptor_register_pipe(GATContext error_context, GATRegistry registry, GATTable_const system_config, GATTable_const instance_config, void *token) { GAT_USES_STATUS(error_context, "pipe_adaptor_register_pipe"); GATPipeCPI cpi = NULL; GATPipeCPI_Data cpidata; GAT_UNUSED_PARAMETER(system_config); GAT_UNUSED_PARAMETER(instance_config); memset(&cpidata, 0, sizeof(GATPipeCPI_Data)); /* * provide the appropriate callback functions */ /* adaptor instance data */ cpidata.data = NULL; cpidata.destroy = pipe_adaptor_PipeCPI_Destroy; /* Lifetime control and basic GATObject functionality support for every * object instance created by the client. */ cpidata.create_instance = pipe_adaptor_PipeCPI_CreateInstance; cpidata.destroy_instance = pipe_adaptor_PipeCPI_DestroyInstance; cpidata.clone_instance = pipe_adaptor_PipeCPI_CloneInstance; cpidata.equals_instance = pipe_adaptor_PipeCPI_EqualsInstance; /* streamable support */ cpidata.read = pipe_adaptor_PipeCPI_Read; cpidata.write = pipe_adaptor_PipeCPI_Write; cpidata.seek = pipe_adaptor_PipeCPI_Seek; cpidata.close = pipe_adaptor_PipeCPI_Close; /* monitoring support */ cpidata.get_metrics = pipe_adaptor_PipeCPI_GetMetrics; cpidata.get_metric_event = pipe_adaptor_PipeCPI_GetMetricEvent; /* Create a GATPipeCPI object. */ cpi = GATPipeCPI_Create(GATPIPECPI_VERSION, &cpidata); if(NULL != cpi) { /* Need to pass preferences to allow matching * of a user's preferences with what this adaptor does. */ GATPreferences preferences = GATPreferences_Create(); if(NULL != preferences) { /* at least the Name preference should be defined */ GAT_CREATE_STATUS(GATPreferences_Add(preferences, "Name", "pipe_adaptor")); GAT_CREATE_STATUS(GATPreferences_Add(preferences, "Security", "none")); GAT_CREATE_STATUS(GATPreferences_Add(preferences, "Local", "true")); GAT_CREATE_STATUS(GATRegistry_AddGATPipeCPI(registry, cpi, token, preferences)); GATPreferences_Destroy(&preferences); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } if (GAT_FAILED(GAT_CURRENT_STATUS())) { GATPipeCPI_Destroy(&cpi); } return GAT_RETURN_STATUS(); } /* Local functions */ /** pipe_adaptor_PipeCPI_Destroy * Destroy the adaptor-provided data object on GATPipeCPI destruction. * When the GATPipeCPI object created in this adaptor's _register * function is destroyed, this function is invoked to allow the * adaptor to cleanup. * * @param data Adaptor-provided data object. */ static void pipe_adaptor_PipeCPI_Destroy(void *data) { GAT_UNUSED_PARAMETER(data); } /** pipe_adaptor_PipeCPI_CreateInstance * Create a new CPI object instance. * Adaptor implementation of create instance capability. * * @param adaptor_data Adaptor-provided data object. * @param data The pointer to the data structure containing at least * the constructor provided data items and a member instance_data, which * may be used by the adaptor to store CPI instance specific data. * @param information Additional infor required * @return An error code. */ GATResult pipe_adaptor_PipeCPI_CreateInstance(void *adaptor_data, GATPipeCPI_Instance *data, void *information) { if (NULL != data) { GAT_USES_STATUS(data->context, "pipe_adaptor_PipeCPI_CreateInstance"); if (NULL != information) { GATPipeAdaptorInfo *gatPipeAdaptorInfo = (GATPipeAdaptorInfo *)information; if (GATTrue == gatPipeAdaptorInfo->isClientInfo) { GAT_CREATE_STATUS(pipe_adaptor_PipeCPI_CreateClientInstance( adaptor_data, data, gatPipeAdaptorInfo->clientSocket)); // gatPipeAdaptorInfo->serverNodename, // gatPipeAdaptorInfo->serverPort)); } else { GAT_CREATE_STATUS(pipe_adaptor_PipeCPI_CreateServerInstance( adaptor_data, data, gatPipeAdaptorInfo->clientSocket)); } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** pipe_adaptor_PipeCPI_CreateServerInstance * Create a new CPI object instance. * Adaptor implementation of create instance capability. * * @param adaptor_data Adaptor-provided data object. * @param data The pointer to the data structure containing at least * the constructor provided data items and a member instance_data, which * may be used by the adaptor to store CPI instance specific data. * @param clientSocket The client socket * @return An error code. */ static GATResult pipe_adaptor_PipeCPI_CreateServerInstance(void *adaptor_data, GATPipeCPI_Instance *data, int clientSocket) { GAT_UNUSED_PARAMETER(adaptor_data); if (NULL != data) { GAT_USES_STATUS(data->context, "pipe_adaptor_PipeCPI_CreateServerInstance"); int *newClientSocket = (int *) malloc(sizeof(int)); if (NULL != newClientSocket) { *newClientSocket = clientSocket; data->instance_data = (void *) newClientSocket; } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** pipe_adaptor_PipeCPI_CreateClientInstance * Create a new CPI object instance. * Adaptor implementation of create instance capability. * * @param adaptor_data Adaptor-provided data object. * @param data The pointer to the data structure containing at least * the constructor provided data items and a member instance_data, which * may be used by the adaptor to store CPI instance specific data. * @param serverNodename The server nodename * @param serverPort The server port * @return An error code. */ static GATResult pipe_adaptor_PipeCPI_CreateClientInstance(void *adaptor_data, GATPipeCPI_Instance *data, int clientSocket) { GAT_UNUSED_PARAMETER(adaptor_data); if (NULL != data) { GAT_USES_STATUS(data->context, "pipe_adaptor_PipeCPI_CreateClientInstance"); int *newClientSocket = (int *) malloc(sizeof(int)); if (NULL != newClientSocket) { *newClientSocket = clientSocket; data->instance_data = (void *) newClientSocket; } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } // GAT_UNUSED_PARAMETER(adaptor_data); // // if (NULL != data) // { // GAT_USES_STATUS(data->context, "pipe_adaptor_PipeCPI_CreateClientInstance"); // // if (NULL != serverNodename && 0 <= serverPort) // { // int *newClientSocket = (int *) malloc(sizeof(int)); // if (NULL != newClientSocket) // { // *newClientSocket = socket(AF_INET, SOCK_STREAM, 0); // if (0 <= *newClientSocket) // { // struct sockaddr_in serverAddress; // struct hostent *hostend = NULL; // // memset(&serverAddress, 0, sizeof(serverAddress)); // serverAddress.sin_family = AF_INET; // hostend = gethostbyname(serverNodename); // serverAddress.sin_addr = *((struct in_addr *)hostend->h_addr);; // serverAddress.sin_port = htons(serverPort); // // if (INADDR_NONE != serverAddress.sin_addr.s_addr) // { // int connectReturn; // // connectReturn = connect(*newClientSocket, // (struct sockaddr *) &serverAddress, sizeof(serverAddress)); // if (0 <= connectReturn) // { // data->instance_data = (void *) newClientSocket; // } // else // { // GAT_CREATE_STATUS(GAT_FAIL); // } // } // else // { // GAT_CREATE_STATUS(GAT_FAIL); // } // } // else // { // GAT_CREATE_STATUS(GAT_FAIL); // } // // if (GAT_FAILED(GAT_CURRENT_STATUS())) // { // close(*newClientSocket); // free(newClientSocket); // } // } // else // { // GAT_CREATE_STATUS(GAT_MEMORYFAILURE); // } // } // else // { // GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); // } // return GAT_RETURN_STATUS(); // } // return GAT_INVALID_HANDLE; //} /** pipe_adaptor_PipeCPI_DestroyInstance * Destroy a CPI object instance. * Adaptor implementation of destroy instance capability. * * @param data Adaptor-provided data object. * @param instance_data The instance data of the CPI object to destroy. */ void pipe_adaptor_PipeCPI_DestroyInstance(void *adaptor_data, GATPipeCPI_Instance *data) { GAT_UNUSED_PARAMETER(adaptor_data); if(NULL != data) { int *serverSocket = (int *)data->instance_data; if (0 != *serverSocket) { close(*serverSocket); *serverSocket = 0; } free(data->instance_data); } } /** pipe_adaptor_PipeCPI_CloneInstance * Clone a CPI object instance. * Adaptor implementation of the clone instance capability. * * @param data Adaptor-provided data object. * @param instance_data The instance data of this CPI object * @param new_instance_data The pointer to the variable, where the instance * data of the cloned CPI object is to be returned to. * * @return An error code. */ GATResult pipe_adaptor_PipeCPI_CloneInstance(void *adaptor_data, GATPipeCPI_Instance const *instance_data, GATPipeCPI_Instance *new_instance_data) { GAT_UNUSED_PARAMETER(adaptor_data); if (NULL != instance_data) { GAT_USES_STATUS(instance_data->context, "pipe_adaptor_PipeCPI_CloneInstance"); if (NULL != new_instance_data) { new_instance_data->instance_data = malloc(sizeof(int)); if (NULL != new_instance_data->instance_data) { int *client_socket = (int *)instance_data->instance_data; int *new_client_socket = (int *)new_instance_data->instance_data; *new_client_socket = *client_socket; } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** pipe_adaptor_PipeCPI_EqualsInstance * Clone a CPI object instance. * Adaptor implementation of the clone instance capability. * * @param data Adaptor-provided data object. * @param lhs The instance data of the left CPI object. * @param lhs The instance data of the right CPI object. * @param isequal The pointer to the variable, where the result is to be * returned to. * * @return An error code. */ GATResult pipe_adaptor_PipeCPI_EqualsInstance(void *data, GATPipeCPI_Instance const *lhs, GATPipeCPI_Instance const *rhs, GATBool *isequal) { GATResult retval = GAT_INVALID_HANDLE; GAT_UNUSED_PARAMETER(data); if ( (NULL != lhs) && (NULL != rhs) && (NULL != isequal) ) { *isequal = GATFalse; retval = GAT_SUCCESS; if( lhs == rhs ) { *isequal = GATTrue; retval = GAT_SUCCESS; } } return retval; } /* Streamable support !!! */ /** pipe_adaptor_PipeCPI_Read * Reads data from a Pipe. * Adaptor implementation of Pipe read capability. * * @param data Adaptor-provided data object. * @param instance_data The instance data of this CPI object * @param buffer The buffer into which data is read * @param size The size of the buffer * @param readBytes the number of bytes read * @return An error code. */ static GATResult pipe_adaptor_PipeCPI_Read(void *data, GATPipeCPI_Instance const *instance_data, void *buffer, GATuint32 size, GATuint32 *readBytes) { GAT_UNUSED_PARAMETER(data); if (NULL != instance_data) { GAT_USES_STATUS(instance_data->context, "pipe_adaptor_PipeCPI_Read"); if (NULL != buffer && NULL != readBytes) { int *localSocket = (int *) instance_data->instance_data; int localReadBytes = recv (*localSocket, buffer, (size_t) size, 0); if (-1 != localReadBytes) { GAT_CREATE_STATUS(pipe_adaptor_FireReadEvent( instance_data->context, instance_data->monitorable, instance_data->source, "read")); } *readBytes = (GATuint32) localReadBytes; } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** pipe_adaptor_PipeCPI_Write * Writes data to a Pipe. * Adaptor implementation of Pipe write capability. * * @param data Adaptor-provided data object. * @param instance_data The instance data of this CPI object * @param buffer The buffer from which data is written * @param size The size of the buffer * @param writtenBytes the number of bytes written * @return An error code. */ static GATResult pipe_adaptor_PipeCPI_Write(void *data, GATPipeCPI_Instance const *instance_data, void const *buffer, GATuint32 size, GATuint32 *writtenBytes) { GAT_UNUSED_PARAMETER(data); if (NULL != instance_data) { GAT_USES_STATUS(instance_data->context, ""); if (NULL != buffer && NULL != writtenBytes) { int *localSocket = (int *) instance_data->instance_data; int localWrittenBytes = send(*localSocket, buffer, (size_t)size, 0); if (-1 != localWrittenBytes) { GAT_CREATE_STATUS(pipe_adaptor_FireWriteEvent( instance_data->context, instance_data->monitorable, instance_data->source, "write")); } *writtenBytes = (GATuint32) localWrittenBytes; } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** pipe_adaptor_PipeCPI_Seek * Seeks on a Pipe. * Adaptor implementation of Pipe seek capability. * * @param data Adaptor-provided data object. * @param instance_data The instance data of this CPI object * @param origin The GATOrigin from whence to seek * @param offset The offset from the origin which to seek to * @param new_position The new position of the Pipe * @return An error code. */ static GATResult pipe_adaptor_PipeCPI_Seek(void *data, GATPipeCPI_Instance const *instance_data, GATOrigin origin, GATint32 offset, GATuint32 *new_position) { GAT_UNUSED_PARAMETER(data); GAT_UNUSED_PARAMETER(origin); GAT_UNUSED_PARAMETER(offset); GAT_UNUSED_PARAMETER(new_position); pipe_adaptor_FireSeekEvent( instance_data->monitorable, instance_data->source, "seek" ); return GAT_NOTIMPL; } /** pipe_adaptor_PipeCPI_Close * Closes a Pipe * Adaptor implementation of Pipe close capability. * * @param data Adaptor-provided data object. * @param instance_data The instance data of this CPI object * @return An error code. */ static GATResult pipe_adaptor_PipeCPI_Close(void *data, GATPipeCPI_Instance const *instance_data) { GAT_UNUSED_PARAMETER(data); if (NULL != instance_data) { GAT_USES_STATUS(instance_data->context, "pipe_adaptor_PipeCPI_Close"); int *localSocket = (int *) instance_data->instance_data; if (NULL != instance_data->instance_data) { close(*localSocket); *localSocket = 0; GAT_CREATE_STATUS(pipe_adaptor_FireCloseEvent(instance_data->context, instance_data->monitorable, instance_data->source, "close")); } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /* Monitoring support */ /** pipe_adaptor_PipeCPI_GetMetrics * * The function pipe_adaptor_PipeCPI_GetMetrics should return a * list of GATMetric objects supported by this adaptor. I.e. the adaptor is * capable to fire GATMetricEvents for the returned metrics. This list should * include all the supported metrics, event like and continuous ones. * * @param data Adaptor-provided data object. * @param instance_data Instance data for the CPI provider object. * @param metrics The pointer to the variable, which receives the returned * list of metrics. * * @return An error code. */ static GATResult pipe_adaptor_PipeCPI_GetMetrics(void *data, GATPipeCPI_Instance const *instance_data, GATList_GATMetric *metrics) { GAT_UNUSED_PARAMETER(data); GAT_UNUSED_PARAMETER(instance_data); return GATMetric_CreateListOfMetrics(metric_data, __countof(metric_data), metrics); } /** pipe_adaptor_PipeCPI_GetMetricEvent * * The function pipe_adaptor_PipeCPI_GetMetricEvent should * return the GATMetricEvent associated with the given continuous metric. This * function gets called for continuous metrics only, since returning the * metric event object to the caller is th only way for the client to get * access to it. * * @param data Adaptor-provided data object. * @param instance_data Instance data for the CPI provider object. * @param metric The metric instance describing the metric event to return. * This metric should be equivalent to one of the metrics returned by * our own GetMetrics CPI function (see above). If this is another * (not known to us metric), an error should be returned. * @param event The pointer to the variable, which receives the metric event * to return. * * @return An error code. */ static GATResult pipe_adaptor_PipeCPI_GetMetricEvent(void *data, GATPipeCPI_Instance const *instance_data, GATMetric metric, GATMetricEvent *event) { /* this adaptor supports no continuous metrics */ GAT_UNUSED_PARAMETER(data); GAT_UNUSED_PARAMETER(instance_data); GAT_UNUSED_PARAMETER(metric); GAT_UNUSED_PARAMETER(event); return GAT_SUCCESS; } /** pipe_adaptor_FireReadEvent * * The function pipe_adaptor_FireReadEvent fires a * 'pipe read' event to all registered metric listeners. */ static GATResult pipe_adaptor_FireReadEvent(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name) { GAT_USES_STATUS(context, "pipe_adaptor_FireReadEvent"); if (NULL != monitorable && NULL != source && NULL != name) { GATMetric metric = NULL; GAT_CREATE_STATUS(GATMetric_CreateMetric(&metric_data[METRIC_PIPE_READ], &metric)); if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { GATMetricEvent event = GATMetricEvent_Create_EventLike(source, metric, (void *)name, (GATuint32)(strlen(name) + 1)); if (NULL != event) { GAT_CREATE_STATUS(GATMonitorable_Impl_FireEvent(monitorable, metric, event)); GATMetricEvent_Destroy(&event); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } GATMetric_Destroy(&metric); } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } /** pipe_adaptor_FireWriteEvent * * The function pipe_adaptor_FireWriteEvent fires a * 'pipe write' event to all registered metric listeners. */ static GATResult pipe_adaptor_FireWriteEvent(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name) { GAT_USES_STATUS(context, "pipe_adaptor_FireWriteEvent"); if (NULL != monitorable && NULL != source && NULL != name) { GATMetric metric = NULL; GAT_CREATE_STATUS(GATMetric_CreateMetric(&metric_data[METRIC_PIPE_WRITE], &metric)); if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { GATMetricEvent event = GATMetricEvent_Create_EventLike(source, metric, (void *)name, (GATuint32)(strlen(name) + 1)); if (NULL != event) { GAT_CREATE_STATUS(GATMonitorable_Impl_FireEvent(monitorable, metric, event)); GATMetricEvent_Destroy(&event); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } GATMetric_Destroy(&metric); } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } /** pipe_adaptor_FireSeekEvent * * The function pipe_adaptor_FireSeekEvent fires a * 'pipe seek' event to all registered metric listeners. */ static GATResult pipe_adaptor_FireSeekEvent(GATMonitorable_Impl monitorable, GATObject_const source, char const *name) { GATResult retval = GAT_INVALID_PARAMETER; if (NULL != monitorable && NULL != source && NULL != name) { GATMetric metric = NULL; retval = GATMetric_CreateMetric(&metric_data[METRIC_PIPE_SEEK], &metric); if (GAT_SUCCESS == retval) { GATMetricEvent event = GATMetricEvent_Create_EventLike(source, metric, (void *)name, (GATuint32)(strlen(name) + 1)); if (NULL != event) { retval = GATMonitorable_Impl_FireEvent(monitorable, metric, event); } else { retval = GAT_MEMORYFAILURE; } GATMetricEvent_Destroy(&event); GATMetric_Destroy(&metric); } } return retval; } /** pipe_adaptor_FireCloseEvent * * The function pipe_adaptor_FireCloseEvent fires a * 'pipe close' event to all registered metric listeners. */ static GATResult pipe_adaptor_FireCloseEvent(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name) { GAT_USES_STATUS(context, "pipe_adaptor_FireCloseEvent"); if (NULL != monitorable && NULL != source && NULL != name) { GATMetric metric = NULL; GAT_CREATE_STATUS(GATMetric_CreateMetric(&metric_data[METRIC_PIPE_CLOSE], &metric)); if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { GATMetricEvent event = GATMetricEvent_Create_EventLike(source, metric, (void *)name, (GATuint32)(strlen(name) + 1)); if (NULL != event) { GAT_CREATE_STATUS(GATMonitorable_Impl_FireEvent(monitorable, metric, event)); GATMetricEvent_Destroy(&event); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } GATMetric_Destroy(&metric); } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); }