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

GATLogicalFile.c Go to the documentation of this file. /** @file GATLogicalFile.c * Source file for the GATLogicalFile class. * * @date Thu Oct 16 2003 * * @version $Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/src/GATLogicalFile.c,v 1.33 2004/04/09 12:29:18 hartmutkaiser Exp $ * * Copyright (C) Hartmut Kaiser * This file is part of the GAT Engine. * Contributed by 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) */ static const char *rcsid = "$Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/src/GATLogicalFile.c,v 1.33 2004/04/09 12:29:18 hartmutkaiser Exp $"; /* System Header Files */ #include <stdlib.h> #include <string.h> #include <assert.h> /* GAT Header Files */ #include "GATUtil.h" #include "GATInternal.h" #include "GATErrors.h" #include "GATType.h" #include "GATObject.h" #include "GATRegistry.h" #include "GATFile.h" #include "GATLogicalFileCPI.h" #include "GATXdsWrapper.h" /* define the vtable types */ GATOBJECT_DEFINE_VTABLE(GATLogicalFile); GATSERIALISABLE_DEFINE_VTABLE(GATLogicalFile); GATMONITORABLE_DEFINE_VTABLE(GATLogicalFile); /* GATList_GATFile */ GATLIST_IMPLEMENT(extern, GATFile, GATList_GATFile, GATType_GATFile); /* Declare the converters to/from GATObject */ GATOBJECT_DEFINE_CONVERTERS(GATLogicalFile); GATOBJECT_DEFINE_CONVERTERS_QUALIFIED(extern, GATList_GATFile, GATType_GATList); /* Macros */ /* Structures, unions and enums */ struct GATLogicalFile_S { GATLogicalFile_vtable *GATObject__vtable; GATLogicalFile_ISerialisable_vtable *GATSerialisable__vtable; GATLogicalFile_IMonitorable_vtable *GATMonitorable__vtable; /* instance data */ GATLogicalFileCPI_Instance data; /* instance data of the CPI object */ GATLogicalFileCPI cpi; /* CPI object to use for all subsequent operations */ GATLogicalFileCPIList cpilist; /* CPI list of appropriate CPI objects */ }; /* Static function prototypes */ static GATResult GATLogicalFile_DeSerialise_Create(GATContext context, GATObject stream, GATLocation location, GATLogicalFile *new_object); static GATResult GATLogicalFile_GetCPIInstanceData(GATLogicalFile logfile, void **data); /* File scope variables */ static GATLogicalFile_vtable GATLogicalFile__vtable = { GATLogicalFile_GetType, GATLogicalFile_Destroy, GATLogicalFile_Equals, GATLogicalFile_Clone, GATLogicalFile_GetInterface, GATLogicalFile_GetCPIInstanceData }; static GATLogicalFile_ISerialisable_vtable GATLogicalFile_ISerialisable__vtable = { GATLogicalFile_Serialise, GATLogicalFile_DeSerialise, GATLogicalFile_GetIsDirty }; static GATLogicalFile_IMonitorable_vtable GATLogicalFile_IMonitorable__vtable = { GATLogicalFile_AddMetricListener, GATLogicalFile_RegisterPolling, GATLogicalFile_RemoveRegisteredMetric, GATLogicalFile_GetMetrics }; /* External functions */ /** GATLogicalFile_Register_GATSerialisable * The GATLogicalFile_Register_GATSerialisable function registers the * serialization vtable with the GAT engine to allow generic object creation. * This function is called by the GAT engine, there is no need to use it * directly. */ GATResult GATLogicalFile_Register_GATSerialisable() { return GATObject_Register_GATSerialisable(GATType_GATLogicalFile, &GATLogicalFile_ISerialisable__vtable); } /** GATLogicalFile_Create() * */ GATLogicalFile GATLogicalFile_Create(GATContext context, GATLocation location, GATLogicalFileMode mode, GATPreferences_const preferences) { GAT_STATUS_APIENTRY(context, "GATLogicalFile_Create"); GATLogicalFile new_logfile = (GATLogicalFile)malloc(sizeof(struct GATLogicalFile_S)); if(NULL != new_logfile) { memset(new_logfile, 0, sizeof(struct GATLogicalFile_S)); new_logfile->GATObject__vtable = &GATLogicalFile__vtable; new_logfile->GATSerialisable__vtable = &GATLogicalFile_ISerialisable__vtable; new_logfile->GATMonitorable__vtable = &GATLogicalFile_IMonitorable__vtable; new_logfile->data.context = context; new_logfile->data.isdirty = GATFalse; new_logfile->data.source = GATLogicalFile_ToGATObject_const(new_logfile); new_logfile->data.mode = mode; GAT_CREATE_STATUS(GATLocation_Clone(location, &new_logfile->data.location)); /* find a CPI object, which can handle the object at the given location */ if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { GATRegistry_const registry = GATContext_internal_GetRegistry(context); /* use default preferences, if appropriate */ if (NULL == preferences) { preferences = GATContext_GetPreferences(context); } new_logfile->cpilist = GATRegistry_FindGATLogicalFileCPI(registry, preferences); if (NULL == new_logfile->cpilist) { GAT_CREATE_STATUS(GAT_NO_REGISTERED_CPI); } else { /* create a new instance of the CPI provider */ GATBool found_cpi = GATFalse; GATLogicalFileCPIList current = NULL; for(current = new_logfile->cpilist; NULL != current; current = current->next) { GAT_CREATE_STATUS(GATLogicalFileCPI_CreateInstance(current->cpi, &new_logfile->data)); if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { new_logfile->cpi = current->cpi; found_cpi = GATTrue; break; } } /* no available CPI object can handle this */ if (GATFalse == found_cpi) { GAT_CREATE_STATUS(GAT_NO_REGISTERED_CPI); } else { /* now, initialise the monitoring framework with the help of the CPI provider found */ GATList_GATMetric metrics = NULL; GATResult retval = GATLogicalFileCPI_GetMetrics(new_logfile->cpi, &new_logfile->data, &metrics); if (GAT_SUCCEEDED(retval)) { new_logfile->data.monitorable = GATMonitorable_Impl_Create(metrics); if (NULL == new_logfile->data.monitorable) { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } GATList_GATMetric_Destroy(&metrics); } else if (GAT_NOTIMPL == retval) { retval = GAT_SUCCESS; /* no monitoring supported here */ } else { GAT_CREATE_STATUS(retval); } /* register this object with the engine */ GAT_CREATE_STATUS(GATRegistry_AddGATLogicalFileToCPIList(context, new_logfile->cpi, new_logfile)); } } } } else { GAT_CREATE_STATUS(GAT_INVALID_HANDLE); } // error handling if (GAT_FAILED(GAT_CURRENT_STATUS())) { GATLogicalFile_Destroy(&new_logfile); } GAT_STORE_STATUS(); return new_logfile; } /** int GATLogicalFile_Equals(GATLogicalFile_const lhs, GATLogicalFile_const rhs, GATBool *isequal) * @brief Compares two logical files * * The function @c GATLogicalFile_Equals compares two logical file objects * @c #GATLogicalFile * * @param lhs The first logfile to compare * @param rhs The second logfile to compare * @param isequal The pointer to the GATBool variable, which should receive * the result if the comparison * * @return An error code. */ GATResult GATLogicalFile_Equals(GATLogicalFile_const lhs, GATLogicalFile_const rhs, GATBool *isequal) { if (NULL != lhs && NULL != rhs) { GAT_STATUS_APIENTRY(lhs->data.context, "GATLogicalFile_Equals"); if (NULL != isequal) { GAT_CREATE_STATUS(GATLocation_Equals(lhs->data.location, rhs->data.location, isequal)); if (GATTrue == *isequal) { GAT_CREATE_STATUS(GATLogicalFileCPI_EqualsInstance(lhs->cpi, &lhs->data, &rhs->data, isequal)); } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** int GATLogicalFile_GetType(GATLogicalFile_const filehandle) * @brief Return the type of the GATLogicalFile * * The function @c GATLogicalFile_type_GetType always returns GATType_GATLogicalFile. * * @param object The object to inspect * * @return returns always @c #GATType_GATLogicalFile. */ GATType GATLogicalFile_GetType(GATLogicalFile_const file) { GAT_UNUSED_PARAMETER(file); return GATType_GATLogicalFile; } /** int GATLogicalFile_Clone(GATLogicalFile_const logfile, GATLogicalFile *new_logfile) * @brief Clone the given logfile * * The function @c GATLogicalFile_type_Clone generates a (deep) copy of the given * logfile. * * @param filehandle The object to clone * @param new_filehandle The pointer, through which the result is to be * returned. * * @return An error type. */ GATResult GATLogicalFile_Clone(GATLogicalFile_const filehandle, GATLogicalFile *new_filehandle) { if (NULL != filehandle) { GAT_STATUS_APIENTRY(filehandle->data.context, "GATLogicalFile_Clone"); if (NULL != new_filehandle) { struct GATLogicalFile_S const *logfile = filehandle; GATLogicalFile new_logfile = (GATLogicalFile)malloc(sizeof(struct GATLogicalFile_S)); *new_filehandle = NULL; if (NULL == new_logfile) { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } else { memset(new_logfile, 0, sizeof(struct GATLogicalFile_S)); new_logfile->GATObject__vtable = &GATLogicalFile__vtable; new_logfile->GATSerialisable__vtable = &GATLogicalFile_ISerialisable__vtable; new_logfile->GATMonitorable__vtable = &GATLogicalFile_IMonitorable__vtable; new_logfile->data.context = logfile->data.context; new_logfile->data.isdirty = GATFalse; new_logfile->data.source = GATLogicalFile_ToGATObject_const(new_logfile); new_logfile->data.mode = logfile->data.mode; new_logfile->cpilist = GATRegistry_CloneGATLogicalFileCPIList( logfile->cpilist); if (NULL == new_logfile->cpilist) { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } GAT_CREATE_STATUS(GATLocation_Clone(logfile->data.location, &new_logfile->data.location)); if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { /* re-find the cpi to use */ GATLogicalFileCPIList current = logfile->cpilist; GATLogicalFileCPIList new_current = new_logfile->cpilist; for (/**/; NULL != current; current = current->next, new_current = new_current->next) { if (current->cpi == logfile->cpi) { new_logfile->cpi = new_current->cpi; break; } } assert(NULL != new_logfile->cpi); /* clone the instance data */ GAT_CREATE_STATUS(GATLogicalFileCPI_CloneInstance(logfile->cpi, &logfile->data, &new_logfile->data)); /* clone the monitoring data */ if (NULL != logfile->data.monitorable) { GAT_CREATE_STATUS(GATMonitorable_Impl_Clone(logfile->data.monitorable, &new_logfile->data.monitorable)); } /* register this object with the engine */ GAT_CREATE_STATUS(GATRegistry_AddGATLogicalFileToCPIList( new_logfile->data.context, new_logfile->cpi, new_logfile)); } } /* destroy the newly allocated object, if some error occured */ if (GAT_FAILED(GAT_CURRENT_STATUS())) { GATLogicalFile_Destroy(&new_logfile); } else { /* return the new object */ *new_filehandle = new_logfile; } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** int GATLogicalFile_GetInterface(GATLogicalFile_const file, GATInterface iftype, void const **ifp) * @brief Get an interface supported by a GATLogicalFile * * The function GATLogicalFile_GetInterface allows to get a pointer to an * additional interface supported by this GATLogicalFile. * * @param object The object to be asked for the new interface. * @param iftype The interface the object is to be asked for. * @param ifp The pointer, through which the result is to be returned. * * @return An error type. */ GATResult GATLogicalFile_GetInterface(GATLogicalFile_const file, GATInterface iftype, void const **ifp) { if (NULL != file) { GAT_STATUS_APIENTRY(file->data.context, "GATLogicalFile_GetInterface"); if (NULL != ifp) { if (GATInterface_ISerialisable == iftype || GATInterface_IAdvertisable == iftype) { *ifp = (void const *) &file->GATSerialisable__vtable; } else if (GATInterface_IMonitorable == iftype && NULL != file->data.monitorable) { *ifp = (void const *) &file->GATMonitorable__vtable; } else { *ifp = NULL; GAT_CREATE_STATUS(GAT_NO_INTERFACE); } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** int GATLogicalFile_Destroy(GATLogicalFile *filehandle) * @brief Destroy the given logfile. * * The function @c GATLogicalFile_Destroy destroys the given logfile. * * @param filehandle The logfile to be destroyed. If this parameter is 0 (zero) * the function does nothing, but returns @c #GAT_SUCCESS. * * @return Returns @c #GAT_SUCCESS if the logfile was destroyed successfully * or if the filehandle parameter was 0 (zero). */ void GATLogicalFile_Destroy(GATLogicalFile *filehandle) { /* if the given filehandle is 0 (zero), then do nothing */ if (NULL != filehandle && NULL != *filehandle) { GATMonitorable_Impl_Destroy(&(*filehandle)->data.monitorable); if (NULL != (*filehandle)->cpi) { GATLogicalFileCPI_DestroyInstance((*filehandle)->cpi, &(*filehandle)->data); } GATLocation_Destroy(&(*filehandle)->data.location); GATLogicalFileCPIList_Destroy((*filehandle)->cpilist); free(*filehandle); *filehandle = NULL; } } /** int GATLogicalFile_AddFile(GATLogicalFile filehandle, GATFile target) * @brief Add a file to the logical file store. * * The function @c GATLogicalFile_AddFile adds the passed GATFile instance to * the set of physical files represented by this GATLogicalFile instance. * * @param filehandle The logfile to which the physical should be added. * @param target The physical file to be added to the logical file store. * * @return An error code. */ GATResult GATLogicalFile_AddFile(GATLogicalFile file, GATFile_const target) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != file) { retval = GATLogicalFileCPI_AddFile(file->cpi, &file->data, target); } return retval; } /** int GATLogicalFile_RemoveFile(GATLogicalFile filehandle, GATFile target) * @brief Remove a file from the logical file store * * The functions @c GATLogicalFile_RemoveFile removes the passed GATFile * instance from the set of physical files represented by this GATLogicalFile * instance. * * @param filehandle The logfile from which the physical should be removed. * @param target The physical file to be removed from the logical file store. * * @return An error code. */ GATResult GATLogicalFile_RemoveFile(GATLogicalFile file, GATFile_const target) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != file) { retval = GATLogicalFileCPI_RemoveFile(file->cpi, &file->data, target); } return retval; } /** int GATLogicalFile_Replicate(GATLogicalFile_const filehandle, GATLocation_const target) * @brief Replicate the logical file store * * The functions GATLogicalFile_Replicate replicates the logical file * represented by this instance to the physical file specified by the passed * GATLocation. * * @param filehandle The logfile from which the physical should be removed. * @param target The physical file to replicate the logical file store to. * * @return An error code. */ GATResult GATLogicalFile_Replicate(GATLogicalFile_const file, GATLocation_const target) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != file) { retval = GATLogicalFileCPI_Replicate(file->cpi, &file->data, target); } return retval; } /** int GATLogicalFile_GetFiles(GATLogicalFile_const logfile, GATList_GATFile *files) * @brief Get the list of files of a logical file store. * * The function GATLogicalFile_GetFiles returns a List of GATFile instances * each of which is a GATFile corresponding to a physical file represented by * this GATLogicalFile instance. * * @param filehandle The logfile from which the physical should be removed. * @param files The pointer to the variable, where the list of files is to be * returned to. * * @return An error code. */ GATResult GATLogicalFile_GetFiles(GATLogicalFile_const file, GATList_GATFile *files) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != file) { retval = GATLogicalFileCPI_GetFiles(file->cpi, &file->data, files); } return retval; } /** int GATLogicalFile_Remove(GATLogicalFile filehandle) * @brief Removes the logical file store * * The functions @c GATLogicalFile_Remove removes the set of physical files * represented by this GATLogicalFile instance. All references to physical * files contained in this set are removed too. * * @param filehandle The logfile, which should be removed. * * @return An error code. */ GATResult GATLogicalFile_Remove(GATLogicalFile logfile) { GATResult retval = GAT_INVALID_HANDLE; if (NULL != logfile) { retval = GATLogicalFileCPI_Remove(logfile->cpi, &logfile->data); } return retval; } /* GATAdvertiseable API */ /** GATLogicalFileCPI_SerialiseCallback * * The function GATLogicalFileCPI_SerialiseCallback is used as a callback * function for the serialisation of a GATLogicalFile object. It should be * provided to serialise the associated CPI provider data for the given object. * * @param object The object to serialise. This is the same as the object * passed as the first parameter to the function GATXds_SerialiseObject. * @param stream The stream interface to use for the serialisation. * @param clear_dirty If the clear_dirty parameter is set to GATTrue, the * internal dirty flag of this object is to be reset (no used here) * * @return An error code. * * @remark This function is called from the GAT engine, there is no need to * call it directly. */ static GATResult GATLogicalFileCPI_SerialiseCallback(GATObject object, GATObject stream, GATBool clear_dirty) { GATLogicalFile file = GATObject_ToGATLogicalFile(object); if (NULL != file) { GAT_USES_STATUS(file->data.context, "GATLogicalFileCPI_SerialiseCallback"); GAT_CREATE_STATUS(GATLogicalFileCPI_Serialise(file->cpi, &file->data, stream, clear_dirty)); if (GAT_SUCCEEDED(GAT_CURRENT_STATUS()) && GATTrue == clear_dirty) { file->data.isdirty = GATFalse; } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** int GATLogicalFile_Serialise(GATFile file, GATObject stream, GATBool clear_dirty) * @brief Serialise a GATLogicalFile object * * The function GATLogicalFile_Serialise serialises the given GATLogicalFile * object into the given stream. * * @param file The GATLogicalFile object to serialise. * @param stream The stream interface to use for the serialisation. * @param clear_dirty If the clear_dirty parameter is set to GATTrue, the * internal dirty flag of this object is to be reset (no used here) * * @return An error code. */ GATResult GATLogicalFile_Serialise(GATLogicalFile file, GATObject stream, GATBool clear_dirty) { if (NULL != file) { GAT_USES_STATUS(file->data.context, "GATLogicalFile_Serialise"); /* FIXME: serialise the location directly, when GATLocation is fully implemented */ char *name = GATLocation_ToString(file->data.location); if (NULL != name) { GAT_CREATE_STATUS(GATXds_SerialiseObject(GATLogicalFile_ToGATObject(file), stream, clear_dirty, GATLogicalFileCPI_SerialiseCallback, "uint32 string", GATLOGICALFILE_VERSION1, name)); free(name); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** GATLogicalFileCPI_VersionCallback * * The function GATLogicalFileCPI_VersionCallback is used as a callback * function during the de-serialisation of a GATLogicalFile. It should be * provided to test, whether the de-serialised version matches the expected * version. * * @param version The version number, which was de-serialised from the stream. * * @return This function should return GATTrue, if the version matches the * expected value (version is valid), GATFalse otherwise. * * @remark This function is called from the GAT engine, there is no need to * call it directly. */ static GATBool GATLogicalFileCPI_VersionCallback(GATuint32 version) { GATBool retval = GATFalse; if ((version & ~GATLOGICALFILE_MINOR_MASK) <= GATLOGICALFILE_LASTVERSION) { retval = GATTrue; } return retval; } /** GATLogicalFileCPI_DeSerialiseCallback * * The function GATLogicalFileCPI_DeSerialiseCallback is used as a callback * function during the de-serialisation of a GATLogicalFile. It should be * provided for the instantiation of the new GATLogicalFile object based on * the already de-serialised data items and the de-serialisation of the * associated CPI provider data for the given object. * * @param context The GAT context to be used for object construction. * @param stream The stream interface to use for the serialisation. * @param object The pointer to the variable, which should receive the newly * constructed object. * @param version The version of the saved data read from the input stream. * @param args This parameter is the pointer to the va_list containing * pointers to the already de-serialised data items accordingly to the * format string, provided during the call to the * GATLogicalFile_DeSerialise function. * * @return An error code. * * @remark This function is called from the GAT engine, there is no need to * call it directly. */ static GATResult GATLogicalFileCPI_DeSerialiseCallback(GATContext context, GATObject stream, GATObject *object, GATuint32 version, va_list args) { GAT_USES_STATUS(context, "GATLogicalFileCPI_DeSerialiseCallback"); /* the version was eaten already */ /* FIXME: serialise/de-serialise the location directly, when GATLocation is fully implemented */ /*GATLocation *location = va_arg(args, GATLocation *);*/ char const **name = va_arg(args, char const **); GATLocation location = GATLocation_Create(*name); GATLogicalFile file = NULL; /* construct the new object */ GAT_CREATE_STATUS(GATLogicalFile_DeSerialise_Create(context, stream, location, &file)); GATLocation_Destroy(&location); /* FIXME: see above */ GAT_UNUSED_PARAMETER(version); if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { if (NULL != object) { *object = GATLogicalFile_ToGATObject(file); } else { GATLogicalFile_Destroy(&file); GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } } return GAT_RETURN_STATUS(); } /** GATLogicalFile GATLogicalFile_DeSerialise(GATContext context, GATObject stream, GATBool clear_dirty) * @brief De-serialise a GATLogicalFile object * * The function GATLogicalFile_DeSerialise de-serialises a streamed * GATLogicalFile object from the given stream It constructs a new instance * of the de-serialised object. * * @param context The GAT context to be used for object construction. * @param stream The stream interface to use for the serialisation. * @param result The pointer to a variable, which receives the status code of * the operation. * * @return The newly constructed GATLogicalFile object. */ GATLogicalFile GATLogicalFile_DeSerialise(GATContext context, GATObject stream, GATResult *result) { GAT_USES_STATUS(context, "GATLogicalFile_DeSerialise"); GATObject object = NULL; /* the new object will be created here */ GATLogicalFile file = NULL; /* we must provide all instance data items to be de-serialised for this GATFile object accordingly to the provided format string */ GATuint32 version = 0; /* FIXME: de-serialise the location directly, when GATLocation is fully implemented */ /* GATLocation location = NULL; */ char *name = NULL; /* read the data */ GAT_CREATE_STATUS(GATXds_DeSerialiseObject(context, stream, GATLogicalFileCPI_DeSerialiseCallback, GATLogicalFileCPI_VersionCallback, &object, "uint32 string", &version, &name)); /* GATLocation_Destroy(&location);*/ free(name); file = GATObject_ToGATLogicalFile(object); if (NULL == file) { GAT_CREATE_STATUS(GAT_BAD_OBJECT_CONVERSION); } if (GAT_FAILED(GAT_CURRENT_STATUS())) { GATObject_Destroy(&object); file = NULL; } if (NULL != result) { *result = GAT_CURRENT_STATUS(); } GAT_STORE_STATUS(); return file; } /** GATLogicalFile_GetIsDirty * * The function GATLogicalFile_GetIsDirty retrieves the status of the dirty * flag of this GATLogicalFile object. * * @param file The GATLogicalFile object to inspect for its dirty status. * @param isdirty The pointer to a variable, which receives the dirty status. * * @return An error code. */ GATResult GATLogicalFile_GetIsDirty(GATLogicalFile_const file, GATBool *isdirty) { if (NULL != file) { GAT_STATUS_APIENTRY(file->data.context, "GATLogicalFile_GetIsDirty"); if (NULL != isdirty) { *isdirty = file->data.isdirty; } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /* GATMonitorable API */ /** GATLogicalFile_AddMetricListener * * The function GATLogicalFile_AddMetricListener adds the passed instance of a * GATMetricListener to the list of GATMetricListeners which are notified of * fired GATMetricEvents of the type described by the provided GATMetric * instance. * * @param file The GATLogicalFile instance to add the GATMetricListener to. * @param listener The GTAMetricListener to call, when the corresponding * GATMetricEvent is fired. * @param listener_data The client supplied data, which will be passed through * to the GATMetricListener. * @param metric The GATMetric instance describing the GATMetricEvent to pass * to the GATMetricListener. * @param cookie The returned value should be used to remove the * GATMetricListener from this GATMonitorable. * * @return An error code. */ GATResult GATLogicalFile_AddMetricListener(GATLogicalFile file, GATMetricListener listener, void *listener_data, GATMetric metric, GATuint32 *cookie) { if (NULL != file) { GAT_STATUS_APIENTRY(file->data.context, ""); if (NULL != file->data.monitorable) { GAT_CREATE_STATUS(GATMonitorable_Impl_AddMetricListener( file->data.monitorable, listener, listener_data, metric, cookie)); } else { /* this may happen, if the adaptor has not registered any GATMetrics */ GAT_CREATE_STATUS(GAT_NO_INTERFACE); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** GATLogicalFile_RegisterPolling * * The function GATLogicalFile_RegisterPolling registers a continuous * metric with the given GATFile instance. * * @param file The GATLogicalFile instance to register the metric with. * @param metric The GATMetric instance describing the GATMetricEvent to pass * to the GATMetricListener. This metric instance must be of type * GATMeasurementType_Continuous, otherwise an error is returned. * @param event The pointer to a variable, which should receive the resulting * GATMetricEvent. The GATMetricEvent instance should be freed by the * caller when it isn't used anymore. * @param cookie The returned value should be used to remove the * GATMetricListener from this GATLogicalFile. * * @return An error code. */ GATResult GATLogicalFile_RegisterPolling(GATLogicalFile file, GATMetric metric, GATMetricEvent *event, GATuint32 *cookie) { if (NULL != file) { GAT_STATUS_APIENTRY(file->data.context, "GATLogicalFile_RegisterPolling"); if (NULL != file->data.monitorable) { GAT_CREATE_STATUS(GATMonitorable_Impl_RegisterPolling(file->data.monitorable, metric, 0, cookie)); /* ask the CPI provider to return the corresponding metric event */ GAT_CREATE_STATUS(GATLogicalFileCPI_GetMetricEvent(file->cpi, &file->data, metric, event)); if (GAT_FAILED(GAT_CURRENT_STATUS()) && NULL != cookie && 0 != *cookie) { GATMonitorable_Impl_RemoveRegisteredMetric(file->data.monitorable, metric, *cookie); *cookie = 0; } } else { /* this may happen, if the adaptor has not registered any GATMetrics */ GAT_CREATE_STATUS(GAT_NO_INTERFACE); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** GATLogicalFile_RemoveRegisteredMetric * * The function GATLogicalFile_RemoveRegisteredMetric removes a GATMetricListener, * which was previously registered with GATLogicalFile_AddMetricListener. * * @param file The GATLogicalFile instance to remove the GATMetricListener from. * @param listener The GTAMetricListener to call, when the corresponding * GATMetricEvent is fired. * @param metric The GATMetric instance describing the GATMetricEvent to pass * to the GATMetricListener. * @param cookie This value identifies the GATMetricListener to remove, it * was returned from the corresponding GATMonitorable_AddMetricListener * or GATMonitorable_MetricRegisterPolling functions. * * @return An error code. */ GATResult GATLogicalFile_RemoveRegisteredMetric(GATLogicalFile file, GATMetric metric, GATuint32 cookie) { if (NULL != file) { GAT_STATUS_APIENTRY(file->data.context, "GATLogicalFile_RemoveRegisteredMetric"); if (NULL != file->data.monitorable) { GAT_CREATE_STATUS(GATMonitorable_Impl_RemoveRegisteredMetric(file->data.monitorable, metric, cookie)); } else { /* this may happen, if the adaptor has not registered any GATMetrics */ GAT_CREATE_STATUS(GAT_NO_INTERFACE); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** GATLogicalFile_GetMetrics * * The function GATLogicalFile_GetMetrics returns a list of metrics supported * by this GATLogicalFile. * * @param file The GATLogicalFile instance, for which the supported metrics * should be returned. * @param metrics The pointer to the variable, which receives the resulting * list of metrics. * * @return An error code. */ GATResult GATLogicalFile_GetMetrics(GATLogicalFile_const file, GATList_GATMetric *metrics) { if (NULL != file) { GAT_STATUS_APIENTRY(file->data.context, "GATLogicalFile_GetMetrics"); if (NULL != file->data.monitorable) { GAT_CREATE_STATUS(GATMonitorable_Impl_GetMetrics(file->data.monitorable, metrics)); } else { /* this may happen, if the adaptor has not registered any GATMetrics */ GAT_CREATE_STATUS(GAT_NO_INTERFACE); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /* Local functions */ /** GATLogicalFile_DeSerialise_Create * * The function GATLogicalFile_DeSerialise_Create creates a new GATFile object * and tries to find a CPI provider to associate with this file object. The * CPI provider is selected by testing, which adapter is able to handle the * streamed instance data of the original CPI provider. * * @param context The GAT context to use for creation of the GATLogicalFile * object. * @param stream The object from which the adaptor should read the streamed * instance data. * @param location This is the URI of the logical file to reconstruct. * @param new_object The pointer to the variable, which should receive the * newly constructed GATLogicalFile object. * * @return An error code. */ static GATResult GATLogicalFile_DeSerialise_Create(GATContext context, GATObject stream, GATLocation location, GATLogicalFile *new_object) { GAT_USES_STATUS(context, "GATLogicalFile_DeSerialise_Create"); GATLogicalFile new_file = (GATLogicalFile) malloc(sizeof(struct GATLogicalFile_S)); if(NULL != new_file) { memset(new_file, 0, sizeof(struct GATLogicalFile_S)); new_file->GATObject__vtable = &GATLogicalFile__vtable; new_file->GATSerialisable__vtable = &GATLogicalFile_ISerialisable__vtable; new_file->GATMonitorable__vtable = &GATLogicalFile_IMonitorable__vtable; new_file->data.context = context; new_file->data.isdirty = GATFalse; new_file->data.mode = GATLogicalFileMode_Open; /* should exist */ new_file->data.source = GATLogicalFile_ToGATObject_const(new_file); GAT_CREATE_STATUS(GATLocation_Clone(location, &new_file->data.location)); /* find a CPI object, which can handle the data at the given stream location */ if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { GATRegistry_const registry = GATContext_internal_GetRegistry(context); GATPreferences_const preferences = NULL; /* use default preferences, if appropriate */ if (NULL == preferences) { preferences = GATContext_GetPreferences(context); } new_file->cpilist = GATRegistry_FindGATLogicalFileCPI(registry, preferences); if (NULL == new_file->cpilist) { GAT_CREATE_STATUS(GAT_NO_REGISTERED_CPI); } else { /* find out the current stream position */ GATuint32 offset = 0; GATBool found_cpi = GATFalse; GATLogicalFileCPIList current = NULL; GAT_CREATE_STATUS(GATStreamable_Seek(stream, GATOrigin_Current, 0, &offset)); if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { /* create new instance data of the CPI provider */ for(current = new_file->cpilist; NULL != current; current = current->next) { /* try, whether this cpi can handle the input */ GAT_CREATE_STATUS(GATLogicalFileCPI_DeSerialise(current->cpi, stream, &new_file->data)); if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { new_file->cpi = current->cpi; found_cpi = GATTrue; break; } /* reset stream pointer to the beginning of the CPI instance data */ GAT_CREATE_STATUS(GATStreamable_Seek(stream, GATOrigin_Set, offset, 0)); } } /* no available CPI object can handle this */ if (GATFalse == found_cpi) { GAT_CREATE_STATUS(GAT_NO_MATCHING_CPI); } else { /* try to re-init the monitoring support, since the adaptor found may support another set of GATMetric's, than the original one. */ GATList_GATMetric metrics = NULL; GATResult retval = GATLogicalFileCPI_GetMetrics(new_file->cpi, &new_file->data, &metrics); if (GAT_SUCCEEDED(retval)) { new_file->data.monitorable = GATMonitorable_Impl_Create(metrics); if (NULL == new_file->data.monitorable) { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } GATList_GATMetric_Destroy(&metrics); } else if (GAT_NOTIMPL != retval) { GAT_CREATE_STATUS(retval); } else { retval = GAT_SUCCESS; /* no monitoring supported here */ } if (GAT_SUCCEEDED(retval)) { GAT_CREATE_STATUS(GATRegistry_AddGATLogicalFileToCPIList( new_file->data.context, new_file->cpi, new_file)); } } } } } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { if (NULL != new_object) { *new_object = new_file; } else { GATLogicalFile_Destroy(&new_file); GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } } else { GATLogicalFile_Destroy(&new_file); } return GAT_RETURN_STATUS(); } /* GATLogicalFile_GetCPIInstanceData * * The function GATLogicalFile_GetCPIInstanceData returns the CPI instance * data, associated with the given GATLogicalFile object. * * @param logfile The object, for which to return the CPI instance data. * @param data The pointer to the variable, which should receive the * resulting CPI instance data. * * @return An error code. */ static GATResult GATLogicalFile_GetCPIInstanceData(GATLogicalFile logfile, void **data) { if (NULL != logfile) { GAT_USES_STATUS(logfile->data.context, "GATLogicalFile_GetCPIInstanceData"); if (NULL != data) { *data = (void *)&logfile->data; } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; }