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

GATLoader.c Go to the documentation of this file. /** @file GATLoader.c * Main file for the GATLoader class. * * A GATLoader is responsible for loading and maintaining a list of * adaptors. * * @date Thu Sep 18 2003 * * @version $Header: /export/cvs-gridlab/wp-1/Codes/GATEngine/C-reference/src/GATLoader.c,v 1.23 2004/04/22 10:25:05 hartmutkaiser Exp $ * * Copyright (C) Tom Goodale * This file is part of the GAT Engine. * Contributed by Tom Goodale <goodale@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/src/GATLoader.c,v 1.23 2004/04/22 10:25:05 hartmutkaiser Exp $"; /* System Header Files */ #include <stdio.h> #include <stdlib.h> #include <string.h> #include <ctype.h> /* GAT Header Files */ #include "GATUtil.h" #include "GATLoader.h" #include "GATErrors.h" #include "GATTestUtils.h" #include "ltdl/ltdl.h" #include "uuid.h" /* Macros */ #define REGISTRATION_SUFFIX "_register" /* Structures, unions and enums */ struct AdaptorInstance { struct AdaptorInstance *next; char *path; char *name; char *nickname; lt_dlhandle handle; }; struct GATLoader_S { struct AdaptorInstance *list; }; /* Static function prototypes */ static struct AdaptorInstance * AdaptorInstance_Create(const char *path, const char *name, const char *nickname); static char * CanonicaliseName(const char *original); static void AdaptorInstance_Destroy(struct AdaptorInstance *this); static GATResult LoadAdaptor(GATContext error_context, struct AdaptorInstance *instance, GATRegistry registry, GATTable_const system_config, GATTable_const instance_config); /* File scope variables */ /* External functions */ /** GATLoader_Create * The GATLoader constructor. * This is the constructor for GATLoader objects. * * @return A new GATLoader */ GATLoader GATLoader_Create(void) { GATLoader this; this = (GATLoader)malloc(sizeof(*this)); if(this) { lt_dlinit(); this->list = NULL; } return this; } /** GATLoader_Destroy * The GATLoader destructor. * This is the destructor for GATLoader objects. * * @param this An old GATLoader */ void GATLoader_Destroy(GATLoader *this) { if(NULL != this && NULL != *this) { struct AdaptorInstance *adaptor = (*this)->list; lt_dlexit(); /* free all AdaptorInstance's */ while (NULL != adaptor) { struct AdaptorInstance *next = adaptor; adaptor = adaptor->next; AdaptorInstance_Destroy(next); } free(*this); *this = NULL; } } /** GATLoader_LoadAdaptor * Loads a given adaptor. * Given a path, load the adaptor pointed to there, * invoking its registration function and passing that * both a system and an instance configuration tables. * Each adaptor may be given a nickname, which is * otherwise extracted from the file part of the * path. All nicknames must be unique. * * @param this The loader object. * @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 path The path to the adaptor file. * @param name The name of the adaptor. * @param nickname The name the loader should know this adaptor instance as. * * @return An error code. */ GATResult GATLoader_LoadAdaptor(GATLoader this, GATContext error_context, GATRegistry registry, GATTable_const system_config, GATTable_const instance_config, const char *path, const char *name, const char *nickname) { GAT_USES_STATUS(error_context, "GATLoader_LoadAdaptor"); struct AdaptorInstance *last = NULL; struct AdaptorInstance *instance = AdaptorInstance_Create(path, name, nickname); if (NULL != instance) { /* Check for duplication */ struct AdaptorInstance *current = NULL; for(current = this->list; NULL != current; last = current, current = current->next) { if (!strcmp(current->nickname, instance->nickname)) { GAT_CREATE_STATUS(GAT_DUPLICATE_ADAPTOR); } } } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { /* Ok, try to load it */ instance->handle = lt_dlopenext(instance->path); if (NULL != instance->handle) { GAT_CREATE_STATUS(LoadAdaptor(error_context, instance, registry, system_config, instance_config)); } else { GAT_CREATE_STATUS_MSG(GAT_FAILED_TO_LOAD_ADAPTOR, instance->path); } } if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { /* Everything worked, so add it to the list */ if (NULL != last) { last->next = instance; } else { this->list = instance; } } else { AdaptorInstance_Destroy(instance); } return GAT_RETURN_STATUS(); } /* Local functions */ /** AdaptorInstance_Create * Creates an adaptor structure. * The loader stores details of adaptors internally; * this function initialises a structure to hold this info. * * @param path The adaptor path. * @param name The adaptor's name. * @param nickname The adaptor's nickname. * * @return A new AdaptorInstance. */ static struct AdaptorInstance * AdaptorInstance_Create(const char *path, const char *name, const char *nickname) { struct AdaptorInstance *this; /* Create a new element for the adaptor list */ this = (struct AdaptorInstance *)malloc(sizeof(*this)); if(this) { this->next = NULL; this->path = GATUtil_strdup(path); if(!name) { this->name = CanonicaliseName(path); } else { this->name = GATUtil_strdup(name); } if(!nickname) { this->nickname = GATUtil_strdup(this->name); } else { this->nickname = GATUtil_strdup(nickname); } if(! this->path || ! this->name || ! this->nickname) { free(this->path); free(this->name); free(this->nickname); free(this); this = NULL; } } return this; } /** AdaptorInstance_Destroy * Destroys an adaptor structure. * The loader stores details of adaptors internally; * this function destroys a structure holding this info. * * @param this An AdaptorInstance to be destroyed. */ static void AdaptorInstance_Destroy(struct AdaptorInstance *object) { if(NULL != object) { free(object->path); free(object->name); free(object->nickname); /* the following was freed already by the ltdl library if(this->handle) { lt_dlclose(this->handle); } */ free(object); } } /** CanonicaliseName * Extract the canonical name of an adaptor from its full path name. * We need the name of the adaptor in order to invoke its * registration function. CanonicaliseName takes the path * to an adaptor and extracts the base filename from it. * Additionally, if it is a libtool library, it removes the "lib" * prefix which libtool insists on having. * * @param input The path to an adaptor file. * * @return A canonoical name for the adaptor. */ static char * CanonicaliseName(const char *original) { char *retval; const char *start; const char *end; char *pos; /* Find filename part of name */ start = strrchr(original, '/'); if(!start) { start = original; } else { start++; } /* Scan forward and end at any character not in [a-zA-Z0-9_-] */ for(end = start; *end && (isalnum(*end) || *end == '_' || *end == '-'); end++) { /* Do nothing */ } if(!strcmp(end,".la")) { /* It's a libtool library, which insists on having lib as * first three chars. */ if(start[0] == 'l' && start[1] == 'i' && start[2] == 'b') { start += 3; } } /* Allocate memory */ retval = (char *)malloc(end-start + 1); if(retval) { /* Copy data */ for(pos = retval; start < end ; start++, pos++) { *pos = *start; } *pos = 0; } return retval; } /** LoadAdaptor * Loads a given adaptor. * Given an AdaptorInstance, invokes its registration function and passes that * both a system and an instance configuration tables. * * @param instance The AdaptorInstance holding data about the adaptor. * @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. * * @return An error code. */ static GATResult LoadAdaptor (GATContext error_context, struct AdaptorInstance *instance, GATRegistry registry, GATTable_const system_config, GATTable_const instance_config) { GAT_USES_STATUS(error_context, "LoadAdaptor"); typedef GATResult (*registrationproc_t)(GATContext, GATRegistry, GATTable_const, GATTable_const, void *); registrationproc_t func = NULL; char *funcname = (char *)malloc(strlen(instance->name) + sizeof(REGISTRATION_SUFFIX) + 1); if (NULL != funcname) { /* try to find old entry point */ sprintf (funcname, "%s%s", instance->name, REGISTRATION_SUFFIX); func = (registrationproc_t)lt_dlsym (instance->handle, funcname); if (NULL != func) { GAT_CREATE_STATUS(func(error_context, registry, system_config, instance_config, instance->nickname)); } else { GAT_CREATE_STATUS(GAT_NO_ADAPTOR_REGISTRATION_FUNC); // GAT_DEBUG ("could not load adaptor\n"); } free (funcname); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); // GAT_DEBUG ("Mem-Failure\n"); } /* TODO: sometimes, no error seems to get issued on adaptor load * failure - needs fix. -- Andre. */ { char buffer[256]; snprintf (buffer, sizeof(buffer), "Loading adaptor %s", instance->nickname); GAT_TEST_START (buffer); GAT_TEST_TRACE (GAT_SUCCEEDED(GAT_CURRENT_STATUS()), error_context); GAT_TEST_STOP (); } return GAT_RETURN_STATUS(); }