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 fileops adaptor. * * Test adaptor to check the GATFile API. Provides a simple * file GATFileCPI implementation. * * @date Sun Oct 5 2003 * * @version $Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/adaptors/fileops/adaptor.c,v 1.25 2004/04/22 10:25:05 hartmutkaiser Exp $ * * Copyright (C) Tom Goodale * Copyright (C) Hartmut Kaiser * This file is part of the GAT Engine. * Contributed by * Tom Goodale <goodale@aei.mpg.de> * Hartmut Kaiser <hartmutkaiser [at] t-online [dot] 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) */ #if defined(sccs) static const char *rcsid = "$Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/adaptors/fileops/adaptor.c,v 1.25 2004/04/22 10:25:05 hartmutkaiser Exp $"; #endif /* System Header Files */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/wait.h> #include <sys/stat.h> /* GAT Header Files */ #include <GATCPI.h> /* Macros */ /* Should copy this from a config table if available, and * use the below as a default. */ #define COPY_COMMAND "/bin/cp" #define MOVE_COMMAND "/bin/mv" #define REMOVE_COMMAND "/bin/rm -f" #define __countof(x) (sizeof(x)/sizeof(x[0])) /* Structures, unions and enums */ /* Adaptor data */ typedef struct GATFileOpsAdaptor_Data { GATTable config_data; } GATFileOpsAdaptor_Data; /* Instance data */ typedef struct GATFileOpsInstance_Data { GATContext context; GATLocation location; } GATFileOpsInstance_Data; /* Static function prototypes */ static void fileops_adaptor_FileCPI_Destroy(void *data); /* instance specific functions */ static GATResult fileops_adaptor_FileCPI_ServiceActions(void *data, GATFileCPI_Instance *instance_data, GATTimePeriod_const timeout /* = 0 */); static GATResult fileops_adaptor_FileCPI_CreateInstance(void *data, GATFileCPI_Instance *instance_data); static void fileops_adaptor_FileCPI_DestroyInstance(void *data, GATFileCPI_Instance *instance_data); static GATResult fileops_adaptor_FileCPI_CloneInstance(void *data, GATFileCPI_Instance const *instance_data, GATFileCPI_Instance *new_instance_data); static GATResult fileops_adaptor_FileCPI_EqualsInstance(void *data, GATFileCPI_Instance const *lhs, GATFileCPI_Instance const *rhs, GATBool *isequal); /* Serialisation functions */ static GATResult fileops_adaptor_FileCPI_Serialise(GATFileCPI cpi, GATFileCPI_Instance const *instance_data, GATObject stream, GATBool clear_dirty); static GATResult fileops_adaptor_FileCPI_DeSerialise(GATFileCPI cpi, GATObject stream, GATFileCPI_Instance *instance_data); /* Execute a GATFile copy operation */ static GATResult fileops_adaptor_FileCPI_Copy(void *data, GATFileCPI_Instance const *instance_data, GATLocation_const targetLocation, GATFileMode mode); /* Execute a GATFile move operation */ static GATResult fileops_adaptor_FileCPI_Move(void *data, GATFileCPI_Instance const *instance_data, GATLocation_const targetLocation, GATFileMode mode); /* Execute a GATFile delete operation */ static GATResult fileops_adaptor_FileCPI_Delete(void *data, GATFileCPI_Instance const *instance_data); /* Execute a GATFile test for is_readable */ static GATResult fileops_adaptor_FileCPI_IsReadable(void *data, GATFileCPI_Instance const *instance_data); /* Execute a GATFile test for is_writable */ static GATResult fileops_adaptor_FileCPI_IsWritable(void *data, GATFileCPI_Instance const *instance_data); /* Execute a GATFile get_length operation */ static GATResult fileops_adaptor_FileCPI_GetLength(void *data, GATFileCPI_Instance const *instance_data, unsigned long *length); /* Execute a GATFile get_lastwritetime operation */ static GATResult fileops_adaptor_FileCPI_LastWriteTime(void *data, GATFileCPI_Instance const *instance_data, GATTime *lw_time); /* Execute a GATFile get_metrics operation */ static GATResult fileops_adaptor_FileCPI_GetMetrics(void *data, GATFileCPI_Instance const *instance_data, GATList_GATMetric *metrics); /* Execute a GATFile get_metric_event operation */ static GATResult fileops_adaptor_FileCPI_GetMetricEvent(void *data, GATFileCPI_Instance const *instance_data, GATMetric metric, GATMetricEvent *event); static GATResult fileops_adaptor_get_file_size(void *data, GATType type, void *buffer, GATuint32 size); /* local helper functions */ static char * fileops_get_table_entry(GATTable_const table, char const *key); static GATResult fileops_copy_config(GATTable internal_data, GATTable_const system_config, GATTable_const instance_config, char const *key, char const *default_value); /* monitoring support (event firing) */ static GATResult fileops_adaptor_FireCopiedEvent(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name); static GATResult fileops_adaptor_FireMovedEvent(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name); static GATResult fileops_adaptor_FireDeletedEvent(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name); /* Adaptor data */ static GATFileOpsAdaptor_Data * GATFileOpsAdaptor_Data_Create(); static void GATFileOpsAdaptor_Data_Destroy(GATFileOpsAdaptor_Data *); /* File scope variables */ /* supported metrics */ static GATStaticMetric metric_data[] = { /* fileops.file_copied event */ { "fileops.file_copied", /* name */ GATMeasurementType_EventLike, /* type */ GATType_String, /* data type */ "", /* unit */ 0, /* parameter count */ 0 /* parameters */ }, /* fileops.file_moved event */ { "fileops.file_moved", /* name */ GATMeasurementType_EventLike, /* type */ GATType_String, /* data type */ "", /* unit */ 0, /* parameter count */ 0 /* parameters */ }, /* fileops.file_deleted event */ { "fileops.file_deleted", /* name */ GATMeasurementType_EventLike, /* type */ GATType_String, /* data type */ "", /* unit */ 0, /* parameter count */ 0 /* parameters */ }, /* fileops.file_size metric */ { "fileops.file_size", /* name */ GATMeasurementType_Continuous, /* type */ GATType_GATuint32, /* data type */ "Bytes", /* unit */ 0, /* parameter count */ 0 /* parameters */ }, }; /* symbolic constants for the metric positions inside the metric_data array */ #define METRIC_FILE_COPIED 0 #define METRIC_FILE_MOVED 1 #define METRIC_FILE_DELETED 2 #define METRIC_FILE_SIZE 3 /* External functions */ GATResult fileops_adaptor_register(GATContext error_context, GATRegistry registry, GATTable_const system_config, GATTable_const instance_config, void *token); /** fileops_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 fileops_adaptor_register(GATContext error_context, GATRegistry registry, GATTable_const system_config, GATTable_const instance_config, void *token) { GATResult retcode = GAT_MEMORYFAILURE; GATFileCPI cpi = NULL; GATPreferences preferences = NULL; if (!GATVERSION_ISCOMPATIBLE()) { retcode = GAT_UNKNOWN_VERSION; } else { GATFileOpsAdaptor_Data *internal_data = GATFileOpsAdaptor_Data_Create(); GATFileCPI_Data cpidata; memset(&cpidata, 0, sizeof(GATFileCPI_Data)); if (NULL != internal_data) { /* Create a GATFileCPI object. * This adaptor stores the internal data in an own GATTable object. */ fileops_copy_config(internal_data->config_data, system_config, instance_config, "copycmd", COPY_COMMAND); fileops_copy_config(internal_data->config_data, system_config, instance_config, "movecmd", MOVE_COMMAND); fileops_copy_config(internal_data->config_data, system_config, instance_config, "deletecmd", REMOVE_COMMAND); /* * provide the appropriate callback functions */ /* adaptor instance data */ cpidata.data = internal_data; cpidata.destroy = fileops_adaptor_FileCPI_Destroy; /* Lifetime control and basic GATObject functionality support for every * object instance created by the client. */ cpidata.service_actions = fileops_adaptor_FileCPI_ServiceActions; cpidata.create_instance = fileops_adaptor_FileCPI_CreateInstance; cpidata.destroy_instance = fileops_adaptor_FileCPI_DestroyInstance; cpidata.clone_instance = fileops_adaptor_FileCPI_CloneInstance; cpidata.equals_instance = fileops_adaptor_FileCPI_EqualsInstance; /* serialisation support for the provided instance data */ cpidata.serialise = fileops_adaptor_FileCPI_Serialise; cpidata.deserialise = fileops_adaptor_FileCPI_DeSerialise; /* the CPI specific functionality */ cpidata.copy = fileops_adaptor_FileCPI_Copy; cpidata.move = fileops_adaptor_FileCPI_Move; cpidata.remove = fileops_adaptor_FileCPI_Delete; cpidata.isreadable = fileops_adaptor_FileCPI_IsReadable; cpidata.iswritable = fileops_adaptor_FileCPI_IsWritable; cpidata.length = fileops_adaptor_FileCPI_GetLength; cpidata.lastwritetime = fileops_adaptor_FileCPI_LastWriteTime; /* monitoring support */ cpidata.get_metrics = fileops_adaptor_FileCPI_GetMetrics; cpidata.get_metric_event = fileops_adaptor_FileCPI_GetMetricEvent; /* register this new CPI provider with the engine */ cpi = GATFileCPI_Create(GATFILECPI_VERSION, &cpidata); if(NULL != cpi) { /* Need to pass preferences to allow matching * of a user's preferences with what this adaptor does. */ preferences = GATPreferences_Create(); if(NULL != preferences) { /* at least the Name preference should be defined */ GATPreferences_Add(preferences, "Name", "fileops_adaptor"); GATPreferences_Add(preferences, "Security", "none"); GATPreferences_Add(preferences, "Local", "true"); retcode = GATRegistry_AddGATFileCPI(registry, cpi, token, preferences); GATPreferences_Destroy(&preferences); } } } if (GAT_SUCCESS != retcode) { GATFileCPI_Destroy(&cpi); GATFileOpsAdaptor_Data_Destroy(internal_data); } } return retcode; } /* Local functions */ /** fileops_adaptor_FileCPI_Destroy * Destroy the adaptor-provided data object on GATFileCPI destruction. * When the GATFileCPI 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 fileops_adaptor_FileCPI_Destroy(void *data) { GATFileOpsAdaptor_Data_Destroy((GATFileOpsAdaptor_Data *) data); } /* instance specific functions */ /** fileops_adaptor_FileCPI_ServiceActions * * The function fileops_adaptor_FileCPI_ServiceActions is called, whenever * the client calls GATContext_ServiceActions. This function is called for * every created object. * This function should be used to update all instance specific data, which * may have been changed asynchronously or to fire pending events. * * @param data Adaptor-provided data object. * @param instance_data The instance data of this CPI object * @param timeout This may be a 0 timeout to indicate no timeout at all, or * a specific time length. * * @return An error code. */ static GATResult fileops_adaptor_FileCPI_ServiceActions(void *data, GATFileCPI_Instance *instance_data, GATTimePeriod_const timeout) { return GAT_NOTIMPL; } /** fileops_adaptor_FileCPI_CreateInstance * Create a new CPI object instance. * Adaptor implementation of create instance capability. * * This function gets called for every created object instance. The adaptor * may provide some arbitrary instance data, which is to be stored inside the * provided data structure (there is an instance_data member, which hold this * adaptor provided object instance data). This overall data structure * is handed back to the adaptor on every function call always as the second * parameter. * * @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. */ static GATResult fileops_adaptor_FileCPI_CreateInstance(void *adaptor_data, GATFileCPI_Instance *data) { GATResult retval = GAT_INVALID_PARAMETER; if (NULL != data) { /* this adaptor does not maintain instance data */ data->instance_data = NULL; retval = GAT_SUCCESS; } return retval; } /** fileops_adaptor_FileCPI_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. */ static void fileops_adaptor_FileCPI_DestroyInstance(void *adaptor_data, GATFileCPI_Instance *data) { /* this adaptor does not maintain instance data */ assert(NULL == data || NULL == data->instance_data); } /** fileops_adaptor_FileCPI_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. */ static GATResult fileops_adaptor_FileCPI_CloneInstance(void *adaptor_data, GATFileCPI_Instance const *data, GATFileCPI_Instance *new_data) { GATResult retval = GAT_INVALID_PARAMETER; if (NULL != new_data) { /* this adaptor does not maintain instance data */ new_data->instance_data = NULL; retval = GAT_SUCCESS; } return retval; } /** fileops_adaptor_FileCPI_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 rhs 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. */ static GATResult fileops_adaptor_FileCPI_EqualsInstance(void *adaptor_data, GATFileCPI_Instance const *lhs, GATFileCPI_Instance const *rhs, GATBool *isequal) { /* this adaptor does not maintain instance data */ GATResult retval = GAT_INVALID_PARAMETER; if (NULL != isequal) { /* has to compare the instance specific data only */ *isequal = GATTrue; retval = GAT_SUCCESS; } return retval; } /* Serialisation support */ /** fileops_adaptor_FileCPI_Serialise * * The function fileops_adaptor_FileCPI_Serialise is called by the * GAT engine, whenever the client requested a Serialise operation on the * corresponding GATFile object. The function should serialise into the * given stream all the instance specific data of the object. * * @param data Adaptor-provided data object. * @param instance_data The instance data of this CPI object. * @param stream The GATSTream object to use for serialisation of the instance * data. * @param clear_dirty This flag defines, whether the dirty flag of saved * dependent objects is to be cleared. * * @return An error code */ static GATResult fileops_adaptor_FileCPI_Serialise(GATFileCPI cpi, GATFileCPI_Instance const *instance_data, GATObject stream, GATBool clear_dirty) { /* this adaptor does not maintain instance data, so there is nothing to do here */ GATResult retval = GAT_SUCCESS; return retval; } /** fileops_adaptor_FileCPI_DeSerialise * * The function fileops_adaptor_FileCPI_DeSerialise is called by * the GATEngine, whenever the client requested a DeSerialise operation for * a GATFile object. The function should deserialise all the instance * specific data of the object from the given stream. * * @param data Adaptor-provided data object. * @param stream The GATSTream object to use for de-serialisation of the * instance data. * @param instance_data The instance data of this CPI object. * * @return An error code */ static GATResult fileops_adaptor_FileCPI_DeSerialise(GATFileCPI cpi, GATObject stream, GATFileCPI_Instance *instance_data) { /* this adaptor does not maintain instance data, so there is nothing to do here */ GATResult retval = GAT_INVALID_PARAMETER; if (NULL != instance_data) { instance_data->instance_data = NULL; retval = GAT_SUCCESS; } return retval; } /* CPI specific functionality */ /** fileops_adaptor_FileCPI_Copy * Copy a file from one location to another. * Adaptor implementation of file copy capability. * * @param data Adaptor-provided data object. * @param instance_data The instance data of this CPI object * @param targetLocation Location to copy file to. * * @return An error code. */ static GATResult fileops_adaptor_FileCPI_Copy(void *adaptor_data, GATFileCPI_Instance const *data, GATLocation_const targetLocation, GATFileMode mode) { GAT_USES_STATUS(data->context, "fileops_adaptor_FileCPI_Copy"); char *source = GATLocation_ToString(data->location); char *target = GATLocation_ToString(targetLocation); if (NULL != source && NULL != target) { /* get the command prefix from the internal data table */ GATFileOpsAdaptor_Data *internal_data = (GATFileOpsAdaptor_Data *) adaptor_data; char *copycmd = fileops_get_table_entry(internal_data->config_data, "copycmd"); /* This is a very simple-minded approach, but it works. */ if (NULL != copycmd) { char *command_string = (char *)malloc(strlen(copycmd) + strlen(source) + strlen(target) + 3); if(command_string) { /* if the mode if GATFileMode_FailIfExists test, whether the destination exists */ struct stat destfile; if (GATFileMode_Overwrite == mode || -1 == stat(target, &destfile)) { int retcode = 0; sprintf(command_string, "%s %s %s", copycmd, source, target); retcode = system(command_string); if (0 == retcode) { /* fire the file_copied event */ GAT_CREATE_STATUS(fileops_adaptor_FireCopiedEvent(data->context, data->monitorable, data->source, source)); } GAT_CREATE_STATUS(WEXITSTATUS(retcode)); } else { GAT_CREATE_STATUS(GAT_FILEOPEN_ERROR); } free(command_string); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } free(copycmd); } else { /* something unexpected happened (unable to re-find the copycmd from the internal data table) */ GAT_CREATE_STATUS(GAT_FAIL); } free(source); free(target); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } return GAT_RETURN_STATUS(); } /** fileops_adaptor_FileCPI_Move * Move a file from one location to another. * Adaptor implementation of file move capability. * * @param data Adaptor-provided data object. * @param instance_data The instance data of this CPI object * @param targetLocation Location to copy file to. * * @return An error code. */ static GATResult fileops_adaptor_FileCPI_Move(void *adaptor_data, GATFileCPI_Instance const *data, GATLocation_const targetLocation, GATFileMode mode) { GAT_USES_STATUS(data->context, "fileops_adaptor_FileCPI_Move"); char *source = GATLocation_ToString(data->location); char *target = GATLocation_ToString(targetLocation); if (NULL != source && NULL != target) { /* get the command prefix from the internal data table */ GATFileOpsAdaptor_Data *internal_data = (GATFileOpsAdaptor_Data *) adaptor_data; char *copycmd = fileops_get_table_entry(internal_data->config_data, "movecmd"); /* This is a very simple-minded approach, but it works. */ if (NULL != copycmd) { char *command_string = (char *)malloc(strlen(copycmd) + strlen(source) + strlen(target) + 3); if(command_string) { /* if the mode if GATFileMode_FailIfExists test, whether the destination exists */ struct stat destfile; if (GATFileMode_Overwrite == mode || -1 == stat(target, &destfile)) { int retcode = 0; sprintf(command_string, "%s %s %s", copycmd, source, target); retcode = system(command_string); if (0 == retcode) { /* fire the file_copied event */ GAT_CREATE_STATUS(fileops_adaptor_FireMovedEvent(data->context, data->monitorable, data->source, source)); } GAT_CREATE_STATUS(WEXITSTATUS(retcode)); } else { GAT_CREATE_STATUS(GAT_FILEOPEN_ERROR); /* destination exists */ } free(command_string); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } free(copycmd); } else { /* something unexpected happened (unable to re-find the movecmd from the internal data table) */ GAT_CREATE_STATUS(GAT_FAIL); } free(source); free(target); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } return GAT_RETURN_STATUS(); } /** fileops_adaptor_FileCPI_Delete * Delete a file. * Adaptor implementation of file delete capability. * * @param data Adaptor-provided data object. * @param instance_data The instance data of this CPI object * * @return An error code. */ static GATResult fileops_adaptor_FileCPI_Delete(void *adaptor_data, GATFileCPI_Instance const *data) { GAT_USES_STATUS(data->context, "fileops_adaptor_FileCPI_Delete"); char *source = GATLocation_ToString(data->location); if (NULL != source) { /* get the command prefix from the internal data table */ GATFileOpsAdaptor_Data *internal_data = (GATFileOpsAdaptor_Data *) adaptor_data; char *copycmd = fileops_get_table_entry(internal_data->config_data, "deletecmd"); /* This is a very simple-minded approach, but it works. */ if (NULL != copycmd) { char *command_string = (char *)malloc(strlen(copycmd) + strlen(source) + 3); if(command_string) { int retcode = 0; sprintf(command_string, "%s %s", copycmd, source); retcode = system(command_string); if (0 == retcode) { /* fire the file_copied event */ GAT_CREATE_STATUS(fileops_adaptor_FireDeletedEvent(data->context, data->monitorable, data->source, source)); } GAT_CREATE_STATUS(WEXITSTATUS(retcode)); free(command_string); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } free(copycmd); } else { /* something unexpected happened (unable to re-find the movecmd from the internal data table) */ GAT_CREATE_STATUS(GAT_FAIL); } free(source); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } return GAT_RETURN_STATUS(); } /** fileops_adaptor_FileCPI_IsReadable * Tests a GATFile test for its readability. * Adaptor implementation of the is_readable capability. * * @param data Adaptor-provided data object. * @param instance_data The instance data of this CPI object * * @return An error code. */ static GATResult fileops_adaptor_FileCPI_IsReadable(void *adaptor_data, GATFileCPI_Instance const *data) { GAT_USES_STATUS(data->context, "fileops_adaptor_FileCPI_IsReadable"); char *source = GATLocation_ToString(data->location); if (NULL != source) { struct stat file_status; if (0 == stat(source, &file_status)) { /* file does exist */ GAT_CREATE_STATUS((file_status.st_mode & S_IRUSR) ? GAT_SUCCESS : GAT_FALSE); } else { /* file does not exist */ GAT_CREATE_STATUS(GAT_FILEOPEN_ERROR); } free(source); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } return GAT_RETURN_STATUS(); } /** fileops_adaptor_FileCPI_IsWritable * Tests a GATFile test for its writability. * Adaptor implementation of the is_writable capability. * * @param data Adaptor-provided data object. * @param instance_data The instance data of this CPI object * * @return An error code. */ static GATResult fileops_adaptor_FileCPI_IsWritable(void *adaptor_data, GATFileCPI_Instance const *data) { GAT_USES_STATUS(data->context, "fileops_adaptor_FileCPI_IsWritable"); char *source = GATLocation_ToString(data->location); if (NULL != source) { struct stat file_status; if (0 == stat(source, &file_status)) { /* file does exist */ GAT_CREATE_STATUS((file_status.st_mode & S_IWUSR) ? GAT_SUCCESS : GAT_FALSE); } else { /* file does not exist */ GAT_CREATE_STATUS(GAT_FILEOPEN_ERROR); } free(source); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } return GAT_RETURN_STATUS(); } /** fileops_adaptor_FileCPI_GetLength * Returns the size of a GATFile. * Adaptor implementation of the get_length capability. * * @param data Adaptor-provided data object. * @param instance_data The instance data of this CPI object. * @param length The pointer to the variable, which receives the current size * of the inspected file. * * @return An error code. */ static GATResult fileops_adaptor_FileCPI_GetLength(void *adaptor_data, GATFileCPI_Instance const *data, unsigned long *length) { GAT_USES_STATUS(data->context, "fileops_adaptor_FileCPI_GetLength"); if (NULL == length) { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } else { struct stat file_status; char *source = GATLocation_ToString(data->location); *length = (unsigned long)(-1); if (NULL != source) { if (0 == stat(source, &file_status)) { /* file does exist */ *length = file_status.st_size; } else { /* file does not exist */ GAT_CREATE_STATUS(GAT_FILEOPEN_ERROR); } free(source); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } } return GAT_RETURN_STATUS(); } /** fileops_adaptor_FileCPI_LastWriteTime * Returns the last write time of a GATFile. * Adaptor implementation of the get_lastwritetime capability. * * @param data Adaptor-provided data object. * @param instance_data The instance data of this CPI object. * @param lw_time The pointer to the variable, which receives the last write * time of the inspected file. * * @return An error code. */ static GATResult fileops_adaptor_FileCPI_LastWriteTime(void *adaptor_data, GATFileCPI_Instance const *data, GATTime *lw_time) { GAT_USES_STATUS(data->context, "fileops_adaptor_FileCPI_LastWriteTime"); if (NULL == lw_time) { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } else { struct stat file_status; char *source = GATLocation_ToString(data->location); *lw_time = NULL; if (NULL != source) { if (0 == stat(source, &file_status)) { /* file exists */ *lw_time = GATTime_Create(file_status.st_mtime); } else { /* file does not exist */ GAT_CREATE_STATUS(GAT_FILEOPEN_ERROR); } free(source); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } } return GAT_RETURN_STATUS(); } /** fileops_adaptor_FileCPI_GetMetrics * * The function fileops_adaptor_FileCPI_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 fileops_adaptor_FileCPI_GetMetrics(void *data, GATFileCPI_Instance const *instance_data, GATList_GATMetric *metrics) { return GATMetric_CreateListOfMetrics(metric_data, __countof(metric_data), metrics); } /** fileops_adaptor_FileCPI_GetMetricEvent * * The function fileops_adaptor_FileCPI_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 fileops_adaptor_FileCPI_GetMetricEvent(void *data, GATFileCPI_Instance const *instance_data, GATMetric metric, GATMetricEvent *event) { if (NULL != instance_data) { GAT_USES_STATUS(instance_data->context, "fileops_adaptor_FileCPI_GetMetricEvent"); GATMetric target_metric = NULL; GAT_CREATE_STATUS(GATMetric_CreateMetric(&metric_data[METRIC_FILE_SIZE], &target_metric)); if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { GATBool isequal = GATFalse; GAT_CREATE_STATUS(GATMetric_Equals(target_metric, metric, &isequal)); if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { if (GATTrue == isequal) { GATMetricEvent target_event = GATMetricEvent_Create_Continuous( instance_data->source, metric, fileops_adaptor_get_file_size, instance_data->location); if (NULL != target_event) { if (NULL != event) { *event = target_event; } else { GATMetricEvent_Destroy(&target_event); GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } } else { GATMetricEvent_Destroy(&target_event); GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } } GATMetric_Destroy(&target_metric); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /* local functions */ /** fileops_get_table_entry * @brief Get a table entry * * Retrieve the data from a table, which is associated with a given key. * * @param table The table from which the data is to be retrieved * @param key The key to look for * * @return The actual data or 0 (zero), if no data was found. Note, that the * returned data is to be freed by the caller. */ static char * fileops_get_table_entry(GATTable_const table, char const *key) { char *buffer = NULL; int len = GATTable_Get_String(table, key, 0, 0); if (len > 0) { buffer = (char *)malloc(len+1); if (NULL != buffer) { if (len != GATTable_Get_String(table, key, buffer, len+1)) { free(buffer); buffer = NULL; } } } return buffer; } /** fileops_copy_config * @brief Extract configuration data from the config tables * * The function fileops_copy_config tries to find the data associated with the * given key first in the supplied instance_config table and if not found in * the supplied system_config table. If it isn't found either, it uses the * supplied default value. * The recovered data is stored into the internal_data table. * * @param internal_data The table, where the recovered data is to be stored in * @param system_config The system configuration table * @param instance_config The instance specific configuration table * @param key The key for which the associated data is to be searched * @param default_value The value to be used, if no entries in the * configuration tables was found * * @return A GAT error code. */ static GATResult fileops_copy_config(GATTable internal_data, GATTable_const system_config, GATTable_const instance_config, char const *key, char const *default_value) { GATResult retval = GAT_FAIL; char *value = fileops_get_table_entry(instance_config, key); if (NULL != value) { retval = GATTable_Add_String(internal_data, key, value); free(value); } else if (NULL != (value = fileops_get_table_entry(system_config, key))) { retval = GATTable_Add_String(internal_data, key, value); free(value); } else { retval = GATTable_Add_String(internal_data, key, default_value); } return retval; } /** GATFileOpsAdaptor_Data_Create * This helper creates an instance of a GATFileOpsAdaptor_Data object. * * @return The newly created and initialized GATFileOpsAdaptor_Data object. */ static GATFileOpsAdaptor_Data * GATFileOpsAdaptor_Data_Create() { GATFileOpsAdaptor_Data *data = (GATFileOpsAdaptor_Data *)malloc(sizeof(GATFileOpsAdaptor_Data)); if (NULL != data) { data->config_data = GATTable_Create(); if (NULL == data->config_data) { free(data); data = NULL; } } return data; } /** GATFileOpsAdaptor_Data_Destroy * This helper destroys an instance of a GATFileOpsAdaptor_Data object. * * @param The GATFileOpsAdaptor_Data object to destroy */ static void GATFileOpsAdaptor_Data_Destroy(GATFileOpsAdaptor_Data *data) { if (NULL != data) { GATTable_Destroy(&data->config_data); free(data); } } /** fileops_adaptor_FireCopiedEvent * * The function fileops_adaptor_FireCopiedEvent fires a 'file copied' event * to all registered metric listeners. */ static GATResult fileops_adaptor_FireCopiedEvent(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name) { GAT_USES_STATUS(context, "fileops_adaptor_FireCopiedEvent"); if (NULL != monitorable && NULL != source && NULL != name) { GATMetric metric = NULL; GAT_CREATE_STATUS(GATMetric_CreateMetric(&metric_data[METRIC_FILE_COPIED], &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); } } return GAT_RETURN_STATUS(); } /** fileops_adaptor_FireMovedEvent * * The function fileops_adaptor_FireMovedEvent fires a 'file moved' event * to all registered metric listeners. */ static GATResult fileops_adaptor_FireMovedEvent(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name) { GAT_USES_STATUS(context, "fileops_adaptor_FireMovedEvent"); if (NULL != monitorable && NULL != source && NULL != name) { GATMetric metric = NULL; GAT_CREATE_STATUS(GATMetric_CreateMetric(&metric_data[METRIC_FILE_MOVED], &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); } } return GAT_RETURN_STATUS(); } /** fileops_adaptor_FireDeletedEvent * * The function fileops_adaptor_FireDeletedEvent fires a 'file deleted' event * to all registered metric listeners. */ static GATResult fileops_adaptor_FireDeletedEvent(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name) { GAT_USES_STATUS(context, "fileops_adaptor_FireDeletedEvent"); if (NULL != monitorable && NULL != source && NULL != name) { GATMetric metric = NULL; GAT_CREATE_STATUS(GATMetric_CreateMetric(&metric_data[METRIC_FILE_DELETED], &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); } } return GAT_RETURN_STATUS(); } /** fileops_adaptor_get_file_size * * The function fileops_adaptor_get_file_size has to return the size of the * referenced file. * This function gets called, whenever the client code tries to retrieve the * value associated with the corresponding GATMetricEvent. * */ static GATResult fileops_adaptor_get_file_size(void *data, GATType type, void *buffer, GATuint32 size) { GATResult retval = GAT_INVALID_PARAMETER; GATLocation location = (GATLocation) data; if ((NULL != location) && (NULL != buffer) && (size >= sizeof(GATint32)) && (GATType_GATuint32 == type)) { struct stat file_status; char *source = GATLocation_ToString(location); if (NULL != source) { if (0 == stat(source, &file_status)) { /* file does exist */ *(GATint32 *)buffer = file_status.st_size; retval = GAT_SUCCESS; } else { /* file does not exist */ retval = GAT_FILEOPEN_ERROR; } free(source); } else { retval = GAT_MEMORYFAILURE; } } return retval; }