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

adaptor.c Go to the documentation of this file. /** @file adaptor.c * Main file for the filestream adaptor. * * Test adaptor to check the GATFileStream API. Provides a simple * file GATFileStreamCPI implementation. * * @date $Date: 2004/04/22 10:25:05 $ * * @version $Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/adaptors/filestream/adaptor.c,v 1.6 2004/04/22 10:25:05 hartmutkaiser Exp $ * * Copyright (C) Kelly Davis * This file is part of the GAT Engine. * Contributed by Kelly Davis <kdavis@aei.mpg.de>. * * Use, modification and distribution is subject to the Gridlab Software * License. (See accompanying file GLlicense.txt or copy at * http://www.gridlab.org/GLlicense.txt) */ static const char *rcsid = "$Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/adaptors/filestream/adaptor.c,v 1.6 2004/04/22 10:25:05 hartmutkaiser Exp $"; /* System Header Files */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h> /* GAT Header Files */ #include <GATCPI.h> /* Macros */ #define __countof(x) (sizeof(x)/sizeof(x[0])) /* Structures, unions and enums */ /* Instance data -- not used */ typedef struct GATFileStreamInstance_Data { FILE *file; } GATFileStreamInstance_Data; /* Static function prototypes */ static void filestream_adaptor_FileStreamCPI_Destroy(void *data); /* instance specific functions */ GATResult filestream_adaptor_FileStreamCPI_CreateInstance(void *adaptor_data, GATFileStreamCPI_Instance *data); void filestream_adaptor_FileStreamCPI_DestroyInstance(void *adaptor_data, GATFileStreamCPI_Instance *data); GATResult filestream_adaptor_FileStreamCPI_CloneInstance(void *adaptor_data, GATFileStreamCPI_Instance const *data, GATFileStreamCPI_Instance *new_data); GATResult filestream_adaptor_FileStreamCPI_EqualsInstance(void *adaptor_data, GATFileStreamCPI_Instance const *lhs, GATFileStreamCPI_Instance const *rhs, GATBool *isequal); /* Streamable functions */ static GATResult filestream_adaptor_FileStreamCPI_Read(void *data, GATFileStreamCPI_Instance const *instance_data, void *buffer, GATuint32 size, GATuint32 *readBytes); static GATResult filestream_adaptor_FileStreamCPI_Write(void *data, GATFileStreamCPI_Instance const *instance_data, void const *buffer, GATuint32 size, GATuint32 *writtenBytes); static GATResult filestream_adaptor_FileStreamCPI_Seek(void *data, GATFileStreamCPI_Instance const *instance_data, GATOrigin origin, GATint32 offset, GATuint32 *new_position); static GATResult filestream_adaptor_FileStreamCPI_Close(void *data, GATFileStreamCPI_Instance *instance_data); /* Execute a GATFileStream get_metrics operation */ static GATResult filestream_adaptor_FileStreamCPI_GetMetrics(void *data, GATFileStreamCPI_Instance const *instance_data, GATList_GATMetric *metrics); /* Execute a GATFileStream get_metric_event operation */ static GATResult filestream_adaptor_FileStreamCPI_GetMetricEvent(void *data, GATFileStreamCPI_Instance const *instance_data, GATMetric metric, GATMetricEvent *event); /* local helper functions */ static GATResult filestream_adaptor_FireReadEvent(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name); static GATResult filestream_adaptor_FireWriteEvent(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name); static GATResult filestream_adaptor_FireSeekEvent(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name); static GATResult filestream_adaptor_FireCloseEvent(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name); /* File scope variables */ static GATStaticMetric metric_data[] = { /* filestream.read event */ { "filestream.read", /* name */ GATMeasurementType_EventLike, /* type */ GATType_String, /* data type */ "", /* unit */ 0, /* parameter count */ 0 /* parameters */ }, /* filestream.write event */ { "filestream.write", /* name */ GATMeasurementType_EventLike, /* type */ GATType_String, /* data type */ "", /* unit */ 0, /* parameter count */ 0 /* parameters */ }, /* filestream.seek event */ { "filestream.seek", /* name */ GATMeasurementType_EventLike, /* type */ GATType_String, /* data type */ "", /* unit */ 0, /* parameter count */ 0 /* parameters */ }, /* filestream.close event */ { "filestream.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_FILESTREAM_READ 0 #define METRIC_FILESTREAM_WRITE 1 #define METRIC_FILESTREAM_SEEK 2 #define METRIC_FILESTREAM_CLOSE 3 /* External functions */ /** filestream_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 filestream_adaptor_register(GATContext error_context, GATRegistry registry, GATTable_const system_config, GATTable_const instance_config, void *token) { GATResult retcode = GAT_MEMORYFAILURE; if (!GATVERSION_ISCOMPATIBLE()) { retcode = GAT_UNKNOWN_VERSION; } else { GATFileStreamCPI cpi = NULL; GATFileStreamCPI_Data cpidata; memset(&cpidata, 0, sizeof(GATFileStreamCPI_Data)); /* * provide the appropriate callback functions */ /* adaptor instance data */ cpidata.data = NULL; cpidata.destroy = filestream_adaptor_FileStreamCPI_Destroy; /* Lifetime control and basic GATObject functionality support for every * object instance created by the client. */ cpidata.create_instance = filestream_adaptor_FileStreamCPI_CreateInstance; cpidata.destroy_instance = filestream_adaptor_FileStreamCPI_DestroyInstance; cpidata.clone_instance = filestream_adaptor_FileStreamCPI_CloneInstance; cpidata.equals_instance = filestream_adaptor_FileStreamCPI_EqualsInstance; /* streamable support */ cpidata.read = filestream_adaptor_FileStreamCPI_Read; cpidata.write = filestream_adaptor_FileStreamCPI_Write; cpidata.seek = filestream_adaptor_FileStreamCPI_Seek; cpidata.close = filestream_adaptor_FileStreamCPI_Close; /* monitoring support */ cpidata.get_metrics = filestream_adaptor_FileStreamCPI_GetMetrics; cpidata.get_metric_event = filestream_adaptor_FileStreamCPI_GetMetricEvent; /* Create a GATFileStreamCPI object. */ cpi = GATFileStreamCPI_Create(GATFILESTREAMCPI_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 */ GATPreferences_Add(preferences, "Name", "filestream_adaptor"); GATPreferences_Add(preferences, "Security", "none"); GATPreferences_Add(preferences, "Local", "true"); retcode = GATRegistry_AddGATFileStreamCPI(registry, cpi, token, preferences); GATPreferences_Destroy(&preferences); } } if (GAT_SUCCESS != retcode) { GATFileStreamCPI_Destroy(&cpi); } } return retcode; } /* Local functions */ /** filestream_adaptor_FileStreamCPI_Destroy * Destroy the adaptor-provided data object on GATFileStreamCPI destruction. * When the GATFileStreamCPI 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 filestream_adaptor_FileStreamCPI_Destroy(void *data) { /* nothing to do here (no internal data allocated) */ } /** filestream_adaptor_FileStreamCPI_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. * * @return An error code. */ GATResult filestream_adaptor_FileStreamCPI_CreateInstance(void *adaptor_data, GATFileStreamCPI_Instance *data) { if (NULL != data) { GAT_USES_STATUS(data->context, "filestream_adaptor_FileStreamCPI_CreateInstance"); char *location = GATLocation_ToString(data->location); if (NULL != location) { FILE *file = NULL; if (GATFileStreamMode_Read == data->mode) { file = fopen(location, "r"); } else if (GATFileStreamMode_Write == data->mode) { file = fopen(location, "w"); } else if (GATFileStreamMode_Append == data->mode) { file = fopen(location, "a"); } else { file = fopen(location, "r+"); } if (NULL != file) { data->instance_data = (void *) file; } else { GAT_CREATE_STATUS(GAT_FILEOPEN_ERROR); } free(location); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** filestream_adaptor_FileStreamCPI_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 filestream_adaptor_FileStreamCPI_DestroyInstance(void *adaptor_data, GATFileStreamCPI_Instance *data) { if (NULL != data) { GAT_USES_STATUS(data->context, "filestream_adaptor_FileStreamCPI_DestroyInstance"); if (NULL != data->instance_data) { fclose((FILE *)data->instance_data); data->instance_data = NULL; } GAT_STORE_STATUS(); } } /** filestream_adaptor_FileStreamCPI_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 filestream_adaptor_FileStreamCPI_CloneInstance(void *adaptor_data, GATFileStreamCPI_Instance const *instance_data, GATFileStreamCPI_Instance *new_instance_data) { if (NULL != instance_data && NULL != new_instance_data) { GAT_USES_STATUS(instance_data->instance_data, "filestream_adaptor_FileStreamCPI_CloneInstance"); if (NULL != instance_data->instance_data) { new_instance_data->instance_data = instance_data->instance_data; } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** filestream_adaptor_FileStreamCPI_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 filestream_adaptor_FileStreamCPI_EqualsInstance(void *data, GATFileStreamCPI_Instance const *lhs, GATFileStreamCPI_Instance const *rhs, GATBool *isequal) { if (NULL != lhs && NULL != rhs) { GAT_USES_STATUS(lhs->context, "filestream_adaptor_FileStreamCPI_EqualsInstance"); if (NULL != isequal) { *isequal = GATFalse; if (lhs->instance_data == rhs->instance_data) { *isequal = GATTrue; } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /* Streamable support */ /** filestream_adaptor_FileStreamCPI_Read * Reads data from a FileStream. * Adaptor implementation of FileStream 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 filestream_adaptor_FileStreamCPI_Read(void *data, GATFileStreamCPI_Instance const *instance_data, void *buffer, GATuint32 size, GATuint32 *readBytes) { if (NULL != instance_data) { GAT_USES_STATUS(instance_data->context, "filestream_adaptor_FileStreamCPI_Read"); if ((NULL != buffer) && (NULL != readBytes)) { *readBytes = (GATuint32) fread(buffer, 1, (size_t) size, (FILE *) instance_data->instance_data); if (size == *readBytes) { GAT_CREATE_STATUS(filestream_adaptor_FireReadEvent( instance_data->context, instance_data->monitorable, instance_data->source, "read")); } else { GAT_CREATE_STATUS(POSIX_TO_GAT(errno)); } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** filestream_adaptor_FileStreamCPI_Write * Writes data to a FileStream. * Adaptor implementation of FileStream 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 filestream_adaptor_FileStreamCPI_Write(void *data, GATFileStreamCPI_Instance const *instance_data, void const *buffer, GATuint32 size, GATuint32 *writtenBytes) { if (NULL != instance_data) { GAT_USES_STATUS(instance_data->context, "filestream_adaptor_FileStreamCPI_Write"); if ((NULL != buffer) && (NULL != writtenBytes)) { *writtenBytes = (GATuint32) fwrite (buffer, 1, (size_t) size, (FILE *) instance_data->instance_data ); if (size == *writtenBytes) { GAT_CREATE_STATUS(filestream_adaptor_FireWriteEvent( instance_data->context, instance_data->monitorable, instance_data->source, "write")); } else { GAT_CREATE_STATUS(POSIX_TO_GAT(errno)); } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** filestream_adaptor_FileStreamCPI_Seek * Seeks on a FileStream. * Adaptor implementation of FileStream 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 FileStream * @return An error code. */ static GATResult filestream_adaptor_FileStreamCPI_Seek(void *data, GATFileStreamCPI_Instance const *instance_data, GATOrigin origin, GATint32 offset, GATuint32 *new_position) { if (NULL != instance_data) { GAT_USES_STATUS(instance_data->context, "filestream_adaptor_FileStreamCPI_Seek"); if (NULL != new_position) { int wherefrom; if (GATOrigin_Set == origin) { wherefrom = SEEK_SET; } else if (GATOrigin_Current == origin) { wherefrom = SEEK_CUR; } else if (GATOrigin_End == origin) { wherefrom = SEEK_END; } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { if (0 == fseek ((FILE *) instance_data->instance_data, (long) offset, wherefrom )) { long newPosition = ftell ((FILE *) instance_data->instance_data); if (-1 != newPosition) { if (NULL != new_position) { *new_position = (GATuint32) newPosition; GAT_CREATE_STATUS(filestream_adaptor_FireSeekEvent( instance_data->context, instance_data->monitorable, instance_data->source, "seek")); } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } } else { GAT_CREATE_STATUS(POSIX_TO_GAT(errno)); } } else { GAT_CREATE_STATUS(POSIX_TO_GAT(errno)); } } } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** filestream_adaptor_FileStreamCPI_Close * Closes a FileStream * Adaptor implementation of FileStream close capability. * * @param data Adaptor-provided data object. * @param instance_data The instance data of this CPI object * @return An error code. */ static GATResult filestream_adaptor_FileStreamCPI_Close(void *data, GATFileStreamCPI_Instance *instance_data) { if (NULL != instance_data) { GAT_USES_STATUS(instance_data->context, "filestream_adaptor_FileStreamCPI_Close"); if (0 == fclose ((FILE *) instance_data->instance_data)) { GAT_CREATE_STATUS(filestream_adaptor_FireCloseEvent( instance_data->context, instance_data->monitorable, instance_data->source, "close")); } else { GAT_CREATE_STATUS(POSIX_TO_GAT(errno)); } instance_data->instance_data = NULL; return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /* Monitoring support */ /** filestream_adaptor_FileStreamCPI_GetMetrics * * The function filestream_adaptor_FileStreamCPI_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 filestream_adaptor_FileStreamCPI_GetMetrics(void *data, GATFileStreamCPI_Instance const *instance_data, GATList_GATMetric *metrics) { return GATMetric_CreateListOfMetrics(metric_data, __countof(metric_data), metrics); } /** filestream_adaptor_FileStreamCPI_GetMetricEvent * * The function filestream_adaptor_FileStreamCPI_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 filestream_adaptor_FileStreamCPI_GetMetricEvent(void *data, GATFileStreamCPI_Instance const *instance_data, GATMetric metric, GATMetricEvent *event) { /* this adaptor supports no continuous metrics */ GATResult retval = GAT_SUCCESS; return retval; } /** filestream_adaptor_FireReadEvent * * The function filestream_adaptor_FireReadEvent fires a * 'filestream read' event to all registered metric listeners. */ static GATResult filestream_adaptor_FireReadEvent(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name) { GAT_USES_STATUS(context, "filestream_adaptor_FireReadEvent"); if (NULL != monitorable && NULL != source && NULL != name) { GATMetric metric = NULL; GAT_CREATE_STATUS(GATMetric_CreateMetric( &metric_data[METRIC_FILESTREAM_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)); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } GATMetricEvent_Destroy(&event); GATMetric_Destroy(&metric); } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } /** filestream_adaptor_FireWriteEvent * * The function filestream_adaptor_FireWriteEvent fires a * 'filestream write' event to all registered metric listeners. */ static GATResult filestream_adaptor_FireWriteEvent(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name) { GAT_USES_STATUS(context, "filestream_adaptor_FireWriteEvent"); if (NULL != monitorable && NULL != source && NULL != name) { GATMetric metric = NULL; GAT_CREATE_STATUS(GATMetric_CreateMetric( &metric_data[METRIC_FILESTREAM_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)); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } GATMetricEvent_Destroy(&event); GATMetric_Destroy(&metric); } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } /** filestream_adaptor_FireSeekEvent * * The function filestream_adaptor_FireSeekEvent fires a * 'filestream seek' event to all registered metric listeners. */ static GATResult filestream_adaptor_FireSeekEvent(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name) { GAT_USES_STATUS(context, "filestream_adaptor_FireSeekEvent"); if (NULL != monitorable && NULL != source && NULL != name) { GATMetric metric = NULL; GAT_CREATE_STATUS(GATMetric_CreateMetric( &metric_data[METRIC_FILESTREAM_SEEK], &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)); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } GATMetricEvent_Destroy(&event); GATMetric_Destroy(&metric); } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } /** filestream_adaptor_FireCloseEvent * * The function filestream_adaptor_FireCloseEvent fires a * 'filestream close' event to all registered metric listeners. */ static GATResult filestream_adaptor_FireCloseEvent(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name) { GAT_USES_STATUS(context, "filestream_adaptor_FireCloseEvent"); if (NULL != monitorable && NULL != source && NULL != name) { GATMetric metric = NULL; GAT_CREATE_STATUS(GATMetric_CreateMetric( &metric_data[METRIC_FILESTREAM_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)); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } GATMetricEvent_Destroy(&event); GATMetric_Destroy(&metric); } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); }