- 2.0.0-0.6.2012041515snap
- Initial gfal 2.0 preview release
gfal2-v2.10.2-f5bac4127b0e17b5b613cc757c2fc34d257bd011/readme.html 0000664 0000000 0000000 00000005403 12617131713 0022572 0 ustar 00root root 0000000 0000000
gfal2
gfal2
Description
The Grid File Access Library 2 offers a POSIX interface to the distributed files system supported by WLCG.
Differents file systems are supported by a collections of GFAL 2 plugins, this is a non complete list:
- LFC (Logical File Catalog), with lfn://
- SRM (Storage Resource Manager) with srm://
- RFIO (Remote File I/O) with rfio://
- DCAP (Remote FTP for dCache ) with gsidcap://
- HTTP/Webdav with cluster, third party copy and client side credential support.
Installation
GFAL2 itself abstracts the access to different underlying storage systems - including local -, but in order to get
support for a given protocol, its corresponding plugin needs to be installed.
- gfal2-plugin-lfc
- gfal2-plugin-srm
- gfal2-plugin-rfio
- gfal2-plugin-dcap
- gfal2-plugin-http
For convenience we provide a package called gfal2-all, which will trigger the installation of all these packages.
gfal2-devel is required only for development.
A typical installation can be done as easy as bellow:
yum install gfal2-all gfal2-devel
Shipped separatly there is also available a plugin for XRootD (root://) protocol: gfal2-plugin-xrootd
API Documentation
Doxygen documentation
You can also have a look at the examples folder to see some simple usage of the API.
License
This software is licensed under the Apache 2 License.
See LICENSE for details.
Release Notes
See RELEASE-NOTES for a detailed changelog.
Contact
You can notify bugs or ask for feature requests via
- Tracker
- https://its.cern.ch/jira/browse/DMC/component/10808
- Mailing list
- dmc-support@cern.ch
gfal2-v2.10.2-f5bac4127b0e17b5b613cc757c2fc34d257bd011/setup_test_env.sh 0000775 0000000 0000000 00000000224 12617131713 0024051 0 ustar 00root root 0000000 0000000 #!/bin/bash
export GFAL_PLUGIN_DIR=`pwd`/plugins/
export GFAL_CONFIG_DIR=`pwd`/test/conf_test/
export LD_LIBRARY_PATH=`pwd`/src:$LD_LIBRARY_PATH
$@
gfal2-v2.10.2-f5bac4127b0e17b5b613cc757c2fc34d257bd011/setup_test_env_isolated.sh 0000664 0000000 0000000 00000000241 12617131713 0025731 0 ustar 00root root 0000000 0000000 #!/bin/bash
export GFAL_CONFIG_DIR=`pwd`/test/conf_test/
## export etics needed configs
echo "## print environment"
env
echo "## end print environment"
$@
gfal2-v2.10.2-f5bac4127b0e17b5b613cc757c2fc34d257bd011/setup_test_env_var.sh 0000775 0000000 0000000 00000000356 12617131713 0024727 0 ustar 00root root 0000000 0000000 #!/bin/bash
export LFC_HOST=cvitblfc1.cern.ch
export LCG_GFAL_INFOSYS=certtb-bdii-top.cern.ch:2170
export GFAL_PLUGIN_DIR=`pwd`/plugins/
export GFAL_CONFIG_DIR=`pwd`/../dist/etc/gfal2/
export LD_LIBRARY_PATH=`pwd`/src:$LD_LIBRARY_PATH
$@
gfal2-v2.10.2-f5bac4127b0e17b5b613cc757c2fc34d257bd011/src/ 0000775 0000000 0000000 00000000000 12617131713 0021234 5 ustar 00root root 0000000 0000000 gfal2-v2.10.2-f5bac4127b0e17b5b613cc757c2fc34d257bd011/src/CMakeLists.txt 0000664 0000000 0000000 00000000756 12617131713 0024004 0 ustar 00root root 0000000 0000000 cmake_minimum_required (VERSION 2.6)
# Shared utilities can be compiled as static, and then
# included at linking time
add_subdirectory (utils)
set(gfal2_utils_src ${gfal2_utils_src} PARENT_SCOPE)
set(gfal2_utils_c_src ${gfal2_utils_c_src} PARENT_SCOPE)
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/utils)
# Core library
if (MAIN_CORE)
add_subdirectory (core)
# Command line tool to get GFAL2 version
add_subdirectory (version)
endif (MAIN_CORE)
# Plugins
add_subdirectory (plugins)
gfal2-v2.10.2-f5bac4127b0e17b5b613cc757c2fc34d257bd011/src/core/ 0000775 0000000 0000000 00000000000 12617131713 0022164 5 ustar 00root root 0000000 0000000 gfal2-v2.10.2-f5bac4127b0e17b5b613cc757c2fc34d257bd011/src/core/CMakeLists.txt 0000664 0000000 0000000 00000006413 12617131713 0024730 0 ustar 00root root 0000000 0000000 cmake_minimum_required (VERSION 2.6)
# Sources needed for the core library
file (GLOB src_cancel "cancel/*.c*")
file (GLOB src_common "common/*.c" "common/future/*.c")
file (GLOB src_config "config/*.c")
file (GLOB src_exceptions "exceptions/*.c*")
file (GLOB src_gconfig "g_config_manager/*.c*")
file (GLOB src_file "file/*.c*")
file (GLOB src_global "global/*c*")
file (GLOB src_logger "logger/*.c*")
file (GLOB src_posix "posix/*.c*")
# Core library
add_definitions(-D__GFAL2_BUILD__)
add_library (gfal2 SHARED ${src_cancel}
${src_common}
${src_config}
${src_gconfig}
${src_file}
${src_global}
${src_logger}
${src_posix}
${src_exceptions}
${gfal2_utils_c_src})
target_link_libraries (gfal2 "stdc++" ) # hotfix for libc TLS init bug in EPEL 5
target_link_libraries (gfal2 ${GLIB2_PKG_LIBRARIES} ${GTHREAD2_PKG_LIBRARIES})
target_link_libraries (gfal2 "dl")
set_target_properties (gfal2 PROPERTIES
VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}
SOVERSION ${VERSION_MAJOR}
CLEAN_DIRECT_OUTPUT 1
OUTPUT_NAME ${OUTPUT_NAME_MAIN})
# pkgconfig for gfal2
add_PkgConfigFile_for_Library ("gfal2.pc" gfal2
HEADER_DIRS "gfal2"
CFLAGS " -D_FILE_OFFSET_BITS=64 "
DESCRIPTION "GFAL 2.0 pkgconfig file"
REQUIRES "glib-2.0")
# Install core library
install (TARGETS gfal2 LIBRARY DESTINATION ${LIB_INSTALL_DIR})
install (FILES ${CMAKE_CURRENT_BINARY_DIR}/gfal2.pc DESTINATION ${PKGCONFIG_FILES_DIR})
# Install development headers
install (FILES "gfal_api.h" "gfal_plugins_api.h"
DESTINATION ${INCLUDE_INSTALL_DIR}/gfal2/)
install (FILES "cancel/gfal_cancel.h"
DESTINATION ${INCLUDE_INSTALL_DIR}/gfal2/cancel)
install (FILES "logger/gfal_logger.h"
DESTINATION ${INCLUDE_INSTALL_DIR}/gfal2/logger)
install (FILES "posix/gfal_posix_api.h"
DESTINATION ${INCLUDE_INSTALL_DIR}/gfal2/posix)
install (FILES "common/gfal_constants.h"
"common/gfal_common_plugin_interface.h"
"common/gfal_prototypes.h"
"common/gfal_common_plugin.h"
"common/gfal_types.h"
"common/gfal_deprecated.h"
"common/gfal_common_err_helpers.h"
DESTINATION ${INCLUDE_INSTALL_DIR}/gfal2/common)
install (FILES "global/gfal_global.h"
DESTINATION ${INCLUDE_INSTALL_DIR}/gfal2/global)
install (FILES "config/gfal_config.h"
DESTINATION ${INCLUDE_INSTALL_DIR}/gfal2/config)
install (FILES "g_config_manager/g_config_manager.h"
DESTINATION ${INCLUDE_INSTALL_DIR}/gfal2/g_config_manager)
install (FILES "file/gfal_file_api.h"
DESTINATION ${INCLUDE_INSTALL_DIR}/gfal2/file)
install (FILES "fdesc/gfal_file_handle.h"
DESTINATION ${INCLUDE_INSTALL_DIR}/gfal2/fdesc)
# Transfer library
if (MAIN_TRANSFER)
add_subdirectory (transfer)
endif (MAIN_TRANSFER)
gfal2-v2.10.2-f5bac4127b0e17b5b613cc757c2fc34d257bd011/src/core/cancel/ 0000775 0000000 0000000 00000000000 12617131713 0023411 5 ustar 00root root 0000000 0000000 gfal2-v2.10.2-f5bac4127b0e17b5b613cc757c2fc34d257bd011/src/core/cancel/gfal_cancel.c 0000664 0000000 0000000 00000006470 12617131713 0026002 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) CERN 2013-2015
*
* Copyright (c) Members of the EMI Collaboration. 2010-2013
* See http://www.eu-emi.eu/partners for details on the copyright
* holders.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include
#include
#include
#include
#include
//
// @author : Devresse Adrien
//
// cancel logic of gfal 2
//
int gfal2_cancel(gfal2_context_t context)
{
if (!context)
return -1;
else if (context->cancel == TRUE) // avoid recursive calls
return 0;
g_mutex_lock(context->mux_cancel);
const int n_cancel = g_atomic_int_get(&(context->running_ops));
context->cancel = TRUE;
g_hook_list_invoke(&context->cancel_hooks, TRUE);
g_mutex_unlock(context->mux_cancel);
while ((g_atomic_int_get(&(context->running_ops))) > 0) {
usleep(50);
}
context->cancel = FALSE;
return n_cancel;
}
gboolean gfal2_is_canceled(gfal2_context_t context)
{
return context->cancel;
}
// Increase number of the running task for the cancel logic
// Return negative value if task is canceled
int gfal2_start_scope_cancel(gfal2_context_t context, GError** err)
{
if (context && context->cancel) {
g_set_error(err, gfal_cancel_quark(), ECANCELED,
"[gfal2_cancel] operation canceled by user");
return -1;
}
g_atomic_int_inc(&(context->running_ops));
return 0;
}
int gfal2_end_scope_cancel(gfal2_context_t context)
{
if (context)
(void) g_atomic_int_dec_and_test(&(context->running_ops));
return 0;
}
struct gfal_hook_data_s {
void* userdata;
gfal2_context_t context;
gfal_cancel_hook_cb cb;
};
static void gfal_ghook_cancel_wrapper(gpointer data)
{
struct gfal_hook_data_s* d = data;
d->cb(d->context, d->userdata);
}
gfal_cancel_token_t gfal2_register_cancel_callback(gfal2_context_t context,
gfal_cancel_hook_cb cb, void* userdata)
{
g_assert(context && cb);
g_mutex_lock(context->mux_cancel);
GHook* h = g_hook_alloc(&context->cancel_hooks);
struct gfal_hook_data_s* d = g_new(struct gfal_hook_data_s, 1);
d->context = context;
d->userdata = userdata;
d->cb = cb;
h->data = d;
h->destroy = &g_free;
h->func = &gfal_ghook_cancel_wrapper;
g_hook_append(&context->cancel_hooks, h);
g_mutex_unlock(context->mux_cancel);
return (gfal_cancel_token_t) h;
}
void gfal2_remove_cancel_callback(gfal2_context_t context,
gfal_cancel_token_t token)
{
g_assert(context && token);
g_mutex_lock(context->mux_cancel);
GHook* cb = (GHook*) token;
g_hook_destroy_link(&context->cancel_hooks, cb);
g_mutex_unlock(context->mux_cancel);
}
GQuark gfal_cancel_quark()
{
return g_quark_from_string("[gfal2_cancel]");
}
gfal2-v2.10.2-f5bac4127b0e17b5b613cc757c2fc34d257bd011/src/core/cancel/gfal_cancel.h 0000664 0000000 0000000 00000005762 12617131713 0026012 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) CERN 2013-2015
*
* Copyright (c) Members of the EMI Collaboration. 2010-2013
* See http://www.eu-emi.eu/partners for details on the copyright
* holders.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#ifndef GFAL_CANCEL_H_
#define GFAL_CANCEL_H_
#if !defined(__GFAL2_H_INSIDE__) && !defined(__GFAL2_BUILD__)
# warning "Direct inclusion of gfal2 headers is deprecated. Please, include only gfal_api.h or gfal_plugins_api.h"
#endif
#include
#include
#include
/**
* @file gfal_cancel.h
*
* canceling operation for gfal 2.0
*
**/
#ifdef __cplusplus
extern "C"
{
#endif
typedef struct gfal_cancel_token_s* gfal_cancel_token_t;
typedef void (*gfal_cancel_hook_cb)(gfal2_context_t context, void* userdata);
/**
* @brief cancel operation
*
* cancel all pending operation on the given context
* blocking until all operations finish
* all operations will return and trigger an ECANCELED if interrupted.
* Thread safe
* @param context : gfal 2 context
* @return number of operations canceled
*/
int gfal2_cancel(gfal2_context_t context);
/**
* @brief cancel status
* @return true if \ref gfal2_cancel has been called
*
* @param context
* @return true if success
*/
gboolean gfal2_is_canceled(gfal2_context_t context);
/**
* Register a cancel hook, called in each cancellation
* Thread-safe
*/
gfal_cancel_token_t gfal2_register_cancel_callback(gfal2_context_t context,
gfal_cancel_hook_cb cb, void* userdata);
/**
* Remove a cancel hook
* Thread-safe
*/
void gfal2_remove_cancel_callback(gfal2_context_t context, gfal_cancel_token_t token);
/**
* Mark the beginning of a cancellable scope
*/
int gfal2_start_scope_cancel(gfal2_context_t context, GError** err);
/**
* Mark the end of a cancellable scope
*/
int gfal2_end_scope_cancel(gfal2_context_t context);
/**
* GQuark of a cancel action
*/
GQuark gfal_cancel_quark();
/** Convenience macro for gfal2_start_scope_cancel */
#define GFAL2_BEGIN_SCOPE_CANCEL(context, ret_err_value, err) \
do{ \
if(gfal2_start_scope_cancel(context, err) < 0){ \
return ret_err_value; \
} \
}while(0)
/** Convenience macro for gfal2_end_scope_cancel */
#define GFAL2_END_SCOPE_CANCEL(context) \
gfal2_end_scope_cancel(context)
#ifdef __cplusplus
}
#endif
#endif /* GFAL_CANCEL_H_ */
gfal2-v2.10.2-f5bac4127b0e17b5b613cc757c2fc34d257bd011/src/core/common/ 0000775 0000000 0000000 00000000000 12617131713 0023454 5 ustar 00root root 0000000 0000000 gfal2-v2.10.2-f5bac4127b0e17b5b613cc757c2fc34d257bd011/src/core/common/future/ 0000775 0000000 0000000 00000000000 12617131713 0024766 5 ustar 00root root 0000000 0000000 gfal2-v2.10.2-f5bac4127b0e17b5b613cc757c2fc34d257bd011/src/core/common/future/glib.c 0000664 0000000 0000000 00000004551 12617131713 0026054 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) CERN 2013-2015
*
* Copyright (c) Members of the EMI Collaboration. 2010-2013
* See http://www.eu-emi.eu/partners for details on the copyright
* holders.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include
#include "glib.h"
#if (GLIB_CHECK_VERSION(2,16,0) != TRUE) // add code of glib 2.16 for link with a very old glib version
static void
g_error_add_prefix (gchar **string,
const gchar *format,
va_list ap)
{
gchar *oldstring;
gchar *prefix;
prefix = g_strdup_vprintf (format, ap);
oldstring = *string;
*string = g_strconcat (prefix, oldstring, NULL);
g_free (oldstring);
g_free (prefix);
}
void
g_propagate_prefixed_error (GError **dest,
GError *src,
const gchar *format,
...)
{
g_propagate_error (dest, src);
if (dest && *dest)
{
va_list ap;
va_start (ap, format);
g_error_add_prefix (&(*dest)->message, format, ap);
va_end (ap);
}
}
void
g_prefix_error (GError **err,
const gchar *format,
...)
{
if (err && *err)
{
va_list ap;
va_start (ap, format);
g_error_add_prefix (&(*err)->message, format, ap);
va_end (ap);
}
}
#endif
#if (GLIB_CHECK_VERSION(2,18,0) != TRUE)
void
g_set_error_literal (GError **err,
GQuark domain,
gint code,
const gchar *message)
{
g_set_error(err, domain, code, "%s", message);
}
#endif
#if (GLIB_CHECK_VERSION(2,28,0) != TRUE)
void g_list_free_full(GList *list, GDestroyNotify free_func)
{
GList* tmp_list= list;
while( tmp_list != NULL){
free_func(tmp_list->data);
tmp_list = g_list_next(tmp_list);
}
g_list_free(list);
}
#endif
gfal2-v2.10.2-f5bac4127b0e17b5b613cc757c2fc34d257bd011/src/core/common/future/glib.h 0000664 0000000 0000000 00000002377 12617131713 0026065 0 ustar 00root root 0000000 0000000 /**
* @file glib.h
* @brief Advanced functions of glib for the old versions
* @author Devresse Adrien
**/
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
#include
// GError
#if (GLIB_CHECK_VERSION(2,16,0) != TRUE)
#define ERROR_OVERWRITTEN_WARNING "GError set over the top of a previous GError or uninitialized memory.\n"
void g_propagate_prefixed_error (GError **dest,
GError *src,
const gchar *format,
...) G_GNUC_PRINTF (3, 4);
void g_prefix_error (GError **err,
const gchar *format,
...) G_GNUC_PRINTF (2, 3);
#endif
#if (GLIB_CHECK_VERSION(2,18,0) != TRUE)
void g_set_error_literal (GError **err,
GQuark domain,
gint code,
const gchar *message);
#endif
// GList
#if (GLIB_CHECK_VERSION(2,28,0) != TRUE)
void g_list_free_full(GList *list, GDestroyNotify free_func);
#endif
#ifdef __cplusplus
}
#endif
gfal2-v2.10.2-f5bac4127b0e17b5b613cc757c2fc34d257bd011/src/core/common/gfal_common_all.c 0000664 0000000 0000000 00000006226 12617131713 0026737 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) CERN 2013-2015
*
* Copyright (c) Members of the EMI Collaboration. 2010-2013
* See http://www.eu-emi.eu/partners for details on the copyright
* holders.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
/* the version should be set by a "define" at the makefile level */
static const char *gfalversion = VERSION;
// initialization
__attribute__((constructor))
void core_init()
{
#if (!GLIB_CHECK_VERSION (2, 32, 0))
if (!g_thread_supported())
g_thread_init(NULL);
#endif
}
// Initiate a gfal's context with default parameters for use
gfal2_context_t gfal_initG (GError** err)
{
GError* tmp_err=NULL;
gfal2_context_t handle = g_new0(struct gfal_handle_,1);// clear allocation of the struct and set defautl options
if (handle == NULL) {
errno = ENOMEM;
g_set_error(err, gfal2_get_plugins_quark(), ENOMEM,
"[gfal_initG] bad allocation, no more memory free");
return NULL;
}
handle->plugin_opt.plugin_number= 0;
if((handle->conf = gfal_conf_new(&tmp_err)) && !tmp_err){
// load and instantiate all the plugins
gfal_plugins_instance(handle, &tmp_err);
// cancel logic init
handle->cancel = FALSE;
handle->running_ops = 0;
handle->mux_cancel = g_mutex_new();
g_hook_list_init(&handle->cancel_hooks, sizeof(GHook));
}
if (tmp_err) {
if (handle && handle->conf)
gfal_conf_delete(handle->conf);
g_free(handle);
handle = NULL;
}
else {
handle->client_info = g_ptr_array_new();
}
G_RETURN_ERR(handle, tmp_err, err);
}
// free a gfal's handle, safe if null
void gfal_handle_freeG(gfal2_context_t handle)
{
if (handle == NULL)
return;
gfal_plugins_delete(handle, NULL);
gfal_dir_handle_container_delete(&(handle->fdescs));
gfal_conf_delete(handle->conf);
g_list_free(handle->plugin_opt.sorted_plugin);
g_mutex_free(handle->mux_cancel);
g_hook_list_clear(&handle->cancel_hooks);
g_free(handle->agent_name);
g_free(handle->agent_version);
g_ptr_array_foreach(handle->client_info, gfal_free_keyvalue, NULL);
g_free(handle);
handle = NULL;
}
// return a string of the current gfal version
const char *gfal2_version()
{
return gfalversion;
}
char *gfal_version()
{
return (char*) gfalversion;
}
gfal2-v2.10.2-f5bac4127b0e17b5b613cc757c2fc34d257bd011/src/core/common/gfal_common_dir_handle.c 0000664 0000000 0000000 00000004225 12617131713 0030255 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) CERN 2013-2015
*
* Copyright (c) Members of the EMI Collaboration. 2010-2013
* See http://www.eu-emi.eu/partners for details on the copyright
* holders.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include
#include
#include
#include
#include "gfal_constants.h"
#include "gfal_types.h"
#include "gfal_common_filedescriptor.h"
#include "gfal_common_dir_handle.h"
#include "gfal_common_err_helpers.h"
pthread_mutex_t m_dir_container = PTHREAD_MUTEX_INITIALIZER;
// return the singleton of the file descriptor container for the directories
gfal_fdesc_container_handle gfal_dir_handle_container_instance(
gfal_descriptors_container* fdescs, GError** err)
{
gfal_fdesc_container_handle dir_handle = fdescs->dir_container;
if (dir_handle == NULL) {
pthread_mutex_lock(&m_dir_container);
if (fdescs->dir_container == NULL) {
dir_handle = gfal_file_descriptor_handle_create(NULL);
fdescs->dir_container = dir_handle;
if (!dir_handle)
gfal2_set_error(err, gfal2_get_core_quark(), EIO, __func__,
"Error while init directories file descriptor container");
}
pthread_mutex_unlock(&m_dir_container);
}
return dir_handle;
}
void gfal_dir_handle_container_delete(gfal_descriptors_container* fdescs)
{
pthread_mutex_lock(&m_dir_container);
if (fdescs->dir_container && fdescs->dir_container->container)
g_hash_table_destroy(fdescs->dir_container->container);
free(fdescs->dir_container);
fdescs->dir_container = NULL;
pthread_mutex_unlock(&m_dir_container);
}
gfal2-v2.10.2-f5bac4127b0e17b5b613cc757c2fc34d257bd011/src/core/common/gfal_common_dir_handle.h 0000664 0000000 0000000 00000002131 12617131713 0030254 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) CERN 2013-2015
*
* Copyright (c) Members of the EMI Collaboration. 2010-2013
* See http://www.eu-emi.eu/partners for details on the copyright
* holders.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#ifndef GFAL_COMMON_DIR_HANDLE_H_
#define GFAL_COMMON_DIR_HANDLE_H_
#include "gfal_constants.h"
#include "gfal_prototypes.h"
gfal_fdesc_container_handle gfal_dir_handle_container_instance(gfal_descriptors_container* fdescs, GError** err);
void gfal_dir_handle_container_delete(gfal_descriptors_container* fdescs);
#endif /* GFAL_COMMON_DIR_HANDLE_H_ */
gfal2-v2.10.2-f5bac4127b0e17b5b613cc757c2fc34d257bd011/src/core/common/gfal_common_err_helpers.c 0000664 0000000 0000000 00000004347 12617131713 0030503 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) CERN 2013-2015
*
* Copyright (c) Members of the EMI Collaboration. 2010-2013
* See http://www.eu-emi.eu/partners for details on the copyright
* holders.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include
#include
#include
#include "gfal_common_err_helpers.h"
#if (GLIB_CHECK_VERSION(2,16,0) != TRUE)
#include "future/glib.h"
#endif
void gfal2_set_error(GError **err, GQuark domain, gint code,
const gchar *function, const gchar *format, ...)
{
char buffer[512];
va_list args;
va_start(args, format);
vsnprintf(buffer, sizeof(buffer), format, args);
va_end(args);
if (gfal2_log_get_level() >= G_LOG_LEVEL_DEBUG)
g_set_error(err, domain, code, "[%s] %s", function, buffer);
else
g_set_error_literal(err, domain, code, buffer);
}
void gfal2_propagate_prefixed_error_extended(GError **dest, GError *src,
const gchar *function, const gchar *format, ...)
{
if (dest == NULL) {
g_error_free(src);
return;
}
if (gfal2_log_get_level() >= G_LOG_LEVEL_DEBUG) {
if (src->message[0] == '[')
g_propagate_prefixed_error(dest, src, "[%s]", function);
else
g_propagate_prefixed_error(dest, src, "[%s] ", function);
}
else {
*dest = src;
}
if (format != NULL) {
char buffer[512];
va_list args;
va_start(args, format);
vsnprintf(buffer, sizeof(buffer), format, args);
va_end(args);
g_prefix_error(dest, "%s", buffer);
}
}
void gfal2_propagate_prefixed_error(GError **dest, GError *src,
const gchar *function)
{
gfal2_propagate_prefixed_error_extended(dest, src, function, NULL);
}
gfal2-v2.10.2-f5bac4127b0e17b5b613cc757c2fc34d257bd011/src/core/common/gfal_common_err_helpers.h 0000664 0000000 0000000 00000005173 12617131713 0030506 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) CERN 2013-2015
*
* Copyright (c) Members of the EMI Collaboration. 2010-2013
* See http://www.eu-emi.eu/partners for details on the copyright
* holders.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#ifndef GFAL_COMMON_ERR_HELPERS_H_
#define GFAL_COMMON_ERR_HELPERS_H_
#include
#include
#include
#if !defined(__GFAL2_H_INSIDE__) && !defined(__GFAL2_BUILD__)
# warning "Direct inclusion of gfal2 headers is deprecated. Please, include only gfal_api.h or gfal_plugins_api.h"
#endif
#ifdef __cplusplus
extern "C" {
#endif
/** @def Wraps g_set_error and appends the function name
* only if DEBUG is enabled
*/
void gfal2_set_error(GError **err,
GQuark domain,
gint code,
const gchar *function,
const gchar *format,
...) G_GNUC_PRINTF (5, 6);
/** @def Wraps g_propagate_prefixed_error, and appends
* the function name only if DEBUG is enabled
* fmt is always appended
*/
void gfal2_propagate_prefixed_error_extended(GError **dest,
GError *src,
const gchar *function,
const gchar *format,
...) G_GNUC_PRINTF (4, 5);
/** @def Wraps g_propagate_prefixed_error, and appends
* the function name only if DEBUG is enabled
*/
void gfal2_propagate_prefixed_error(GError **dest,
GError *src,
const gchar *function);
#ifdef __cplusplus
}
#endif
/** @def macro for error error report on args
*
*/
#define g_return_val_err_if_fail(exp, val, err, msg) if(!(exp)){ g_set_error(err, gfal2_get_core_quark(), EINVAL, msg); return val; }
/** @def macro for one-line return with error management exception-like
*/
#define G_RETURN_ERR(ret, tmp_err, err) \
if(tmp_err)\
gfal2_propagate_prefixed_error(err, tmp_err, __func__);\
return ret
#endif /* GFAL_COMMON_ERR_HELPERS_H_ */
gfal2-v2.10.2-f5bac4127b0e17b5b613cc757c2fc34d257bd011/src/core/common/gfal_common_file_handle.c 0000664 0000000 0000000 00000003271 12617131713 0030416 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) CERN 2013-2015
*
* Copyright (c) Members of the EMI Collaboration. 2010-2013
* See http://www.eu-emi.eu/partners for details on the copyright
* holders.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include
#include
#include
#include
#include "gfal_constants.h"
#include "gfal_types.h"
#include "gfal_common_filedescriptor.h"
#include "gfal_common_file_handle.h"
#include "gfal_common_err_helpers.h"
gfal_fdesc_container_handle gfal_file_handle_container_instance(
gfal_descriptors_container* fdescs, GError** err)
{
gfal_fdesc_container_handle file_handle = fdescs->file_container;
if (file_handle != NULL)
return file_handle;
else {
file_handle = fdescs->file_container =
gfal_file_descriptor_handle_create(NULL);
if (!file_handle)
gfal2_set_error(err, gfal2_get_plugins_quark(), EIO, __func__,
"Error while init directories file descriptor container");
return file_handle;
}
}
void gfal_file_handle_container_delete(gfal_descriptors_container* fdescs)
{
free(fdescs->file_container);
fdescs->dir_container = NULL;
}
gfal2-v2.10.2-f5bac4127b0e17b5b613cc757c2fc34d257bd011/src/core/common/gfal_common_file_handle.h 0000664 0000000 0000000 00000002136 12617131713 0030422 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) CERN 2013-2015
*
* Copyright (c) Members of the EMI Collaboration. 2010-2013
* See http://www.eu-emi.eu/partners for details on the copyright
* holders.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#ifndef GFAL_COMMON_FILE_HANDLE_H_
#define GFAL_COMMON_FILE_HANDLE_H_
#include "gfal_constants.h"
#include "gfal_prototypes.h"
gfal_fdesc_container_handle gfal_file_handle_container_instance(gfal_descriptors_container* fdescs, GError** err);
void gfal_file_handle_container_delete(gfal_descriptors_container* fdescs);
#endif /* GFAL_COMMON_FILE_HANDLE_H_ */
gfal2-v2.10.2-f5bac4127b0e17b5b613cc757c2fc34d257bd011/src/core/common/gfal_common_filedescriptor.c 0000664 0000000 0000000 00000014760 12617131713 0031207 0 ustar 00root root 0000000 0000000 /*
* Copyright (c) CERN 2013-2015
*
* Copyright (c) Members of the EMI Collaboration. 2010-2013
* See http://www.eu-emi.eu/partners for details on the copyright
* holders.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include